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

#COURSE#

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].

Теперь в объект po