Arduino работа со строками

Объект String в Arduino и команды через последовательный порт

Сколько ни изучаю Arduino, она не перестаёт удивлять меня своей простотой. К примеру, собирая и тестируя систему «умного дома», я думал, что подача команд с компьютера будет самой сложной частью — это же надо принимать строку из последовательного порта, распознавать её, следить, чтобы не возникало ошибок. Однако оказалось достаточно почитать сайт Arduino.cc да потестить пару примеров, как стало ясно — разработчики постарались, чтобы оградить нас от написания длинного и унылого кода. К слову сказать, с задачей в итоге я справился за вечер, под конец даже подумывая: «а какую бы ещё команду прикрутить. «

Итак, предположим, вы уже умеете программировать Arduino и можете разобраться в своём или чужом коде. Одним из основных понятий являются переменные и их типы. Ну-ка навскидку? byte, int, long, char, string. Два последних — по сути одно и то же, ибо string — массив переменных типа char (Кто-нибудь сейчас должен возразить, что char представляется в виде байтового числа, но речь не об этом). Итак, всё, что принимается из последовательного порта, следует читать, как char:

Это первый пример, который может прид ти в голову . Создаём пустую строку, затем, если есть, что читать из последовательного порта, посимвольно её заполняем. Функция Serial.available() возвращает количество байт, доступных для чтения, а если там пусто — то 0, очевидно. Этим можно пользоваться, чтобы узнать длину поданной команды, хотя мы и так её узнаем в приведённом примере — это величина переменной z на выходе из цикла. Да, строка из пробелов (ASCII код пробела — не ноль!) — это терпимо, но всё-таки не очень хорошо, по возможности избегайте этого. А догадливый читатель сможет похвалить себя, если сразу догадается, что стоит исправить в вышеприведённом коде. Для тех, кто не догадался — подсказка: char inchar[6] — строка длиной 6 символов. Если строке присваивается значение, компилятор позволяет не указывать явно её длину, поэтому в примере квадратные скобки пустые.

Кстати, не стоит забывать прописать в setup()

А во встроенном мониторе порта, в который, собственно, и будут отправляться команды, указать скорость — 9600 бод, иначе увидите крякозябры.

Далее, что делать с полученной строкой? Те, кто предложат сравнивать побайтово строку с известными значениями (а такая мысль наверняка кому-то может придти в голову) после прочтения статьи переместятся вперёд во времени лет на 20. Из прошлого, я имею в виду 🙂

Поиск по документации Arduino IDE даёт два варианта, что такое string. Это сам string как строка char’ов, и String, являющийся объектом. Что такое объект? Согласно википедии, это «некоторая сущность в виртуальном пространстве, обладающая определённым состоянием и поведением, имеющая заданные значения свойств (атрибутов) и операций над ними (методов)». Другими словами — переменная со встроенными функциями, делающими что-то с этой переменной. Чтобы начать работать с этим объектом, напишем что-нибудь такого вида:

Здесь к input будут добавляться всё новые символы, пока буфер не иссякнет. Тогда можно будет анализировать полученную строку, например, так:

Код использует очень удобные функции, встроенные в объект String. Это startsWith(), которая возвращает единицу, если строка начинается с того, что записано в скобках, substring(), возвращающая кусок строки, начинающийся в данном случае с 5-го символа (считается, начиная с нуля), trim(), отбрасывающий всё лишнее по краям строки, ну и toInt(), превращающий то, что осталось, в число типа Int. Это число неплохо ещё и проверить на предмет попадания в рамки ожидаемого. В итоге, если дать команду «PauSe 567 «, то МК подождёт ровно 567 миллисекунд.

Про trim() стоит написать отдельно. Он нужен не только для того, чтобы отбросить пробел в начале получившейся строки, но в первую очередь — чтобы избавиться от символов в её конце. Это служебные символы, добавляющиеся при отправке сообщения — NL (новая строка) и CR (возврат каретки). Они нужны как раз для того, чтобы сигнализировать о конце команды, но могут и помешать. Поэтому, несмотря на то, что в мониторе порта можно выбрать, какие из этих символов посылать или не посылать ничего, лучше перестраховаться. Тем более, что делается это в одну строчку кода.

А вот и список функций (методов) объекта String.

charAt() — возвращает символ, стоящий на указанном месте

concat() — функция конкатенации, т.е слияния двух строк в одну. Правда string1 = string1 + string2 это то же самое, что и string1.concat(string1, string2), а записывается проще и понятнее.

