Serial Monitor. Общаемся с компьютером
Для общения между платой Arduino и компьютером или другим устройством в контроллере используется интерфейс UART или USART, который в сочетании со встроенным в UNO USB-to-UART конвертером, позволит установить двунаправленую связь с компьютером через виртуальный последовательный порт. У некоторых моделей Arduino может быть несколько портов. Порт соединяется через цифровой пин 0 (RX) и 1 (TX) при подключении к компьютеру через USB, поэтому не используйте пины 0 и 1 для ввода/вывода.
Раньше на старых компьютерах были COM-порты, сейчас они создаются виртуально при помощи микросхемы FTDI, когда мы подключаем плату к компьютеру через USB.
Вам часто придётся использовать общение между устройствами для обмена информацией. Можно как посылать сигнал с компьютера, например, с клавиатуры, так и принимать сигналы с платы. Это полезно, чтобы узнать, что вообще происходит с сигналом из нужного вывода платы.
В Arduino IDE есть специальный значок с изображением лупы, который запускает Serial Monitor (монитор порта).
Для корректной работы с портом требуется выполнение двух условий: выбрать правильный COM-порт, выбрать скорость работы в скетче, которая должна совпадать со скоростью, выбранной в мониторе порта.
Для общения используется класс Serial. В методе setup() мы открываем порт для общения функцией Serial.begin() с указанием скорости в бодах (baud). Бод — это количество изменений сигнала в секунду. В нашем случае сигналы могут быть только двоичными, так что скорость в бодах соответствует скорости в битах в секунду. Можно использовать любую скорость, главное чтобы на приёмной и передающей сторонах они были одинаковыми. Доступные скорости можно посмотреть в настройках порта. Значение 9600 является стандартным и его можно не менять (9600 бод — 960 символов — один стартовый бит, восемь бит на сам символ и конечный бит). Если установить неправильную скорость, то вместо данных получим «мусор» — данные, которые нельзя обработать. Для обмена данными между другими компонентами скорость может быть и выше, например между платой и Bluetooth-модулем.
На платах Arduino Mega и Arduino Due доступны также Serial1, Serial2, Serial3.
Чтобы отправить сообщение в порт, используются методы print() (символы идут подряд) или println() (с переводом на новую строку).
Давайте выведем какое-нибудь сообщение. Это можно сделать в методе setup(), так как нам не нужно повторять одну и ту же фразу бесконечно. Метод loop() оставляем пустым.
Если посылаем строку, то обрамляем её кавычками. Если число, то кавычки не используем. Изменим функцию setup().
Можно заменить строки и числа на переменные. Перепишем пример.
Немного о числах. При работе с дробными числами, можно указать число знаков после запятой.
Работа с массивами и строками
Разберём пример отправки строк в случайном порядке. Любая строка уже является массивом символов. Поэтому вместо типа String, можно использовать массив char[]. Для примера создадим массив из четырёх имён и будем выводить их в случайном порядке через разные промежутки времени, используя функцию random().
Приём данных
Выводить данные в порт просто. А вот принимать данные с компьютера и других источников сложнее. При отправлении данных, они складываются в буфер, ожидая, когда плата их прочитает. Объём буфера составляет 64 байта. Чтобы постоянно не читать пустой буфер, есть специальная функция проверки буфера Serial.available(). Она возвращает число байт, которые лежат в буфере. Обычно в коде создают условие проверки — если в буфере больше 0 байт, то выполняем какие-то команды.
Для демонстрации создадим странный пример — создадим переменную, присвоим ей данные через Serial.read() и попросим её прислать полученные данные через Serial.print(). Получится круговорот данных или эхо.
Проверяем на числах. Отправляем число 9, а получаем 57. Если вы получаете две строки с числами 57 и 10, то в нижней части окна выберите настройку No line ending вместо Newline.
Попробуем также отправить букву. Опять вместо t возвращается 116. Ерунда какая-то. Всё просто, функция read() работает с символьными значениями и мы видим код символа из стандартной таблицы символов ASCII.
Чтобы решить проблему, нужно изменить тип данных на char.
Вроде проблема решена. Мы можем принимать отдельные цифры и буквы. Но буквы только английские, а числа только однозначные.
Если мы планируем работать только с однозначными числами, то можно написать такой код.
Решение какое-то половинчатое. А как быть с большими числами или словами?
Если отправить двузначное число 23, то ответ разбивается на части — 2 и 3. Получается, что переменная получит последнее число 3 (промежуточные значения перезаписываются). Чтобы обработать всё число, нужно использовать метод parseInt().
Теперь вы можете вводить любые числа. Но, наверное, вы заметите теперь небольшую задержку в ответах. Метод внутри себя перемалывает данные. Кстати, вы можете использовать и обычные символы. Если набор символов состоит только из букв, то вернётся 0. Если будут попадаться и цифры, то будут возвращаться цифры. Попробуйте комбинировать различные сочетания цифр и букв, чтобы понять, как будут обрабатываться данные.
Управление светодиодом с клавиатуры
Напишем пример управления встроенным светодиодом с клавиатуры. Если нажата клавиша 1, то светодиод должен загореться, при нажатии клавиши 0 выключим светодиод.
Часть кода нам уже знакома — мы используем встроенный светодиод под номером 13.
Сигнал от компьютера поступает в виде байта. Создаём новую переменную incomingByte для этих целей.
Последовательный порт включается командой begin() с указанием скорости.
Если с компьютера поступает сигнал, то функция available() вернёт количество байт, доступное для чтения. Таким образом, мы просто убеждаемся, что какой-то сигнал пришёл (больше нуля).
После первой проверки мы проверяем введённый символ, который может быть представлен и как байт. Если символ равен единице, то включаем светодиод, как мы делали раньше. Если символ равен 0, то выключаем.
Как это выглядит на практике. Заливаем скетч и запускаем Serial Monitor (Ctrl+Shift+M). В окне Serial Monitor наверху есть текстовое поле. Вводим в него числа 1 или 0 и нажимаем кнопку Send. Можно также нажать клавишу Enter для быстрого ввода.
Для общего развития в скетч добавлены также две строчки кода, определяющие код нажатой клавиши. Таким образом вы можете узнать код для клавиш 0 и 1. Вы также можете нажимать и на другие клавиши, они не повлияют на светодиод, но вы увидите коды клавиш.
Чуть более сложный пример, когда строка задана в виде массива и символы выводятся по очереди.
Функция Serial.end() закрывает последовательное соединение, порты RX и TX освобождаются и могут быть использованы для ввода/вывода.
В различных уроках вы будете принимать сигналы от платы Arduino. Это полезно, например, для отладки приложения, когда вы выводите сообщения и по ним ориентируетесь, какая часть программа работает, а какая — нет. Способность общения между Arduino и компьютером очень важна. Вы можете принимать сигналы не только в Arduino IDE, но и в других приложениях на компьютере. Например, в связке с Arduino часто используют приложение Processing, в котором рисуют графики поступаемых сигналов.
Если вы больше не нуждаетесь в получении данных, то закрывайте окно Serial Monitor.
Также существует библиотека SoftwareSerial. Она позволяет осуществить последовательную передачу данных через другие цифровые контакты Arduino.
Другие варианты
Чтение данных из последовательного порта возможно другими способами. Ищите расширения, например, Arduino Chrome Serial Monitor. На видео можно посмотреть, как создать расширение самостоятельно.
На C# также можно написать приложение, которое будет уметь считывать данные.
Using the Serial Monitor tool
The Serial Monitor is an essential tool when creating projects with Arduino. It can be used as a debugging tool, testing out concepts or to communicate directly with the Arduino board.
The Arduino IDE 2.0 has the Serial Monitor tool integrated with the editor, which means that no external window is opened when using the Serial Monitor. This means that you can have multiple windows open, each with its own Serial Monitor.
You can download the editor from the Arduino Software page.
You can also follow the downloading and installing the Arduino IDE 2.0 tutorial for more detailed guide on how to install the editor.
Requirements
- Arduino IDE 2.0 installed.
- Arduino board.
- Core installed for the board used.
Notable Changes
Integrated Monitor
One major change that was introduced with the Arduino IDE 2.0 is the integrated Serial Monitor. The older versions of the editor features an external window that matches the port/board that we select.
The Arduino IDE 2.0 works a bit differently. Instead of opening an external window for the Serial Monitor, it shows up where the console log is located, as an additional tab. To understand how this works, let's take a look at how the old editor works:
Serial Monitor on the older version.
Now, let's take a look at the IDE 2.0. Notice how the Serial Monitor is located at the bottom of the editor:
Serial Monitor on the new version.
The Serial Monitor settings are also located here, such as adjusting the baud rate and sending messages.
Advantages
A major advantage with having the Serial Monitor integrated with the editor is the possibility to have multiple monitors open simultaneously. In the old editor, when changing the port/board, it changed across all windows. In addition, we were limited to one Serial Monitor window, an obstacle that the IDE 2.0 removes.
You will find an example with more information on how to use this feature, further down this tutorial under the Using multiple Serial Monitors simultaneously section.
Using the Serial Monitor Tool
The Serial Monitor tool is a really great tool for debugging and establishing communication between a computer and an Arduino. To use it is really easy, but there are some things that we need to do first.
1. First we need to open the Arduino IDE 2.0.
An empty Arduino IDE sketch window.
2. Now, we need to create a sketch that includes some configurations needed, so that our board can communicate with our computer. Mainly, we need to set a baud rate, which is done by writing . Here, the represents the baud rate, which is the maximum bits per seconds that can be transferred. The sketch that we need to use can be found in the snippet below:
3. This will print , every one second to the Serial Monitor. Let's select the board we want to use, and upload the sketch to the board.
Select the board and upload the sketch.
4. When it has finished uploading, click on the Serial Monitor button, located at the top right corner of the IDE. This will launch the Serial Monitor in the bottom of the IDE, replacing the console section.
Open the Serial Monitor, and viewing the output.
The text is now printed every one second. Congratulations, you have now successfully sent a message from your Arduino, to your computer.
Using Multiple Serial Monitors Simultaneously
A really cool feature with the Arduino IDE 2.0 is that the Serial Monitor is linked to the sketch windows you have open. For example, if we have two sketch windows, named sketch_1 and sketch_2, we can select the port and board for each window, and have two Serial Monitors running at the same time.
This is really useful when working with various communication / connectivity projects, where we want to know what's going on both boards at the same time. If you have two Arduino boards, you can try out this feature using the instructions below.
1. First, we need to open a new file, through File > New.
Open a new sketch.
2. Now, we need to choose another board. In this example, we are using an Arduino Nano 33 IoT. If you have connected it to your computer and installed the necessary core for it, it will show up in the board list.
List of available boards.
3. For the new sketch, let's use the same sketch we uploaded to the other board, but replace the , with something else. In this example, we used , as you can see in the code snippet below:
4. Upload the code to the board, and open the Serial Monitor. We should now see being printed every one second. If we put the two sketch windows side by side, we can see how they are printing at the same time.
Two Serial Monitors running simultaneously.
Congratulations, you can now check what is going on with two boards simultaneously!
Note: Using several sketch windows and Serial Monitor at the same time can be quite heavy on your machine.
Монитор порта, отладка
Как мы с вами знаем из урока “Что умеет микроконтроллер“, у многих микроконтроллеров есть интерфейс UART, позволяющий передавать и принимать различные данные. У интерфейса есть два вывода на плате – пины TX и RX. На большинстве Arduino-плат к этим пинам подключен USB-UART преобразователь (расположен на плате), при помощи которого плата может определяться компьютером при подключении USB кабеля и обмениваться с ним информацией. На компьютере создаётся виртуальный COM порт (последовательный порт), к которому можно подключиться при помощи программ-терминалов и принимать-отправлять текстовые данные. Таким же образом кстати работают некоторые принтеры и большинство станков с ЧПУ.
В самой Arduino IDE есть встроенная “консоль” – монитор порта, кнопка с иконкой лупы в правом верхнем углу программы. Нажав на эту кнопку мы откроем сам монитор порта, в котором будут настройки: 
Если с отправкой, автопрокруткой, отметками времени и кнопкой очистить вывод всё и так понятно, то конец строки и скорость мы рассмотрим подробнее:
- Конец строки: тут есть несколько вариантов на выбор, чуть позже вы поймёте, на что они влияют. Лучше поставить нет конца строки, так как это позволит избежать непонятных ошибок на первых этапах знакомства с платформой.
- Нет конца строки – никаких дополнительных символов в конце введённых символов после нажатия на кнопку отправка или клавишу Enter.
- NL – символ переноса строки в конце отправленных данных.
- CR – символ возврата каретки в конце отправленных данных.
- NL+CR – и то и то.
Объект Serial
Начнём знакомство с одним из самых полезных инструментов Arduino-разработчика – Serial, который идёт в комплекте со стандартными библиотеками. Serial позволяет как просто принимать и отправлять данные через последовательный порт, так и наследует из класса Stream кучу интересных возможностей и фишек, давайте сразу их все рассмотрим, а потом перейдём к конкретным примерам.
Запустить связь по Serial на скорости speed (измеряется в baud, бит в секунду). Скорость можно поставить любую, но есть несколько “стандартных” значений. Список скоростей для монитора порта Arduino IDE:
- 300
- 1200
- 2400
- 4800
- 9600 чаще всего используется, можно назвать стандартной
- 19200
- 38400
- 57600
- 115200 тоже часто встречается
- 230400
- 250000
- 500000
- 1000000
- 2000000 – максимальная скорость, не работает на некоторых китайских платах
Отправляет в порт значение val – число или строку, фактически “печатает”. В отличие от write выводит именно текст, т.е. отправив 88, вы получите 88: Serial.print(88); . Отправляет любые стандартные типы данных: численные, символьные, строковые. Также методы print()/println() имеют несколько настроек для разных данных, что делает их очень удобным инструментом отладки:
format позволяет настраивать вывод данных: BIN, OCT, DEC, HEX выведут число в соответствующей системе счисления: двоичная, восьмеричная, десятичная (по умолчанию) и 16-ричная. Цифра после вывода float позволяет настраивать выводимое количество знаков после точки:
Читает данные из буфера и ищет набор символов target (тип char ), опционально можно указать длину length. Возвращает true , если находит указанные символы. Ожидает передачу по таймауту.
Плоттер
Помимо монитора последовательного порта, в Arduino IDE есть плоттер – построитель графиков в реальном времени по данным из последовательного порта. Достаточно отправлять значение при помощи команды Serial.println(значение) и открыть плоттер по последовательному соединению, например построим график значения с аналогового пина A0:
Плоттер поддерживает несколько линий графиков одновременно, для их отображения нужно соблюдать следующий протокол отправки данных: значения выводятся в одну строку, одно за другим по порядку, разделяются пробелом или запятой и в конце обязательно перенос строки.значение1 пробел_или_запятая значение2 пробел_или_запятая значение3 пробел_или_запятая перенос_строки
Давайте выведем значения с аналоговых пинов A0, A1 и A2:
Получим вот такие графики:
В Arduino IDE с версии 1.8.10 добавили возможность подписать графики, для этого перед выводом нужно отправить названия в виде название 1, название 2, название n с переносом строки, и дальше просто выводить данные:
Отправка в порт
Рассмотрим самый классический пример для всех языков программирования: Hello World!
Отправка в порт позволяет узнать значение переменной в нужном месте программы, этот процесс называется отладка. Когда код работает не так, как нужно, начинаем смотреть, где какие переменные какие значения принимают. Или выводим текст из разных мест программы, чтобы наблюдать за порядком её работы. Во взрослых средах разработки и более серьёзных микроконтроллерах есть аппаратная отладка, которая позволяет наблюдать за ходом выполнения программы и значениями любых переменных без вывода в порт.
Давайте вспомним урок циклы и массивы и выведем в порт элементы массива:
Вывод: 0 50 68 85 15 214 63 254 – элементы массива, разделённые пробелами.
Чтение из порта
Проблемы возникают при попытке принять данные в порт. Дело в том, что метод read() читает один символ, а если вы отправите длинное число или строку – программа получит его по одному символу. Чтение сложных данных называется парсинг. Его можно делать вручную, об этом мы поговорим в отдельном уроке из блока “Алгоритмы”. В рамках этого урока рассмотрим встроенные инструменты для парсинга Serial.
Чтобы не нагружать программу чтением пустого буфера, нужно использовать конструкцию
Таким образом чтение будет осуществляться только в том случае, если в буфере есть какие-то данные.
Парсинг цифр
Вы заметите, что после отправки проходит секунда, прежде чем плата ответит в порт. Эта секунда является таймаутом, о котором мы говорили чуть выше. Программа ждёт секунду после принятия последнего символа, чтобы все данные успели прийти. Секунда это очень много, ожидать, скажем, 50 миллисекунд. Это можно сделать при помощи метода setTimeout() .
Теперь после отправки цифры программа будет ждать всего 50 мс и ответит гораздо быстрее!
Парсинг текста
Проще всего прочитать текст в String-строку (урок про них). Это максимально не оптимально, но зато довольно просто для восприятия:
Данный пример выводит любой текст, который был отправлен в монитор порта.
Управляющие символы
Существуют так называемые управляющие символы, позволяющие форматировать вывод. Их около десятка, но вот самые полезные из них
- \n – новая строка
- \r – возврат каретки
- \v – вертикальная табуляция
- \t – горизонтальная табуляция
Также если в тексте вы захотите использовать одинарные кавычки ‘ , двойные кавычки « , обратный слэш \ и некоторые другие символы – их нужно экранировать при помощи обратного слэша, он просто ставится перед символом:
- \» – двойные кавычки
- \’ – апостроф
- \\ – обратный слэш
- \0 – нулевой символ
- \? – знак вопроса
Выведем строку с кавычками:
Комбинация \r\n переведёт строку и вернёт курсор в левое положение:
Символы табуляции позволят удобно отправлять данные для последующей вставки в таблицу. Например выведем несколько степеней двойки в виде таблицы, используя символ табуляции \t :
Результат скопируем и вставим в excel
Удобно!Чтение последовательного порта в Arduino
Последовательный монитор обычно используется только для отображения данных с Arduino на мониторе компьютера. Но его также можно использовать в качестве устройства ввода, которое принимает входные данные от пользователя и отправляет их на Arduino.
Например, этот инструмент может быть использован для создания меню, калькулятора или входа в систему с паролем, где пользователю предлагается ввести информацию, а Arduino выполняет определенное действие на основе этого ввода.
В этой статье мы сначала узнаем, как получать пользовательский ввод из serial порта Arduino. Затем мы рассмотрим несколько примеров программ, чтобы увидеть, как создать меню, калькулятор веса и интерфейс входа с паролем.
Как получить пользовательский ввод с монитора порта
Чтобы получить ввод пользователя с монитора порта, разобьем код на три простых шага.
Шаг 1. Запрос на получение информации
Это может быть вопрос типа “сколько раз вы хотите, чтобы светодиод мигал?” или “выберите опцию из меню?” . Это просто текст, сообщающий пользователю, что ему нужно что-то ввести. Код для подсказки может быть простой функцией Serial.print() , которая выводит вопрос на последовательном мониторе.
Пользователи могут вводить типы данных int , float или string . Только вам нужно будет заранее знать, какой тип данных будет вводить пользователь.
Шаг 2. Ждем обратную связь от пользователя
Для этой цели будем использовать функцию Serial.available() в пустом цикле while . Функция Serial.available() возвращает количество байт, доступных для чтения с последовательного порта. Когда пользователь не вводит данные, функция Serial.available() возвращает нулевое значение. Но когда пользователь вводит данные и нажимает Enter , то функция вернет ненулевое значение. Это используется как условие пустого цикла while , чтобы заставить программу ждать, пока не поступит ввод от пользователя:
Здесь условие пустого цикла while : Serial.available()==0 . Когда пользователь не вводит никаких данных, функция Serial.available() возвращает нулевое значение, что делает условие истинным. Скетч остается внутри цикла while до тех пор, пока пользователь не введет что-то и функция Serial.available() не вернет ненулевое значение.
Шаг 3. Чтение данных
Последним шагом является чтение информации, введенной пользователем, и выполнение действия на основе этого ввода.
Для этого нам нужно разобрать информацию, хранящуюся в буфере serial порта. Чтобы проанализировать информацию, хранящуюся в буфере, мы можем использовать одну из этих трех функций:
- Serial.parseInt()
- Serial.parseFloat()
- Serial.readString()
Тип данных вводимой пользователем информации определяет, какую функцию следует использовать.
- Если пользователь будет вводить целое число, то используйте Serial.parseInt() .
- Если пользователь будет вводить число с плавающей точкой, тогда используйте Serial.parseFloat() .
- А вот если пользователь будет вводить строку, используйте Serial.readString() .
Прежде чем эти функции можно будет использовать, нам нужно объявить переменную для хранения передаваемых данных. Тип этой переменной должен соответствовать типу входных данных.
Например, чтобы проанализировать целое число, вы можете объявить переменную int с именем intVariable и установить ее равной функции Serial.parseInt() следующим образом:
Чтобы получить число с плавающей точкой, вы можете объявить переменную float и установить ее равной функции Serial.parseFloat() :
Чтобы прочитать строку из порта Arduino, вы можете объявить строковую переменную и установить ее равной функции Serial.readString() :
Давайте посмотрим, как работать с чтением из порта на нескольких примерах.
Как анализировать целочисленные типы данных
В качестве примера, как получить целые числа из монитора порта Arduino, давайте взглянем на скетч, который создает меню.
Меню предлагает пользователю выбрать одну из трех характеристик для измерения и вывода значения в serial порт arduino: температура, влажность или атмосферное давление:
Для простоты код взаимодействия с датчиками не включен в этот скетч. Но Вы можете ознакомиться со статьей «Подключение датчика BMP280 к Ардуино», чтобы разобраться как подключить его и считать температуру, влажность и атмосферное давление. После этого будет проще добавить код для датчика в этот скетч.
В верхней части скетча мы объявляем три переменные для хранения показаний с датчика (или датчиков).
- Переменная с именем temp будет хранить показания температуры.
- Переменная с именем Rh будет хранить показания влажности.
- А переменная с именем pressure будет хранить показания давления.
В разделе setup() мы начинаем с инициализации последовательного монитора с помощью функции Serial.begin() .
Затем у нас есть несколько вызовов функции Serial.print() . Они выводят опции меню на последовательном мониторе. Первый вариант — температура, второй вариант — влажность, а третий вариант — атмосферное давление.
В разделе loop() мы сначала предлагаем пользователю ввести пункт меню. У нас есть функция Serial.println() , которая будет выводить текст «Какой датчик вы хотите прочитать?» в монитор порта.
Теперь нам просто нужно дождаться, пока пользователь введет выбор. Мы делаем это с помощью пустого цикла while . Условие цикла while : Serial.available()==0 . Функция Serial.available() возвращает количество байтов, отправленных с монитора последовательного порта. Функция возвращает ноль, когда нет последовательных данных, поэтому скетч остается в цикле while , пока пользователь что-нибудь не введет. Когда пользователь вводит выбор, Serial.available() возвращает ненулевое значение, поэтому скетч выходит из цикла while и продолжает работать с оставшейся частью скетча.
Далее нам нужно прочитать данные, которые ввел пользователь, и для этого нам нужно их проанализировать. Поскольку это меню, пользователь будет вводить целое число, чтобы сделать выбор. Поэтому нам нужно использовать Serial.parseInt() . Мы будем хранить полученные данные в переменной int с именем menu .
На этом этапе мы предложили пользователю ввести пункт меню. Мы ждали, пока он войдет в выбор. И мы получили этот выбор и сохранили его в переменной. Теперь все, что нам нужно сделать, это заставить что-то произойти с этим выбором.
Поскольку есть три разных пункта меню, мы могли бы использовать три разных условных оператора if, чтобы управлять тем, что происходит, когда пользователь вводит выбор. Но более эффективным способом будет использование оператора switch case. Итак, в скетче выше есть оператор switch с переменной menu в скобках.
Затем есть три разных оператора case — case 1, case 2 и case 3.
- Если пользователь вводит 1, скетч выполнит код в первом операторе case и распечатает показания датчика температуры.
- В случае если пользователь введет 2, скетч выполнит код во втором операторе case , который распечатает показания влажности с датчика.
- Если пользователь введет 3, скетч выполнит код в третьем операторе case , который выведет показания атмосферного давления в монитор порта.
Если пользователь вводит число, отличное от одного, двух или трех, мы можем использовать оператор default для вывода сообщения об ошибке, предлагающего ему ввести допустимое число. В приведенном выше скетче, если выполняется оператор default, на последовательный порт выводится текст «Пожалуйста, сделайте свой выбор 1, 2 или 3» .
Чтение из serial-порта arduino чисел с плавающей точкой
Теперь давайте рассмотрим пример того, как получить тип данных float от пользователя из последовательного порта. Этот скетч представляет собой калькулятор, который преобразует вес в килограммах в вес в фунтах:
В разделе setup() мы сначала инициализируем Serial порт. Затем мы выводим текст: «Калькулятор перевода килограммов в фунты» .
В разделе loop() мы запрашиваем у пользователя информацию, выводя «Введите вес в кг: » .
Затем у нас есть пустой цикл while с Serial.available()==0 в качестве условия, поэтому скетч будет ждать, пока пользователь не введет число.
Теперь, поскольку перевод килограммов в фунты может привести к дробному числу, мы объявляем переменную weightKg как число с плавающей точкой. Затем мы устанавливаем его равным функции Serial.parseFloat() и выводим переменную weightKg в монитор порта.
Теперь мы делаем пересчет из килограммов в фунты. В одном килограмме 2,2046 фунта, поэтому мы можем умножить переменную weightKg на 2,2046, чтобы получить фунты и сохранить это значение в новой переменной с плавающей точкой с именем weightLbs . Затем мы последовательно выводим текст «Вес в фунтах:» , за которым следует переменная weightLbs .
Чтение строки из serial порта arduino
Теперь давайте посмотрим, как работать со строковыми входными данными. Этот скетч запросит у пользователя пароль. Если пароль правильный, он выведет «Верный пароль!». Если пароль неверен, он выведет «Неверный пароль!»:
Первое, что мы делаем, это определяем пароль. Вверху скетча есть строковая переменная с именем password , которая устанавливается равной паролю, который будет использоваться. У нас это QWERTY.
В разделе setup() мы инициализируем последовательный монитор с помощью Serial.begin(9600); .
В разделе loop() мы сначала используем функцию Serial.println() для вывода текста: «Пожалуйста, введите свой пароль:» . Затем есть пустой цикл while с Serial.available() == 0 в качестве условия. Это необходимо для того, чтобы скетч ждал, пока пользователь введет пароль.
Значение, хранящееся в переменной пароля, представляет собой строку. Поэтому нам нужно использовать Serial.readString() для чтения строки из последовательного буфера. Вывод функции readString() сохраняется в другой строковой переменной с именем input .
Теперь нам просто нужно сравнить пароль, хранящийся во входной переменной, с паролем, который был определен в скетче. Условие оператора if : input == password . Если условие истинно, скетч войдет в тело и выполнит функцию Serial.println() , которая выведет «Верный пароль!» на последовательном мониторе.
Внутри оператора if вы размещаете код, реагирующий на правильность пароля. Например, вместо того, чтобы выводить текст на последовательном мониторе, вы можете установить на цифровом контакте высокий уровень функцией digitalWrite(), чтобы включить привод для открытия двери.
Если пароль, введенный пользователем, не совпадает с паролем, определенным в скетче, будет выполнен оператор else . Внутри оператора else находится функция Serial.println() , которая выведет «Неверный пароль!» на последовательном мониторе.
Надеюсь, эта статья оказалась вам полезной! Оставляйте комментарии ниже, если у вас есть какие-либо вопросы.