Объект string в 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() – отбрасывает ненужные пробелы в начале и в конце строки.

Объединение строк 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»;

char myStr1[10];

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

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

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

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

int i = 50;

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 charBufVar[20];

stringVar.toCharArray(charBufVar, 20);

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

char[] chArray = «start»;

String str(chArray);

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

String stringVar=string (`start);

Char charVar[ sizeof [stringVar)];

stringVar.toCharArray(charVar, sizeof(charVar));

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

В этой статье мы рассмотрели основные вопросы использования String для работы со строками arduino. Как показывают примеры, ничего страшного и сложного в этом классе нет.

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

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

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

Связываемся с Processing

При работе с платой Arduino мы иногда выводим результат на Serial Monitor. Но это не единственная возможность для получения данных на экране. Например, вы можете воспользоваться программой Processing (http://processing.org/).

Когда вы установите эту программу, то удивитесь – насколько она похожа на Arduino IDE. Не удивляйтесь, обе программы сделаны на одном движке.

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

Запустим Arduino IDE и выберем простейший пример вывода данных на Serial Port:

void setup() { Serial.begin(9600);
} void loop() { Serial.println(“Hello Kitty!”); // ждем 500 миллисекунд перед следующей отправкой delay(500);
}

Запустим пример и убедимся, что код работает.

Получение данных

Теперь мы хотим получить этот же текст в Processing. Запускаем новый проект и напишем код.

Первый шаг – импортировать библиотеку. Идем в Sketch | Import Library | Serial. В скетче появится строка:

import processing.serial.*;

Далее объявляем переменные, создаём обязательные функции. Обратите внимание, что в отличии от скетчей Arduino, в скетчах Processing используется функция draw() вместо loop().
import processing.serial.

*; Serial serial; // создаем объект последовательного порта
String received; // данные, получаемые с последовательного порта void setup()
{ String port = Serial.list()[0]; serial = new Serial(this, port, 9600);
} void draw() { if ( serial.available() > 0) { // если есть данные, received = serial.

readStringUntil('
'); // считываем данные } println(received); //отображаем данные в консоли
}

Чтобы обеспечить прием данных с последовательного порта, нам нужен объект класса Serial. Так как с Arduino мы отправляем данные типа String, нам надо получить строку и в Processing.

В методе setup() нужно получить доступный последовательный порт. Как правило, это первый доступный порт из списка. После этого мы можем настроить объект Serial, указав порт и скорость передачи данных (желательно, чтобы скорости совпадали).

Осталось снова подключить плату, запустить скетч от Processing и наблюдать поступаемые данные в консоли приложения.

Processing позволяет работать не только с консолью, но и создавать стандартные окна. Перепишем код.

import processing.serial.*; Serial serial; // создаем объект последовательного порта
String received; // данные, получаемые с последовательного порта void setup()
{ size(320, 120); String port = Serial.list()[0]; serial = new Serial(this, port, 9600);
} void draw() { if ( serial.available() > 0) { // если есть данные, // считываем их и записываем в переменную received received = serial.readStringUntil('
'); } // Настройки для текста textSize(24); clear(); if (received != null) { text(received, 10, 30); }
}

Запустим пример ещё раз и увидим окно с надписью, которое перерисовывается в одном месте.

Таким образом мы научились получать данные от Arduino. Это позволит нам рисовать красивые графики или создавать программы контроля за показаниями датчиков.

Отправка данных

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

Допустим, мы будем посылать символ “1” из Processing. Когда плата обнаружит присланный символ, включим светодиод на порту 13 (встроенный).

Скетч будет похож на предыдущий. Для примера создадим небольшое окно. При щелчке в области окна будем отсылать “1” и дублировать в консоли для проверки. Если щелчков не будет, то посылается команда “0”.

import processing.serial.*; Serial serial; // создаем объект последовательного порта
String received; // данные, получаемые с последовательного порта void setup()
{ size(320, 120); String port = Serial.list()[0]; serial = new Serial(this, port, 9600);
} void draw() { if (mousePressed == true) { //если мы кликнули мышкой в пределах окна serial.write('1'); //отсылаем 1 println(“1”); } else { //если щелчка не было serial.write('0'); //отсылаем 0 }
}

Теперь напишем скетч для Arduino.

char commandValue; // данные, поступаемые с последовательного порта
int ledPin = 13; // встроенный светодиод void setup() { pinMode(ledPin, OUTPUT); // режим на вывод данных Serial.begin(9600);
} void loop() { if (Serial.available()) { commandValue = Serial.read(); } if (commandValue == '1') { digitalWrite(ledPin, HIGH); // включаем светодиод } else { digitalWrite(ledPin, LOW); // в противном случае выключаем } delay(10); // задержка перед следующим чтением данных
}

Запускаем оба скетча. Щёлкаем внутри окна и замечаем, что светодиод загорается. Можно даже не щёлкать, а удерживать кнопку мыши нажатой – светодиод будет гореть постоянно.

Обмен данными

Теперь попытаемся объединить оба подхода и обмениваться сообщениями между платой и приложением в двух направлениях.

Для максимальной эффективности добавим булеву переменную. В результате у нас отпадает необходимость постоянно отсылать 1 или 0 от Processing и последовательный порт разгружается и не передает лишнюю информацию.

Когда плата обнаружит присланную единицу, то меняем булевое значение на противоположное относительно текущего состояния (LOW на HIGH и наоборот). В else используем строку “Hello Kity”, которую будем отправлять только в случае, когда не обнаружим '1'.

Функция establishContact() отсылает строку, которую мы ожидаем получить в Processing. Если ответ приходит, значит Processing может получить данные.

char commandValue; // данные, поступаемые с последовательного порта
int ledPin = 13;
boolean ledState = LOW; //управляем состоянием светодиода void setup() { pinMode(ledPin, OUTPUT); Serial.begin(9600); establishContact(); // отсылаем байт для контакта, пока ресивер отвечает
} void loop() { // если можно прочитать данные if (Serial.available() > 0) { // считываем данные commandValue = Serial.read(); if (commandValue == '1') { ledState = !ledState; digitalWrite(ledPin, ledState); } delay(100); } else { // Отсылаем обратно Serial.println(“Hello Kitty”); } delay(50);
} void establishContact() { while (Serial.available()

Arduino. Работа с COM-портом

Для связи микроконтроллера с компьютером чаще всего применяют COM-порт. В этой статье мы покажем, как передать команды управления из компьютера и передать данные с контроллера.

Подготовка к работе

Большинство микроконтроллеров обладают множеством портов ввода-вывода. Для связи с ПК наиболее пригоден из них протокол UART. Это протокол последовательной асинхронной передачи данных.

Для его преобразования в интерфейс USB на плате есть конвертор USB-RS232 – FT232RL.
Для выполнения примеров их этой статьи вам будет достаточно только Arduino-совместимая плата. Мы используем EduBoard.

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

Таблица ASCII

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

int symbol = 33; void setup() { Serial.begin(9600); Serial.println(“ASCII Table ~ Character Map”); } void loop() { Serial.write(symbol); Serial.print(“, dec: “); Serial.print(symbol); Serial.print(“, hex: “); Serial.print(symbol, HEX); Serial.print(“, oct: “); Serial.print(symbol, OCT); Serial.print(“, bin: “); Serial.println(symbol, BIN); if(symbol == 126) { while(true) { continue; } } symbol++; }

Переменная symbol хранит код символа. Таблица начинается со значения 33 и заканчивается на 126, поэтому изначально переменной symbol присваивается значение 33.
Для запуска работа порта UART служит функция Serial.begin().

Единственный ее параметр – это скорость. О скорости необходимо договариваться на передающей и приемной стороне заранее, так как протокол передачи асинхронный. В рассматриваемом примере скорость 9600бит/с.

Для записи значения в порт используются три функции:

Serial.write() – записывает в порт данные в двоичном виде.

Serial.print() может иметь много значений, но все они служат для вывода информации в удобной для человека форме. Например, если информация, указанная как параметр для передачи, выделена кавычками – терминальная программа выведет ее без изменения. Если вы хотите вывести какое-либо значение в определенной системе исчисления, то необходимо добавить служебное слово: BIN-двоичная, OCT – восьмеричная, DEC – десятичная, HEX – шестнадцатеричная. Например, Serial.print(25,HEX).

Serial.println() делает то же, что и Serial.print(), но еще переводит строку после вывода информации.

Для проверки работы программы необходимо, чтобы на компьютере была терминальная программа, принимающая данные из COM-порта. В Arduino IDE уже встроена такая. Для ее вызова выберите в меню Сервис->Монитор порта. Окно этой утилиты очень просто:

Монитор порта

Теперь нажмите кнопку перезагрузки. МК перезагрузится и выведет таблицу ASCII:

Таблица ASCII

Обратите внимание на вот эту часть кода:

if(symbol == 126) { while(true) { continue; } }

Она останавливает выполнение программы. Если вы ее исключите – таблица будет выводиться бесконечно.
Для закрепления полученных знаний попробуйте написать бесконечный цикл, который будет раз в секунду отправлять в последовательный порт ваше имя. В вывод добавьте номера шагов и не забудьте переводить строку после имени.

Отправка команд с ПК

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

Как только устройство готово – оно вычитывает данные из буфера. Проверить состояние буфера позволяет функция Serial.avaliable(). Эта функция возвращает количество байт в буфере. Чтобы вычитать эти байты необходимо воспользоваться функцией Serial.read().

Рассмотрим работу этих функций на примере:

int val = 0; void setup() { Serial.begin(9600); } void loop() { if (Serial.available() > 0) { val = Serial.read(); Serial.print(“I received: “); Serial.write(val); Serial.println(); } }

После того, как код будет загружен в память микроконтроллера, откройте монитор COM-порта. Введите один символ и нажмите Enter. В поле полученных данных вы увидите: “I received: X”, где вместо X будет введенный вами символ.
Программа бесконечно крутится в основном цикле.

В тот момент, когда в порт записывается байт функция Serial.available() принимает значение 1, то есть выполняется условие Serial.available() > 0. Далее функция Serial.read() вычитывает этот байт, тем самым очищая буфер. После чего при помощи уже известных вам функций происходит вывод.

Использование встроенного в Arduino IDE монитора COM-порта имеет некоторые ограничения. При отправке данных из платы в COM-порт вывод можно организовать в произвольном формате. А при отправке из ПК к плате передача символов происходит в соответствии с таблицей ASCII.

Это означает, что когда вы вводите, например символ “1”, через COM-порт отправляется в двоичном виде “00110001” (то есть “49” в десятичном виде).

Немного изменим код и проверим это утверждение:

int val = 0; void setup() { Serial.begin(9600); } void loop() { if (Serial.available() > 0) { val = Serial.read(); Serial.print(“I received: “); Serial.println(val,BIN); } }

После загрузки, в мониторе порта при отправке “1” вы увидите в ответ: “I received: 110001”. Можете изменить формат вывода и просмотреть, что принимает плата при других символах.

Управление устройством через COM-порт

Очевидно, что по командам с ПК можно управлять любыми функциями микроконтроллера. Загрузите программу, управляющую работой светодиода:

int val = 0; void setup() { Serial.begin(9600); } void loop() { if (Serial.available() > 0) { val = Serial.read(); if (val=='H') digitalWrite(13,HIGH); if (val=='L') digitalWrite(13,LOW); } }

При отправке в COM-порт символа “H” происходит зажигание светодиода на 13ом выводе, а при отправке “L” светодиод будет гаснуть.
Если по результатам приема данных из COM-порта вы хотите, чтобы программа в основном цикле выполняла разные действия, можно выполнять проверку условий в основном цикле. Например:

int val = '0'; void setup() { Serial.begin(9600); } void loop() { if (Serial.available() > 0) { val = Serial.read();} if (val=='1') { digitalWrite(13,HIGH); delay (100); digitalWrite(13,LOW); delay (100); } if (val=='0') { digitalWrite(13,HIGH); delay (500); digitalWrite(13,LOW); delay (500); } }

Если в мониторе порта отправить значение “1” светодиод будет мигать с частотой 5Гц. Если отправить “0” – частота изменится на 1Гц.

Индивидуальные задания

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

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

Остальные статьи цикла можно найти здесь.

Мы будем очень рады, если вы поддержите наш ресурс и посетите магазин наших товаров shop.customelectronics.ru.

Преобразовать serial.read() в полезную строку с помощью Arduino?

Вот более надежная реализация, которая обрабатывает ненормальные условия ввода и гонки.

• Он обнаруживает необычно длинные входные значения и безопасно их отбрасывает. Например, если источник имел ошибку и генерировал ввод без ожидаемого терминатора; или был злонамерен.
• Он гарантирует, что строковое значение всегда заканчивается на нуль (даже если размер буфера полностью заполнен).
• Ожидает, пока не будет зафиксировано полное значение. Например, задержки передачи могут привести к тому, что Serial.available() будет возвращать ноль, пока остальная часть значения не закончится.
• Не пропускает значения, когда несколько значений поступают быстрее, чем их можно обрабатывать (с учетом ограничений буфера последовательного ввода).
• Может обрабатывать значения, которые являются префиксом другого значения (например, “abc” и “abcd” могут быть прочитаны).

Он намеренно использует массивы символов вместо типа String, чтобы быть более эффективными и избегать проблем с памятью. Он также избегает использования функции readStringUntil(), чтобы не истекать время до ввода ввода.

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

int read_line(char* buffer, int bufsize)
{ for (int index = 0; index < bufsize; index++) { // Wait until characters are available while (Serial.available() == 0) { } char ch = Serial.read(); // read next character Serial.print(ch); // echo it back: useful with the serial monitor (optional) if (ch == ' ') { buffer[index] = 0; // end of line reached: null terminate string return index; // success: return length of string (zero if string is empty) } buffer[index] = ch; // Append character to buffer } // Reached end of buffer, but have not seen the end-of-line yet. // Discard the rest of the line (safer than returning a partial line). char ch; do { // Wait until characters are available while (Serial.available() == 0) { } ch = Serial.read(); // read next character (and discard it) Serial.print(ch); // echo it back } while (ch != ' '); buffer[0] = 0; // set buffer to empty string even though it should not be used return -1; // error: return negative one to indicate the input was too long }

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

const int LED_PIN = 13;
const int LINE_BUFFER_SIZE = 80; // max line length is one less than this void setup() { pinMode(LED_PIN, OUTPUT); Serial.begin(9600);
} void loop() { Serial.print(“> “); // Read command char line[LINE_BUFFER_SIZE]; if (read_line(line, sizeof(line)) < 0) { Serial.println("Error: line too long"); return; // skip command processing and try again on next iteration of loop } // Process command if (strcmp(line, "off") == 0) { digitalWrite(LED_PIN, LOW); } else if (strcmp(line, "on") == 0) { digitalWrite(LED_PIN, HIGH); } else if (strcmp(line, "") == 0) { // Empty line: no command } else { Serial.print("Error: unknown command: ""); Serial.print(line); Serial.println("" (available commands: "off", "on")"); } }

Arduino и Processing

Сегодня познакомимся с такой штукой как Processing.

Processing — это среда программирования, созданная для легкого и быстрого создания различных визуальных элементов. Зачем она нужна в курсе Arduino? За тем, что с помощью Processing можно легко связать Arduino с компьютером и осуществлять обмен информации между ними. Кроме того, Processing позволит визуально представить данные, получаемые с Arduino.

Скачать среду программирования можно бесплатно с официального сайта processing.org. Там же вы найдете всю необходимую информацию и примеры для работы.

Запустив Processing вы увидите, что эта среда очень похожа на Arduino IDE, что неудивительно, ведь Arduino IDE создавалась на основе Processing.

Для начала научимся передавать данные из Arduino в Processing. В этом нам поможет уже знакомый набор Serial. Пусть Arduino отправляет сообщение Hello, Processing!, а Processing, соответственно, будет принимать это сообщение.

На Arduino будет стандартный код отправки сообщения в последовательный порт раз в секунду:

void setup() {  Serial.begin(9600);}void loop() {  //отправляем сообщение  Serial.println(“Hello, Processing!”);  delay(1000);}

Загрузите код в плату.

Теперь настало время написать прием сообщения на Processing. Сначала нужно импортировать библиотеку Serial. Для этого в верхнем меню выберите Sketch -> Import Library -> Serial.

В коде появится строка

import processing.serial.*;

Для работы с Serial нужен объект типа Serial. Создадим его и назовем port.

Также, нам понадобится переменная для хранения принятого сообщения. Создадим строковую переменную message.

Как и в Arduino, в Processing существуют стандартные функции для однократного исполнения — void setup(), и для циклического повторения — void draw() (аналог void loop() в Arduino).

В setup() определим порт, по которому будут общаться Arduino и Processing.

port = new Serial(this, Serial.list()[1],9600);

Здесь нужно правильно указать ваш COM-порт. В диспетчере устройств (можете найти его нажав правой кнопкой мыши на Мой компьютер и выбрав Свойства) посмотрите задействованные COM-порты.

В моем случае есть 2 COM-порта. Arduino подключена к COM4. По счету это второй из занятых портов, но в Java (как и во многих других средах) нумерация начинается с 0, т.е. COM1 — это нулевой порт, COM4 — первый. Поэтому в Serial.list() я указываю номер 1. Если у вас только один COM-порт, то вы поставите Serial.list()[0].

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

Так как считывать сообщения мы должны все время, то поместим эту часть в функцию void draw(). Принимаемое сообщение будем записывать в переменную message.

Также, перед тем, как считать данные, убедимся, что в порт что-то приходило с помощью функции port.available().

if (port.available()>0) {    message = port.readString();  }

В случае принятия сообщения выведем это сообщение в консоль с помощью функции println().

Код программы целиком:

import processing.serial.*;Serial port;  // объект типа Serial для дальнейшего использованияString message;void setup() {  port = new Serial(this, Serial.list()[1], 9600);}void draw() {  if (port.available()>0) { // если в порт пришли данные    message = port.readString(); // считываем сообщение и записываем в переменную message    println(message); // выводим message в консоль  }}

Запустим написанную программу и, если все сделано правильно, увидим в нижней части Processing надпись Hello, Processing!, которая выводится каждую секунду.

А теперь выведем это сообщение не в консоль, а на экран. Для начала зададим размеры рабочего экрана, например, 400х400. Делается это командой size(400, 400) в функции setup(). Также, нам нужно создать шрифт, которым будет написан текст. Объявим объект типа PFont:

В блоке setup создадим необходимый шрифт, например, Arial размером 25пт.

f = createFont(“Arial”,25,true);

В блоке draw() сначала зададим цвет фона командой background(). Чтобы фон был черным напишем background(0).

Дальше укажем, что текст должен выводиться шрифтом f, который мы подготовили заранее, командой textFont(f).

После этого останется вывести текст на экран командой text(message, 10, 50), где message — принятое сообщение, а 10 и 50 — координаты вывода текста.

Код программы:

123456789101112131415161718192021
import processing.serial.*;Serial port;  // объект типа Serial для дальнейшего использованияString message;PFont f;void setup() {  size(400,400);  port = new Serial(this, Serial.list()[1], 9600);  f = createFont(“Arial”,25,true);}void draw() {  if (port.available()>0) { // если в порт пришли данные    message = port.readString(); // считываем сообщение и записываем в переменную message    println(message); // выводим message в консоль    background(0);    // черный фон экрана    textFont(f);      // задаем шрифт текста    text(message, 10, 50);  // выводим сообщение  }}

Если все сделано верно, при запуске у вас появится такое окно:

У нас получилось передать данные из Arduino в Processing и вывести их на экран. В следующий раз обработаем данные, полученные с датчиков с помощью Arduino.

C# Отправка последовательных команд в Arduino

Я использую плату Arduino Mega 2560 для управления полосой светодиодов. Я пытаюсь использовать небольшую консольную программу C# для отправки последовательных команд в мою программу Arduino.

В Arduino у меня есть библиотека под названием SerialCommand, где я могу прочитать последовательную строку и использовать ее для выполнения функции, а также передать так же аргументы: «functionName arg1 arg2 arg3».

Я проверил это, отправив последовательные команды через терминал, и он отлично работает! Я получил функции Arduino для запуска, отправив последовательные команды из моей программы на C#, но только если эта последовательная строка не содержит пробелов.

Вот мой C# код:

class Program { public static System.IO.Ports.SerialPort serialPort1; private void establishConnection() { serialPort1 = new System.IO.Ports.SerialPort(“COM4”); serialPort1.BaudRate = 115200; serialPort1.Open(); } static void Main(string[] args) { Program p = new Program(); p.establishConnection(); string i; while (true) { Console.Write(“Enter command: “); i = Console.ReadLine(); if (i == “exit”) { serialPort1.Close(); break; } else if (i == “1”) { // Turn LED's on and pass argument “test” serialPort1.Write(“ON test
“); } } } }

Я знаю, что мои работы подключения и мои команды посылают, потому что если я запрограммировать свою функцию ON в Arduino работать без аргумента, он прекрасно работает. Однако, если я отправляю команду «ВКЛЮЧЕНО» и включаю аргумент после пробела, или, вообще говоря, пробелы, Arduino не читает его правильно.

У вас есть какие-либо идеи о том, почему пространство вмешивается в мои серийные команды на C#? Спасибо за любую помощь.

Вот простой пример того, что я делаю в Arduino:

#include “SerialCommand.h” #include SerialCommand sCmd; #define PIN7 7 // Strip of LED's Adafruit_NeoPixel testStrip = Adafruit_NeoPixel(10, PIN7, NEO_GRB + NEO_KHZ800); uint32_t testStripColor = 0xFFFFFF; void setup() { Serial.begin(115200); sCmd.addCommand(“ON”, lightsOn); sCmd.addCommand(“OFF”, lightsOff); testStrip.begin(); testStrip.show(); } void loop() { sCmd.readSerial(); } void lightsOn() { char *lightSet; lightSet = sCmd.next(); // Read argument if (strcmp(lightSet, “test”) == 0) { for (int i=0; i < testStrip.numPixels(); i++) { testStrip.setPixelColor(i, testStripColor); } testStrip.show(); } } void lightsOff() { char *lightSet; lightSet = sCmd.next(); // Read argument if (strcmp(lightSet, "test") == 0) { testStrip.clear(); testStrip.show(); } }

c# arduino serial-communication

Arduino IDE : Работа с Serial Monitor

Самой популярной средой разработки для Arduino является официальная программа от итальянских разработчиков – Arduino IDE.

Можно конечно использовать и другие программы, например, имеющая обширный функционал, Atmel Studio и другие.

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

Скачать Arduino IDE можно на официальном сайте Arduino, в разделе программное обеспечение. Вы можете скачать любую версию, как самую новую, так и самую старую. Однако, советую также использовать версию 1.6.5 или 1.6.9, поскольку они является одними из самых стабильных и реже выдают ошибки при компиляции, казалось бы, правильно написанного кода.

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

На верхней панели расположены несколько разделов: файл, инструменты и так далее.

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

Функция “Открыть недавние” достаточна полезная, так как поможет вам открыть программные кода, с которыми вы ранее работали, и не придется тратить лишнее время на их поиски.

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

При установке новых библиотек в Arduino (для различных модулей и датчиков) число примеров увеличится. Также, эти коды содержат подробные пояснения, и поэтому данный раздел будет очень полезен начинающим, программировать на платформе Ардуино. Еще есть подраздел “Настройки”.

В нем стоит обратить внимание на отдельное поле для вставки ссылок, которые позволят загрузить в программу возможность работы с другими платформами и модулями, например с семейством интернет модулей на чипе ESP.

Раздел “Правка” служит для редактирования текста, кода и пояснений для него.

Раздел “Скетч” позволит выполнить различные действия с вашим кодом, например, проверить его (отправить на компиляцию) или загрузить в память вашего устройства.

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

И также имеется раздел “Помощь”, который, вроде как, должен решать возникающие проблемы при работе с Arduino IDE.

Остановимся подробнее на разделе “Инструменты”. Когда вы подключаете плату к компьютеру, то в этом разделе нужно настроить все необходимые параметры: выбрать в списке предложенных вашу плату, указан номер порта, к которому она подключается (посмотреть номер можно в диспетчере устройств в панели управления компьютера).

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

В данной статье хотелось бы затронуть возможность открытия в программе специального дополнительного окна, на котором будут выводиться значения сигналов и различные данные с датчиков и модулей, подключенных к Ардуино. Называется эта функция Serial Monitor (в русскоязычной версии – монитор порта). Ее, также, можно открыть с помощью сочетания клавиш Ctrl+Shift+M

По сути, это окно отвечает за последовательный порт соединения и служит для принятия или отправки различных данных на этот самый порт. В первом поле вы можете вводить различные значения (отправлять их в порт с помощью кнопки “отправить”) и получать, засчет этого, определенную информацию с Ардуино (если это прописано в вашем коде).

Есть также поле для получения данных, а внизу справа можно менять скорость последовательного соединения (измеряется в битах и или в бод на секунду). Чаще всего используется значение в 9600.

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

Чаще всего для работы с этим окном, используют две функции – Serial.print () и Serial.read(). Первая позволяет отправлять данные через порт последовательного соединения, а вторая – принимать их.

Приведем два кода для работы с монитором порта в Arduino IDE

Управление светодиодом с помощью монитора порта. Суть кода такова, что если мы введем цифру 1 в поле ввода и нажнем “отправить”, то светодиод загорится, если введем 0, то погаснет.

void setup() { Serial.begin(9600); // устанавливаем скорость передачи данных последовательного соединения pinMode(13, OUTPUT); // указываем номер контакта на плате, к которому подключен светодиод (13 – это встроенный светодиод на плате) } void loop() { // Получаем команды на включение-выключение светодиода на 13 порту. String str = Serial.readString(); // Если команда «1» то включаем светодиод. if (str == “1”) digitalWrite(13, 1); // Если команда «0» то выключаем светодиод. if (str == “0”) digitalWrite(13, 0); // Делаем временную задержку в 1 секунду (1000 миллисекунд) delay(1000); }

Следующий программный код позволит нам передавать данные из Arduino в Монитор порта, например слово “Amperkot”

void setup() { // устанавливаем скорость передачи данных последовательного соединения. Serial.begin(9600); } void loop() { // Отправляем «Amperkot». Serial.print(“Amperkot”); // Отправляем «Amperkot» включая спецсимволы, означающие переход на новую строку. Serial.println(“Amperkot”); // Делаем временную задержку в 1 секунду (1000 миллисекунд). delay(1000); }

Получаем такую картину:

Таким образом, прочитав данную статью, вы поняли основные функции и интерфейс программы Arduino IDE – среды разработки для Arduino и подобных ей плат, а также узнали о мониторе порта, о предназначении функций Serial.print () и Serial.read(), о том как и для чего их используют. Надеемся, что материал был для вас интересен, а главное полезен, и желаем всем удачной компиляции!

Купить плату Arduino Uno

Читать другие статьи по Arduino

Данная статья является собственностью Amperkot.ru. При перепечатке данного материала активная ссылка на первоисточник, не закрытая для индексации поисковыми системами, обязательна.

Управление servo-мотором через COM-порт Arduino

Управление будет  в таком виде как: в стандартном (или стороннем) окне монитора COM-порта вводим целую цифру от нуля до 180, нажимаем Enter и серво меняет положение своего плеча на заданный угол. Скетч в Arduino IDE выглядит следующим образом:Текст программы с комментариями следующий:

#include  //подключение библиотеки servo

Servo myservo;  // создание объекта servo для управления мотором

// на большинстве плат Arduino можно создать 12 servo объектов

String inputString = “”;         // переменная типа string для сохранения входных данных

boolean stringComplete = false;  // флаг данные получены 

void setup() {

  myservo.attach(9); //выбираем девятый управляющий дискретный выход контроллера для управления моторчиком 

  //инициализация последовательного порта:

  Serial.begin(9600);

  // получить 200 байтов и записать в переменную inputString:

  inputString.reserve(200);

  myservo.write(0); //выставляем изначальное положение серво в 0 градусов

}

void loop() {

  serialEvent(); //вызов нашей коммуникационной функции

  // печатаем ответ в COM-порт и поворачиваем серво на заданный угол:  if (stringComplete) {

    Serial.println(inputString);

    myservo.write(inputString.toInt()); //задание положения серво-машинке из полученной команды

    // обнуляем строковую переменную:    inputString = “”;    stringComplete = false;  }

}

void serialEvent() {  while (Serial.available()) {    // получить новый байт данных:

    char inChar = (char)Serial.read();

    // добавить новый байт к строковой переменной inputString:

    inputString += inChar;

    // если входной символ является новой строкой, взвести флаг    // что бы основной цикл обработал принятую команду:    if (inChar == '
') {      stringComplete = true;

    }

  }

}

Подключаем серво к плате контроллера по таблице соответсвия выводов:

Arduino
 Servo

Ноль питания
Коричневый провод

Плюс 5В
Красный провод

Дискретный выход №9
Оранжевый провод

В мониторе COM-порта тоже необходимо сделать некоторые настройки для корректной работы проекта. В правом нижнем углу окна необходимо выбрать следующие значения выпадающих списков “Новая строка” (чтобы все ваши команды из командной строки заканчивались концом строки) и 9600 бод (так как мы настроили последовательную связь на скорость обмена 9600). Если всё настроено правильно, то введя цифру и нажав Enter в окне монитора COM-порта, серво повернется на соответствующий угол и контроллер вернет эту цифру назад в последовательный порт.

6. Цифровые сигналы в теории и на практике. Последовательный порт

Цифровые сигналы в теории и на практике. Последовательный порт.

В общем случае словосочетание “цифровой сигнал” сейчас не слышал только глухой. А вот понимание сути этого названия есть далеко не у каждого. Я попробую объяснить, что же все это значит… Как говорилось ранее, цифровая техника называется “цифровой” потому, что оперирует только двумя состояниями: напряжение есть и напряжения нет.

Их еще обозначают цифрами 1 и 0. Отсюда и название.

Давайте теперь рассмотрим нашу схему с кнопкой и светодиодом. Кнопку нажали – светодиод загорелся, отпустили – погас. При нажатой кнопке на выход МК подается “1”, в отпущенном состоянии “0”.

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

Здесь время t– это ни что иное, как удержание кнопки в нажатом состоянии. А график изображает «прямоугольный импульс». Не трудно догадаться, что называется он так из-за своей характерной формы.

Электрический импульс – это всплеск напряжения или тока в определённом и конечном промежутке времени. Импульс всегда имеет начало (передний фронт) и конец (спад). В нашем случае они соответствуют моментам нажатия и отпускания кнопки.

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

Если нажать на кнопку несколько раз, то на графике будет несколько таких импульсов. Допустим, эти импульсы будут иметь одинаковое время t и будут следовать через равные интервалы времени.

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

Частота следования импульсов – это количество полных импульсов в единицу времени. За единицу времени принято брать одну секунду. Единицей измерения частоты является герц, по имени немецкого физика Генриха Герца. Один герц – это регистрация одного полного импульса за одну секунду.

Частота и период неразрывно связаны между собой.

И связь эта описывается простой формулой:

F = 1 / T

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

• Если длина импульса t точно равна половине периода T, то такой сигнал часто называют “меандр”.
• Скважностью импульсов называется отношение периода следования импульсов к их длительности и обозначается буквой S:

S=T/t

Скважность – безразмерная величина и не имеет единиц измерения, но может быть выражена в процентах.

• Коэффициент заполнения D является величиной, обратной скважности. Коэффициент заполнения обычно выражается в процентах и вычисляется по формуле:

D=1/S

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

Формирование импульсов осуществлялось вручную – оператор нажимал на ключ(кнопку). На другой стороне так же вручную происходило декодирование – другой оператор, глядя на вспышки лампочки, записывал последовательности и преобразовывал их в символы. Собственно, наше устройство как раз и представляет собой простейший макет первого телеграфа.

А сам телеграф – аналог современного последовательного порта передачи данных. Современный последовательный асинхронный порт передачи данных (UART) работает приблизительно следующим образом: Связь осуществляется по двум проводам – по одному для каждого направления передачи. На каждой стороне есть приемник (Rx) и передатчик (Tx).

Провода соединяют соответственно Tx стороны А с Rx стороны B и Rxстороны А с Txстороны B. Каждый передатчик связывается со своим приемником. Рассмотрим передачу данных со стороны А на сторону В. Обратное направление будет работать идентично этому. Для начала надо вспомнить, что порт асинхронный. Это значит, что обе стороны не синхронизированы друг с другом.

Принимающая сторона ничего не знает о частоте, с которой будут передаваться данные, и в какой момент эта передача начата. Не зная отправной точки (начало отсчета) невозможно правильно разделить данные на биты и составить из них правильные байты. Значит надо синхронизировать обе стороны. Для этого вначале передатчик выдает на линию несколько байт синхронизации вида 01010101 или 10101010.

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

Это простейший алгоритм асинхронной последовательной передачи данных.

На практике все несколько сложнее, но сейчас нам это не особо важно. Все дело в том, что в нашейArduinoпредусмотрен аппаратный последовательный порт. Если быть точным, то это часть микроконтроллера. В ArduinoUno/Mini/Nanoон один, а в ArduinoMegaтаких портов аж 4.

Рассматривая Arduino Uno (Nano/Mini) соответствующие выводы мы найдем под номерами D0(Rx) и D1(Tx). Но при их использовании надо учитывать, что для загрузки программы в микроконтроллер наша плата Arduinoкак раз и использует последовательный порт. Поэтому при прошивке микроконтроллера требуется отключать все периферийные устройства от этих выводов.

Использовать последовательный порт на Arduinoочень просто. Для этого в языке предусмотрен специальный класс Serial. Этот класс обладает следующими методами:

• begin(speed) – открываетпоследовательный порт и устанавливает скорость передачи данных.

  Обычно используются стандартизированные скорости (9600, 14400, 19200, 28800, 38400, 57600 или 115200), но можно указать и любую другую. Важно, чтобы порт на обоих сторонах был открыт с одинаковой скоростью.

• available() – функция возвращает количество байт, принятых микроконтроллером в специальный буфер и доступных для считывания в программу. Буфер может хранить до 64 байт.

• read() – считывает один байт из буфера последовательного соединения. При этом считанный байт из буфера уходит. Байты из буфера считываются в той последовательности, в которой они поступили в порт.
• write(val) – записывает один (или несколько) байт в последовательный порт.
• print(val) – записывает в порт последовательность байтов в виде строки.

  Так же есть функция println(val). Она отличается от данной тем, что в конце строки передает байт указания перехода на новую строку.

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

Мы можем это соединение использовать для любого обмена данными между компьютером и микроконтроллером. В ArduinoIDEв меню сервис есть пункт «Монитор порта». При его вызове откроется такое окошко:

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

int led = 13; int button = 2; void setup() {             

  pinMode(led, OUTPUT);       pinMode(button, INPUT); } intval; void loop() {   val = digitalRead(button);   digitalWrite(led, !val);} Загрузим этот скетч в микроконтроллер и откроем монитор порта. Там мы увидим убегающую вправо строку из нулей и единиц. Как не сложно догадаться, каждый символ этой строки показывает состояние кнопки в момент считывания микроконтроллером. Данные есть – это хорошо, но микроконтроллер работает достаточно быстро и следить за этими данными тяжело. Давайте еще немного модифицируем нашу программу: . . . . intval; intold_val=0; void loop() {   val = digitalRead(button);}

А значит это следующее… Оператор ifиспользуется для проверки каких-либо условий. Если условие верно (истина), то выполняется следующий оператор. Если условие ложно, то следующий оператор пропускается.

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

Так же стоит посмотреть тут и тут.

В нашей программе я добавил переменную old_val для хранения предыдущего состояния кнопки. В операторе ifя сравниваю только что полученное значение с предыдущим. И если они не равны, то выполняется следующий оператор. А если быть точным, блок операторов, заключенный в операторные скобки. Там я устанавливаю новое состояние светодиода.

Потом записываю это же состояние кнопки в порт. В конце я присваиваю переменной old_val новое состояние кнопки. Теперь данные в окошке будут появляться только при каком-либо действии с кнопкой. Как говорилось выше, для передачи в порт информации из нашей платы Arduino есть три функции – write, print и println. Разберем разницу между ними.

Функцию print мы только что использовали. Она вывела нам значения valв одну строку. Давайте теперь заменим ее на println. В результате при каждом вызове к передаче будет добавляться байт перехода на новую строку и нули с единицами в окошке будут отображаться уже в столбик.

А вот если вместо функции print поставить функцию write результат окажется на первый взгляд странным – окошко останется пустым. На самом деле все закономерно. Если функция print передает 0 и 1 как символы, то функция write передает их как байты в «сыром» виде.

А все дело в кодовой таблице… Дело в том, что каждый символ, который мы видим на экране, кодируется определенным числовым значением. Все эти значения собраны в этой самой кодовой таблице ASCII:

Как легко можно убедиться, нулю соответствует значение 48, а единице – 49. Значения байтов 0 и 1 соответствуют не отображаемым символам. Поэтому и экран остался пустым. Если в своей программе Вы напишете Serial.print(86), то в мониторе Вы и увидите 86. Если же написать Serial.write(86), то в мониторе появится буква «V».