equals() — возвращает единицу, если строка посимвольно равна тому, что написано в скобках. Есть ещё equalsIgnoreCase(), который игнорирует регистр (верхний или нижний)

endsWith() — который работает аналогично startsWith()

indexOf() — возвращающий место в строке символа(или строки) в скобках. Ищет с конца и возвращает -1, если не найдено.

length() — выдающий длину строки

setCharAt() — требующий место и символ, который надо поставить на это место, например: string1.setCharAt(3, ‘d’) поставит d третьим символом в строке взамен того, что там стояло

  • И ещё несколько других, которые вряд ли вам понадобятся, если вы не в силах залезть на arduino.cc и прочитать о них 🙂
  • Вот и всё, что хотел рассказать. Надеюсь, эта статья поможет не бояться ООП и научить вашего домашнего робота на Arduino повиноваться сигналам с компа

    Arduino String – работа со строками в ардуино

    Arduino String – основная библиотека для работы со строками в ардуино. С ее помощью существенно упрощается использование массивов символов и строк в скетче. Объект типа String содержит множество полезных функций для создания и объединения строк, преобразований string to int (парсинг чисел) и int to string (форматирование чисел). Строки используются практически в любых проектах, поэтому и вероятность встретить String в скетче очень высока. В этой статье мы постараемся рассмотреть основные методы этого класса и наиболее часто возникающие ситуации.

    Для чего нужен String в ардуино

    Стандартным способом работы со строками в языке C является использование массива символов. Это все означало необходимость работы с указателями и понимания адресной арифметики. В ардуино и C++ у программистов появилось гораздо больше возможностей. Все “низкоуровневые” операции по работе со строкой выделены в отдельный класс, а для основных операций даже переопределены операторы. Например, для объединения срок мы просто используем хорошо знакомый знак “+”, а не зубодробильные функции типа malloc и strcpy. С помощью String мы работаем со строкой как с целым объектом, а не рассматриваем его как массив символов. Это позволяет сосредоточиться на логике скетча, а не деталях реализации хранения символов в памяти.

    Естественно, у любого “упрощения” всегда есть свои подводные камни. String всегда использует больше оперативной памяти и в некоторых случаях функции класса могут медленнее обрабатываться. Поэтому в реальных больших проектах придется тщательно взвешивать все плюсы и минусы и не забывать, что никто не мешает нам работать со строками в стиле С. Все обычные функции обработки массивов char остаются в нашем арсенале и в arduino.

    Создание строк в ардуино с помощью String

    В ардуино у нас есть несколько способов создать строку, приведем основные:

    • char myCharStr [ ] = “Start”; – массив типа char с завершающим пустым символом;
    • String myStr = “Start”; – объявляем переменную, создаем экземпляр класса String и записываем в него константу-строку.
    • String myStr = String(“Start”); – аналогичен предыдущему: создаем строку из константы
    • String myStr(myCharStr); – создаем объект класса String с помощью конструктра, принимающего на вход массив типа char и создающего из char String.
    • String myStr = String(50); – создаем строку из целого числа (преобразование int to string).
    • String myStr = String(30, H); – создаем строку – представление числа в 16-чной системе (HEX to String)
    • String myStr = String(16, B); – создаем строку – представление числа в двоичной системе (Byte to String).

    Каждый раз, когда мы объявляем в коде строку с использованием двойных кавычек, мы создаем неявный объект класса String, являющийся константой. При этом обязательно использование именно двойных кавычек: “String” – это строка. Одинарные кавычки нужны для обозначения отдельных символов. ‘S’ – это символ.

    Функции и методы класса String

    Для работы со строками в String предусмотрено множество полезных функций. Приведем краткое описание каждой из них:

    • String() – конструктор, создает элемент класса данных string. Возвращаемого значения нет. Есть множество вариантов, позволяющих создавать String из строк, символов, числе разных форматов.
    • charAt() возвращает указанный в строке элемент. Возвращаемое значение – n-ный символ строки.
    • compareTo() – функция нужна для проверки двух строк на равенство и позволяет выявить, какая из них идет раньше по алфавиту. Возвращаемые значения: отрицательное число, если строка 1 идет раньше строки 2 по алфавиту; 0 – при эквивалентности двух строк; положительное число, если вторая строка идет раньше первой в алфавитном порядке.
    • concat() – функция, которая объединяет две строки в одну. Итог сложения строк объединяется в новый объект String.
    • startsWith() – функция показывает, начинается ли строка с символа, указанного во второй строке. Возвращаемое значение: true, если строка начинается с символа из второй строки, в ином случае false.
    • endsWith() – работает так же, как и startsWith(), но проверяет уже окончание строки. Также возвращает значения true и false.
    • equals() – сравнивает две строки с учетом регистра, т.е. строки «start» и «START» не будут считаться эквивалентными. Возвращаемые значения: true при эквивалентности, false в ином случае.
    • equalsIgnoreCase() – похожа на equals, только эта функция не чувствительна к регистру символов.
    • getBytes() – позволяет скопировать символы указанной строки в буфер.
    • indexOf() – выполняет поиск символа в строке с начала. Возвращает значение индекса подстроки val или -1, если подстрока не обнаружена.
    • lastIndexOf() –выполняет поиск символа в строке с конца.
    • length() – указывает длину строки в символах без учета завершающего нулевого символа.
    • replace() – заменяет в строке вхождения определенного символа на другой.
    • setCharAt() – изменяет нужный символ в строке.
    • substring() – возвращает подстроку. Может принимать два значения – начальный и конечный индексы. Первый является включительным, т.е. соответствующий ему элемент будет включаться в строку, второй – не является им.
    • toCharArray() – копирует элементы строки в буфер.
    • toLowerCase() – возвращает строку, которая записана в нижнем регистре.
    • toUpperCase() – возвращает записанную в верхнем регистре строку.
    • toInt() – позволяет преобразовать строку в число (целое). При наличии в строке не целочисленных значений функция прерывает преобразование.
    • trim() – отбрасывает ненужные пробелы в начале и в конце строки.
    Читать еще:  Anti calc что это на утюге

    Объединение строк Arduino

    Объединить две строки в одну можно различными способами. Эта операция также называется конкатенацией. В ее результате получается новый объект String, состоящий из двух соединенных строк. Добавить к строке можно различные символы:

    • String3 = string1 + 111; // позволяет прибавить к строке числовую константу. Число должно быть целым.
    • String3 = string1 + 111111111; // добавляет к строке длинное целое число
    • String3 = string1 + ‘А’; // добавляет символ к строке
    • String3 = string1 + “aaa”;// добавляет строковую постоянную.
    • String3 = string1 + string2; // объединяет две строки вместе.

    Важно осторожно объединять две строки из разных типов данных, так как это может привести к ошибке или неправильному результату.

    Arduino string to int и string to float

    Для конвертации целочисленных значений string to int используется функция toInt().

    String MyStr = “111”;

    int x = MyStr.toInt();

    Если нужно конвертировать объект с плавающей запятой, применяется функция atof().

    String MyStr = “11.111”;

    MyStr.toCharArray(myStr1, MyStr.length()); // копируется String в массив myStr1

    float x = atof(myStr1); // преобразование в float

    Преобразование int to string

    Для создания строки из числа не требуется делать особых телодвижений. Мы можем просто объединить строку и число:

    String str = “Строка номер “+ i;

    Можем создать объект, используя конструктор

    String str = String(50);

    Можем объединить оба способа:

    String str = “Строка номер “+ String(50);

    Преобразование String в массив char

    Тип данных Char позволяет объявлять текстовые строки несколькими способами:

    • char myStr1[10]; – в данном случае объявлен массив определенного размера.
    • char myStr2 [6] = <‘a’, b, ‘c’, ‘d’, ‘e’>; – объявлен сам массив. Конечный символ не записанявно, его прибавит сам компилятор.
    • char myStr3[6] = <‘a’, b, ‘c’, ‘d’, ‘e’’/0’>; – объявлен массив, при этом в конце прописан признак окончания строки.
    • char myStr4 [ ] = “abcde”; – инициализация массива строковой постоянной. Размер и завершающий символ добавляются автоматически компилятором.
    • char myStr5 [6 ] = “abcde”; – инициализация массива с точным указанием его размера.
    • char myStr 6[30 ] = “abcde”; – аналогично, но размер указан больше для возможности использования строк большей длины.

    Еще раз напомним, что в типе данных char строковые константы нужно записывать в двойные кавычки «Abcde», а одиночные символы – в одинарные ‘a’.

    Конвертировать строку в массив сhar array можно при помощи следующего кода:

    String stringVar = “111”;

    Можно сделать обратное преобразование – char to string.

    char[] chArray = “start”;

    Пример преобразования String to const char*. Указание звездочкой char*означает, что это массив указателей.

    String stringVar=string (`start);

    Char charVar[ sizeof [stringVar)];

    Заключение о String и ардуино

    В этой статье мы рассмотрели основные вопросы использования String для работы со строками arduino. Как показывают примеры, ничего страшного и сложного в этом классе нет. Более того, зачастую мы можем даже не догадываться, что работаем с классом String: мы просто создаем переменную нужного типа, присваиваем ей строку в двойных кавычках. Создав строку, мы используем все возможности библиотеки String: можем без проблем модифицировать строку, объединять строки, преобразовывать string в int и обратно, а также делать множество других операций с помощью методов класса.

    В ситуациях, когда скетч большой и перед нами встает дефицит памяти, использовать String нужно осторожно, по возможности заменяя на char*. Впрочем, в большинстве первых проектов начинающего ардуинщика таких ситуаций не много, поэтому рекомендуем использовать String без опаски – это предотвратит появление ошибок адресной арифметики, возникающих при работе с массивами char.

    ОБОРУДОВАНИЕ
    ТЕХНОЛОГИИ
    РАЗРАБОТКИ

    Блог технической поддержки моих разработок

    Главное меню

    Урок 30. Текстовые строки в Ардуино. Конвертирование данных в строки и наоборот. Класс String.

    В уроке рассказываю о текстовых строках в Ардуино, о классе String, о преобразовании различных типов данных в текстовые строки и об обратной операции — преобразовании строк в числа.

    Собирался разрабатывать драйвер шагового двигателя с управлением от компьютера, но столкнулся с необходимой для разработки темой, которую мы еще не изучали. Поэтому на один урок я отвлекусь от шаговых двигателей и расскажу о текстовых строках и операциях с ними.

    Текстовые строки в Ардуино.

    Текстовая строка это массив символов, завершающийся специальным символом – признаком конца строки. Признак необходим для того, чтобы функции работы со строками определяли, где заканчиваются символы строки и не считывали лишние данные, не принадлежащие ей.

    В Ардуино признаком конца строки является число 0, в текстовом виде ‘’. При объявлении строковых переменных в некоторых случаях необходимо явно указывать признак конца строки, а в некоторых он формируется по умолчанию.

    Способы объявления и инициализации текстовых строк.

    Объявлен символьный массив определенного размера. При заполнении его символами необходимо позаботиться о записи в конце строки байта со значением 0 – признака окончания строки.

    Объявлен массив и присвоено значение элементам. В конце строки компилятор прибавит признак конца строки автоматически.

    То же самое, только завершающий признак мы объявили явно.

    char myStr4 [ ] = “Start”;

    Массив инициализирован строковой константой. Компилятор автоматически задаст размер массива и добавит завершающий символ.

    char myStr5 [6 ] = “Start”;

    То же самое, только размер массива указан явно.

    char myStr 6[20 ] = “Start”;

    Можно явно указать больший размер массива, например, если он будет использован для строк разной длины.

    • Строковые константы объявляются внутри двойных кавычек ( ”Start” ).
    • Отдельные символы задаются внутри одинарных ( ‘S’ ).

    Длинные строки допускают объявление в таком виде:

    char myStr7 [] = “Текстовая строка может быть”
    “ объявлена”
    “ таким образом”;

    Ничего не мешает задавать массивы строк. Поскольку сами строки являются массивами, массивы строк будут двумерными массивами.

    Массивы строк объявляют как массив указателей. Это связано с тем, что строки могут иметь разную длину, и приходится резервировать двумерный массив данных, рассчитанный на самую длинную строку. А указатели требуют одинаковое количество ячеек памяти.

    Управляющие символы.

    В текстовых строках могут содержаться не только текстовые символы, но и управляющие. Управляющие символы не отображаются на экране в графическом виде. Они используются для управления передачей данных и выводом на экран. Таких символов несколько десятков. Я выделю наиболее важные.

    Для того чтобы вывести текст с новой строки необходимо использовать символы ‘r’ и ‘n’.

    Простая программа, демонстрирующая использование управляющих символов для печати с новой строки.

    // управляющие символы
    void setup() <
    Serial.begin(9600); // скорость 9600
    >

    void loop() <
    Serial.println(«rn Begin rn next string»
    «rn 3 empty strings rnrnrn»); // вывод сообщения в нескольких строках
    delay(1000);
    >

    На экране монитора последовательного порта увидим:


    Часто управляющие символы ‘r’ и ‘n’ применяют для завершения команды в символьном виде, например AT команды. Такой способ управления будем использовать в следующем уроке для драйвера шагового двигателя.

    Конвертирование различных типов данных Ардуино в текстовую строку.

    Задача преобразования различных типов данных в символьный вид и наоборот возникает:

    • при выводе данных на дисплей или индикаторы;
    • передаче данных на другие устройства, например компьютер;
    • некоторые электронные компоненты требуют обмена данными с помощью AT команд в символьном виде, например GSM модемы, WiFi модули и т.п.

    Существует достаточно много способов для решения этой задачи. Я подробно опишу несколько из них, на мой взгляд, самых удачных.

    Конвертирование данных в строку через встроенные функции классов ввода-вывода.

    Самый удобный, предпочтительный способ преобразования данных в символьный вид. Многие библиотеки ввода-вывода имеют функции преобразования данных в текстовый формат.

    Если необходимо передавать данные через последовательный порт, почему бы не воспользоваться стандартными функциями класса Serial (урок 12).

    Например, конвертирование числа int в строку будет выглядеть так.

    Преобразование переменной float в строку можно выполнить так.

    Преобразование будет выполнено при передаче данных на другое устройство. Функции класса Serial подробно описаны в уроке 12.

    Если выводите данные на LCD дисплей с помощью библиотеки LiquidCristal, то для преобразования данных типа int можно использовать метод print (урок 23).

    В библиотеке LiquidCristal нет функции для вывода данных типа float. Можно воспользоваться способом, предложенным в уроке 20 для библиотеки Led4Digits. Стандартная функция класса Led4Digits позволяет отображать на LED индикаторах только целые числа, но добавив простые вычисления можно легко выводить данные с плавающей запятой.

    Конвертирование целочисленных данных в строку через функции itoa, ltoa, ultoa.

    Функции простые, позволяют конвертировать числа целых форматов в текстовую строку.

    itoa (int data, char* string, int radix); // преобразование int

    ltoa (long data, char* string, int radix); // преобразование long

    ultoa (unsigned long data, char* string, int radix); // преобразование unsigned long

    • data – это конвертируемая переменная;
    • char* string – указатель на строку (имя массива);
    • radix – система исчисления результата в строке:
      • 10 для DEC;
      • 8 для OCT;
      • 16 для HEX;
      • 2 для BIN.

    Например, конвертирование переменой x типа int в строку myStr1 можно сделать так.

    itoa(x, myStr1, 10); // в десятичном виде
    itoa(x, myStr1, 8); // в восьмеричном виде
    itoa(x, myStr1, 16); // в шестнадцатеричном виде
    itoa(x, myStr1, 2); // в двоичном виде

    Вот программа для проверки работы этих функций.

    // проверка преобразования числа в текстовую строку
    int x=0; // переменная, которая выводится
    char myStr[20]; // текстовый массив

    void loop() <
    // подготовка буфера строки
    for (int i=0; i DEC
    //itoa(x, myStr, 8); // int -> OCT
    //itoa(x, myStr, 16); // int -> HEX
    //itoa(x, myStr, 2); // int -> BIN

    // преобразование переменной long x
    //ltoa(x, myStr, 10); // long -> DEC
    //ltoa(x, myStr, 8); // long -> OCT
    //ltoa(x, myStr, 16); // long -> HEX
    //ltoa(x, myStr, 2); // long -> BIN

    // преобразование переменной unsigned long x
    //ultoa(x, myStr, 10); // long -> DEC
    //ultoa(x, myStr, 8); // long -> OCT
    //ultoa(x, myStr, 16); // long -> HEX
    //ultoa(x, myStr, 2); // long -> BIN

    В цикле каждые 0,5 секунд происходит:

    • Текстовая строка myStr заполняется пробелами, в конце добавляются управляющие символы возврат каретки и перевод строки.
    • Переменная x конвертируется одной из функцией. Результат оказывается в буфере myStr.
    • Функция Serial.write(myStr, 20); передает через последовательный порт 20 байтов массива myStr в виде байтов.
    • Прибавляется 1 к переменной x.

    Чтобы проверить нужную функцию необходимо освободить ее от признака комментарий. Я проверил все.

    Для вывода чисел с плавающей запятой можно опять предложить метод из урока 20.

    Конвертирование данных в строку с помощью функции sprintf.

    Это самый удобный, универсальный метод. Недостаток такого способа заключается в том, что функция sprintf просто пожирает ресурсы микроконтроллера. В критичных по времени и объему памяти приложениях ее лучше не применять.

    sprint это функция форматированного вывода. Ее широко используют в приложениях на компьютерах. Она дает самые широкие возможности для преобразования данных в строку. Но в системе Ардуино sprintf не поддерживает формат чисел с плавающей запятой.

    int sprintf( char *string, const char *format , argument1, argument2 . )

    Функция возвращает число преобразованных символов. В случае ошибки возвращает число – 1.

    • argument – это переменные, которые необходимо преобразовать;
    • format – управляющая строка:

    Arduino работа со строками

    Дельта принтеры крайне требовательны к точности изготовления комплектующих (геометрия рамы, длины диагоналей, люфтам соединения диагоналей, эффектора и кареток) и всей геометрии принтера. Так же, если концевые выключатели (EndStop) расположены на разной высоте (или разный момент срабатывания в случае контактных концевиков), то высота по каждой из осей оказывается разная и мы получаем наклонную плоскость не совпадающая с плоскостью рабочего столика(стекла). Данные неточности могут быть исправлены либо механически (путем регулировки концевых выключателей по высоте), либо программно. Мы используем программный способ калибровки.
    Далее будут рассмотрены основные настройки дельта принтера.
    Для управления и настройки принтера мы используем программу Pronterface.
    Калибровка принтера делится на три этапа:

    1 Этап. Корректируем плоскость по трем точкам

    Выставление в одну плоскость трех точек — A, B, C (расположенных рядом с тремя направляющими). По сути необходимо уточнить высоту от плоскости до концевых выключателей для каждой из осей.
    Большинство (если не все) платы для управления трехмерным принтером (В нашем случае RAMPS 1.4) работают в декартовой системе координат, другими словами есть привод на оси: X, Y, Z.
    В дельта принтере необходимо перейти от декартовых координат к полярным. Поэтому условимся, что подключенные к двигателям X, Y, Z соответствует осям A, B, C.(Против часовой стрелки начиная с любого двигателя, в нашем случае смотря на логотип слева — X-A, справа Y-B, дальний Z-C) Далее при слайсинге, печати и управлении принтером в ручном режиме, мы будем оперировать классической декартовой системой координат, электроника принтера сама будет пересчитывать данные в нужную ей систему. Это условность нам необходима для понятия принципа работы и непосредственной калибровки принтера.

    Точки, по которым мы будем производить калибровку назовем аналогично (A, B, C) и позиция этих точек равна A= X-52 Y-30; B= X+52 Y-30; C= X0 Y60.

    Алгоритм настройки:

    1. Подключаемся к принтеру. (В случае “крагозяб” в командной строке, необходимо сменить скорость COM порта. В нашем случае с 115200 на 250000 и переподключится)

      После чего мы увидим все настройки принтера.
    2. Обнуляем высоты осей X, Y, Z командой M666 x0 y0 z0.
      И сохраняем изменения командой M500. После каждого изменения настроек необходимо нажать home (или команда g28), для того что бы принтер знал откуда брать отсчет.
    3. Калибровка принтера производится “на горячую”, то есть должен быть включен подогрев стола (если имеется) и нагрев печатающей головки (HotEnd’а) (Стол 60град., сопло 185 град.) Так же нам понадобится щуп, желательно металлический, известных размеров. Для этих задач вполне подойдет шестигранный ключ (самый большой, в нашем случае 8мм, он предоставляется в комплекте с принтерами Prizm Pro и Prizm Mini)
    4. Опускаем печатающую головку на высоту (условно) 9мм (от стола, так, что бы сопло еле касалось нашего щупа, т.к. высота пока что не точно выставлена.) Команда: G1 Z9.
    5. Теперь приступаем непосредственно к настройке наших трех точек.
      Для удобства можно вместо g- команд создать в Pronterface четыре кнопки, для перемещения печатающей головки в точки A, B, C, 0-ноль.

  • Последовательно перемещаясь между тремя точками (созданными ранее кнопками или командами) выясняем какая из них находится ниже всего (визуально) и принимает эту ось за нулевую, относительно нее мы будем менять высоту остальных двух точек.
  • Предположим, что точка A у нас ниже остальных. Перемещаем головку в точку B(Y) и клавишами управления высотой в Pronterface опускаем сопло до касания с нашим щупом, считая величину, на которую мы опустили сопло (в лоб считаем количество нажатий на кнопки +1 и +0.1)
    Далее командой меняем параметры высоты оси Y: M666 Y <посчитанная величина>
    M666 Y0.75
    M500
    G28
  • Ту же операцию проделываем с оставшимися осями. После чего следует опять проверить высоту всех точек, может получится, что разброс высот после первой калибровки уменьшится, но высота все равно будет отличатся, при этом самая низкая точка может изменится. В этом случае повторяем пункты 6-7.
  • 2 Этап. Исправляем линзу

    После того как мы выставили три точки в одну плоскость необходимо произвести коррекцию высоты центральной точки. Из за особенности механики дельты при перемещении печатающей головки между крайними точками в центре она может пройти либо ниже либо выше нашей плоскости, тем самым мы получаем не плоскость а линзу, либо вогнутую либо выпуклую.

    Корректируется этот параметр т.н. дельта радиусом, который подбирается экспериментально.

    Калибровка:

    1. Отправляем головку на высоту щупа в любую из трех точек стола. Например G1 Z9 X-52 Y-30
    2. Сравниваем высоту центральной точки и высоту точек A,B,C. (Если высота точек A, B, C разная, необходимо вернутся к предыдущей калибровки.)
    3. Если высота центральной точки больше остальных, то линза выпуклая и необходимо увеличить значение дельта радиуса. Увеличивать или уменьшать желательно с шагом +-0,2мм, при необходимости уменьшить или увеличить шаг в зависимости от характера и величины искривления (подбирается экспериментально)
    4. Команды:
      G666 R67,7
      M500
      G28
    5. Подгоняем дельта радиус пока наша плоскость не выровняется
    3 Этап. Находим истинную высоту от сопла до столика

    Третьим этапом мы подгоняем высоту печати (от сопла до нижней плоскости — столика) Так как мы считали, что общая высота заведомо не правильная, необходимо ее откорректировать, после всех настроек высот осей. Можно пойти двумя путями решения данной проблемы:
    1 Способ:
    Подогнав вручную наше сопло под щуп, так что бы оно свободно под ним проходило, но при этом не было ощутимого люфта,

    • Командой M114 выводим на экран значение фактической высоты нашего HotEnd’а
    • Командой M666 L получаем полное значение высоты (Параметр H)
    • После чего вычитаем из полной высоты фактическую высоту.
    • Получившееся значение вычитаем из высоты щупа.

    Таким образом мы получаем величину недохода сопла до нижней плоскости, которое необходимо прибавить к полному значению высоты и и записать в память принтера командами:
    G666 H 235.2
    M500
    G28

    2 Способ:
    Второй способ прост как валенок. С “потолка”, “на глаз” прибавляем значение высоты (после каждого изменение не забываем “уходить” в home), добиваясь необходимого значения высоты, но есть шанс переборщить со значениями и ваше сопло с хрустом шмякнется об стекло.

    Как сделать авто калибровку для вашего принтера и что при этом авто калибрует принтер вы узнаете из следующих статей.

    Вы можете помочь и перевести немного средств на развитие сайта

    Читать онлайн «Программируем Arduino. Основы работы со скетчами» автора Монк Саймон — RuLit — Страница 23

    String text = «Temp: » + tempC + » C»;

    Увы, в C этот прием не работает. В данном случае сообщение можно вывести несколькими инструкциями print, как показано далее:

    lcd.print(«Temp: «); lcd.print(tempC); lcd.print(» C»);

    Этот подход устраняет необходимость закулисного копирования данных в процессе конкатенации (объединения) строк, как происходит в других современных языках.

    Аналогичный подход с применением нескольких инструкций вывода можно использовать при работе с монитором последовательного порта и инструкциями Serial.print. В подобных случаях последней в строке обычно используется команда println, добавляющая в конец символ перевода строки.

    Форматирование строк с помощью sprintf

    Стандартная библиотека строковых функций для языка C (не путайте с библиотекой Arduino String Object, которая обсуждается в следующем разделе) включает очень удобную функцию sprintf, выполняющую форматирование массивов символов. Она вставляет значения переменных в строку шаблона, как показано в следующем примере:

    sprint(line1, «Temp: %d C», tempC);

    Массив символов line1 — это строковый буфер, содержащий форматированный текст. Как указано в примере, он имеет емкость 17 символов, включая дополнительный нулевой символ в конце. Имя line1 я выбрал потому, что собираюсь показать, как сформировать содержимое верхней строки для жидкокристаллического дисплея с двумя строками по 16 символов в каждой.

    В первом параметре команде sprintf передается массив символов, в который должен быть записан результат. Следующий аргумент — строка формата, содержащая смесь простого текста, такого как Temp:, и команд форматирования, например %d. В данном случае %d означает «десятичное целое со знаком». Остальные параметры будут подставлены в строку формата в порядке их следования на место команд форматирования.

    Чтобы во вторую строку на жидкокристаллическом дисплее вывести время, его можно сформировать из отдельных значений часов, минут и секунд, как показано далее:

    sprintf(line2, «Time: %2d:%02d:%02d», h, m, s);

    Если попробовать вывести строку line2 в монитор последовательного порта или на экран жидкокристаллического дисплея, вы увидите текст

    Команда sprintf не только подставила числа в нужные места, но и добавила ведущий ноль перед цифрой 5. В примере между символами : находятся команды форматирования трех компонентов времени. Часам соответствует команда %2d, которая выводит двузначное десятичное число. Команды форматирования для минут и секунд немного отличаются (%02d). Эти команды также выводят двузначные десятичные числа, но добавляют ведущий ноль, если это необходимо.

    Однако имейте в виду, что этот прием предназначен для значений типа int. К сожалению, разработчики Arduino не реализовали в стандартной библиотеке C поддержку других типов, таких как float.

    Определение длины строки

    Так как строки, хранящиеся в массивах символов, часто оказываются короче самих массивов, в библиотеке предусмотрена удобная функция с именем strlen. Эта функция подсчитывает число символов в массиве, предшествующих нулевому символу, отмечающему конец строки.

    Функция принимает массив символов в своем единственном параметре и возвращает размер строки (исключая пустой символ), хранящейся в нем, например, команда

    Библиотека Arduino String Object

    В Arduino IDE, начиная с версии 019, вышедшей несколько лет тому назад, включается библиотека String, более понятная и дружественная разработчикам, использующим Java, Ruby, Python и другие языки, где конкатенацию строк допускается выполнять простым оператором +. Эта библиотека также предлагает массу вспомогательных функций для работы со строками.

    Конечно, данная библиотека добавляет к скетчу несколько килобайт кода. Кроме того, она использует механизм динамического распределения памяти со всеми сопутствующими проблемами, такими как исчерпание памяти. Поэтому подумайте хорошенько, прежде чем принять решение о ее использовании. Многие пользователи Arduino предпочитают применять обычные массивы символов.

    Эта библиотека удивительно проста в использовании, и, если вам приходилось работать со строками в Java, благодаря библиотеке Arduino String Object вы будете чувствовать себя как дома.

    Создание строк

    Создать строку можно из массива элементов типа char, а также из значения типа int или float, как показано в следующем примере:

    String message = «Temp: «;

    String temp = String(123);

    Конкатенация строк

    Строки типа String можно объединять друг с другом и с данными других типов с помощью оператора +. Попробуйте добавить следующий код в функцию setup пустого скетча:

    String message = «Temp: «;

    String temp = String(123);

    Serial.println(message + temp + » C»);

    Обратите внимание на то, что последнее значение, добавляемое в строку, в действительности является массивом символов. Если первый элемент в последовательности значений между операторами + является строкой, остальные элементы автоматически будут преобразованы в строки перед объединением.

    Другие строковые функции

    В табл. 6.1 перечислены еще несколько удобных функций из библиотеки String. Полный список доступных функций можно найти по адресу http://arduino.cc/en/Reference/StringObject.

    Таблица 6.1. Некоторые полезные функции в библиотеке String

    Функция

    Пример

    Описание

    char ch = String(«abc»)[0]

    Переменная ch получит значение «a»

    Удалит пробелы с обеих сторон от группы символов abc. Переменная s получит значение «abc»

    Преобразует строковое представление числа в значение типа int или long

    String s = «abcdefg»;

    String s2 = s.substring(1, 3);

    Возвращает фрагмент исходной строки. Переменная s2 получит значение «bc». В параметрах передаются: индекс первого символа фрагмента и индекс символа, следующего за последним символом фрагмента

    String s = «abcdefg»;

    Заменит все вхождения «de» в строке на «DE». Переменная s2 получит значение «abcDEfg»

    Использование ЭСППЗУ

    Содержимое всех переменных, используемых в скетче Arduino, теряется при выключении питания или выполнении сброса. Чтобы сохранить значения, их нужно записать байт за байтом в память ЭСППЗУ. В Arduino Uno имеется 1 Кбайт памяти ЭСППЗУ.

    ПРИМЕЧАНИЕ

    Это не относится к плате Arduino Due, не имеющей ЭСППЗУ. В этой модели данные следует сохранять на карту microSD.

    Для чтения и записи данных в ЭСППЗУ требуется использовать библиотеку, входящую в состав Arduino IDE. Следующий пример демонстрирует, как записать единственный байт в ЭСППЗУ, в данном случае операция выполняется в функции setup:

    byte valueToSave = 123

    В первом аргументе функции write передается адрес в ЭСППЗУ, куда должен быть записан байт данных, а во втором — значение для записи в этот адрес.

    Ссылка на основную публикацию
    Adblock
    detector