Монитор последовательного порта arduino

  • Уроки
  • Базовые уроки Arduino
  • Монитор порта, отладка

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

Как мы с вами знаем из урока “О платформе“, на платах Ардуино стоит USB-TTL конвертер, позволяющий микроконтроллеру в текстовом режиме “консоли” общаться с компьютером по последовательному интерфейсу, Serial. На компьютере создаётся виртуальный COM порт, к которому можно подключиться при помощи программ-терминалов порта, и принимать-отправлять текстовые данные. Через этот же порт загружается прошивка, т.к. поддержка Serial является встроенной в микроконтроллер на “железном” уровне, и USB-TTL преобразователь подключен именно к этим выводам микроконтроллера. На плате Arduino Nano это кстати пины D0 и D1.

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

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

Если с отправкой, автопрокруткой, отметками времени и кнопкой “очистить вывод” всё понятно, то конец строки и скорость мы рассмотрим подробнее:

  • Конец строки: тут есть несколько вариантов на выбор, чуть позже вы поймёте, на что они влияют. Лучше поставить нет конца строки, так как это позволит избежать непонятных ошибок на первых этапах знакомства с Ардуино.
  • Нет конца строки – никаких дополнительных символов в конце введённых символов после нажатия на кнопку отправка/Enter
  • NL – символ переноса строки в конце отправленных данных
  • CR – символ возврата каретки в конце отправленных данных
  • NL+CR – и то и то
  • Скорость – тут на выбор нам даётся целый список скоростей, т.к. общение по Serial может осуществляться на разных скоростях, измеряемых в бод (baud), и если скорости приёма и отправки не совпадают – данные будут получены некорректно. По умолчанию скорость стоит 9600, её и оставим.
  • Очистить вывод – тут всё понятно, очищает вывод
  • Объект Serial

    Начнём знакомство с одной из самых полезных штук Arduino-разработчика – Serial. Serial это объект класса Stream, позволяющий как просто принимать/отправлять данные через последовательный порт, так и наследует из класса Stream кучу интересных возможностей и фишек, давайте сразу их все рассмотрим, а потом перейдём к конкретным примерам.

    Запустить связь по Serial на скорости speed (baud rate, бит в секунду). Скорость можно поставить любую, но есть несколько “стандартных”. Список скоростей для монитора порта Arduino IDE:

    • 300
    • 1200
    • 2400
    • 4800
    • 9600 чаще всего используется, можно назвать стандартной для большинства устройств с связью через TTL
    • 19200
    • 38400
    • 57600
    • 115200 тоже часто встречается
    • 230400
    • 250000
    • 500000
    • 1000000
    • 2000000

    Отправляет в порт значение val – число или строку. В отличие от write выводит именно символы, т.е. отправив 88 вы получите 88: Serial.print(88); выведет 88. Также метод print/println имеет несколько настроек для разных данных, что делает его очень удобным инструментом отладки:

    format позволяет настраивать вывод данных: BIN, OCT, DEC, HEX выведут число в соответствующей системе исчисления, а цифра после вывода float позволяет настраивать выводимое количество знаков после точки

    Полный аналог print(), но автоматически переводит строку после вывода. Позволяет также вызываться без аргументов (с пустыми скобками) просто для перевода строки

    Читает данные из буфера и ищет набор символов target (тип char), опционально можно указать длину length. Возвращает true, если находит указанные символы. Ожидает передачу по таймауту

    Плоттер

    Помимо монитора последовательного порта, в Arduino IDE есть плоттер – построитель графиков в реальном времени по данным из последовательного порта. Достаточно отправить значение при помощи команды Serial.println(значение) и открыть плоттер по последовательному соединению, например построим график значения с аналогового пина A0:

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

    Давайте выведем несколько случайных величин:

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

    Использование пинов

    Как я писал выше, аппаратный Serial имеет выводы на ноги микроконтроллера, для Nano/Uno/Mini это выводы D0 и D1. Можно ли работать с этими пинами, как с обычными цифровыми пинами? При отключенном Serial – можно, при включенном – нет. После вызова Serial.begin() ноги перестают функционировать как цифровые пины в ручном режиме, но после вызова Serial.end() можно снова ими пользоваться!

    Отправка и парсинг

    Рассмотрим самый классический пример для всех языков программирования: Hello World!

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

    Вывод: 0 50 68 85 15 214 63 254 – элементы массива, разделённые пробелами!

    Проблемы возникают при попытке принять данные в порт. Дело в том, что метод read() читает один символ, даже если вы отправите длинное число – программа получит его по одной цифре, и составлять число из цифр придётся вручную. Проблема усугубляется тем, что read() читает именно символ, то есть код символа в таблице ASCII.

    Посмотрим вот такой пример, в котором в порт отправляются принятые в него данные (так называемое эхо):

    Так как же принять именно цифру? Есть хитрость – вычитать из полученного кода символа код цифры 0, либо сам 0 в виде символа: ‘0’

    Также для принятия одиночных чисел у нас есть готовый метод – parseInt/parseFloat – для целочисленных и рациональных чисел соответственно. Процесс приёма и расшифровки данных называется парсинг (parsing). Давайте примем в порт число 1234, используя готовый метод парсинга.

    Итак, мы используем конструкцию if (Serial.available()) <> чтобы опрашивать порт только в том случае, если в него что-то пришло. Отправив в порт число 1234 мы получим ответ ОК, отправив любое другое – error. Также вы заметите, что после отправки проходит секунда, прежде чем плата ответит. Эта секунда спрятана внутри метода parseInt, программа ждёт секунду после принятия данных, чтобы все данные успели прийти. Секунда это очень много, достаточно было ждать, скажем, 50 миллисекунд. Это можно сделать при помощи метода setTimeout.

    Теперь после отправки цифры программа будет ждать всего 50 мс, и сразу же вам ответит.

    В реальном устройстве часто требуется передавать несколько параметров, например у нас Bluetooth танк. Мы ему должны отправить например скорость правой гусеницы, скорость левой гусеницы, положение башни, состояние подсветки, команду на выстрел… Да что угодно. Как быть в таком случае? Тут начинается настоящий парсинг, и появляются варианты, нам придётся придумывать собственный протокол связи.

    Есть два базовых варианта: отправка пакета всех-всех данных и его парсинг, или отправка отдельно каждого параметра с уникальным “ключом” у каждого. Как это понимать: суть первого варианта состоит в принятии пакета данных, которые разделены разделителем. Также правильно будет выделить начало и конец посылки. Пример: $120 80 180 1; – начальный символ $, разделитель ” ” (пробел) и завершающий символ ; . Наличие начального и завершающего символа повышает скорость работы и помехозащищённость связи. Второй вариант – посылки вида MOT1_120, содержащие ключ и значение, соответствующее этому ключу.

    Читайте также:  Максидом промокод на скидку

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

    • Уроки
    • Базовые уроки Arduino
    • Монитор порта, отладка

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

    Как мы с вами знаем из урока “О платформе“, на платах Ардуино стоит USB-TTL конвертер, позволяющий микроконтроллеру в текстовом режиме “консоли” общаться с компьютером по последовательному интерфейсу, Serial. На компьютере создаётся виртуальный COM порт, к которому можно подключиться при помощи программ-терминалов порта, и принимать-отправлять текстовые данные. Через этот же порт загружается прошивка, т.к. поддержка Serial является встроенной в микроконтроллер на “железном” уровне, и USB-TTL преобразователь подключен именно к этим выводам микроконтроллера. На плате Arduino Nano это кстати пины D0 и D1.

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

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

    Если с отправкой, автопрокруткой, отметками времени и кнопкой “очистить вывод” всё понятно, то конец строки и скорость мы рассмотрим подробнее:

    • Конец строки: тут есть несколько вариантов на выбор, чуть позже вы поймёте, на что они влияют. Лучше поставить нет конца строки, так как это позволит избежать непонятных ошибок на первых этапах знакомства с Ардуино.
    • Нет конца строки – никаких дополнительных символов в конце введённых символов после нажатия на кнопку отправка/Enter
    • NL – символ переноса строки в конце отправленных данных
    • CR – символ возврата каретки в конце отправленных данных
    • NL+CR – и то и то
  • Скорость – тут на выбор нам даётся целый список скоростей, т.к. общение по Serial может осуществляться на разных скоростях, измеряемых в бод (baud), и если скорости приёма и отправки не совпадают – данные будут получены некорректно. По умолчанию скорость стоит 9600, её и оставим.
  • Очистить вывод – тут всё понятно, очищает вывод
  • Объект Serial

    Начнём знакомство с одной из самых полезных штук Arduino-разработчика – Serial. Serial это объект класса Stream, позволяющий как просто принимать/отправлять данные через последовательный порт, так и наследует из класса Stream кучу интересных возможностей и фишек, давайте сразу их все рассмотрим, а потом перейдём к конкретным примерам.

    Запустить связь по Serial на скорости speed (baud rate, бит в секунду). Скорость можно поставить любую, но есть несколько “стандартных”. Список скоростей для монитора порта Arduino IDE:

    • 300
    • 1200
    • 2400
    • 4800
    • 9600 чаще всего используется, можно назвать стандартной для большинства устройств с связью через TTL
    • 19200
    • 38400
    • 57600
    • 115200 тоже часто встречается
    • 230400
    • 250000
    • 500000
    • 1000000
    • 2000000

    Отправляет в порт значение val – число или строку. В отличие от write выводит именно символы, т.е. отправив 88 вы получите 88: Serial.print(88); выведет 88. Также метод print/println имеет несколько настроек для разных данных, что делает его очень удобным инструментом отладки:

    format позволяет настраивать вывод данных: BIN, OCT, DEC, HEX выведут число в соответствующей системе исчисления, а цифра после вывода float позволяет настраивать выводимое количество знаков после точки

    Полный аналог print(), но автоматически переводит строку после вывода. Позволяет также вызываться без аргументов (с пустыми скобками) просто для перевода строки

    Читает данные из буфера и ищет набор символов target (тип char), опционально можно указать длину length. Возвращает true, если находит указанные символы. Ожидает передачу по таймауту

    Плоттер

    Помимо монитора последовательного порта, в Arduino IDE есть плоттер – построитель графиков в реальном времени по данным из последовательного порта. Достаточно отправить значение при помощи команды Serial.println(значение) и открыть плоттер по последовательному соединению, например построим график значения с аналогового пина A0:

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

    Давайте выведем несколько случайных величин:

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

    Использование пинов

    Как я писал выше, аппаратный Serial имеет выводы на ноги микроконтроллера, для Nano/Uno/Mini это выводы D0 и D1. Можно ли работать с этими пинами, как с обычными цифровыми пинами? При отключенном Serial – можно, при включенном – нет. После вызова Serial.begin() ноги перестают функционировать как цифровые пины в ручном режиме, но после вызова Serial.end() можно снова ими пользоваться!

    Отправка и парсинг

    Рассмотрим самый классический пример для всех языков программирования: Hello World!

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

    Вывод: 0 50 68 85 15 214 63 254 – элементы массива, разделённые пробелами!

    Проблемы возникают при попытке принять данные в порт. Дело в том, что метод read() читает один символ, даже если вы отправите длинное число – программа получит его по одной цифре, и составлять число из цифр придётся вручную. Проблема усугубляется тем, что read() читает именно символ, то есть код символа в таблице ASCII.

    Посмотрим вот такой пример, в котором в порт отправляются принятые в него данные (так называемое эхо):

    Так как же принять именно цифру? Есть хитрость – вычитать из полученного кода символа код цифры 0, либо сам 0 в виде символа: ‘0’

    Также для принятия одиночных чисел у нас есть готовый метод – parseInt/parseFloat – для целочисленных и рациональных чисел соответственно. Процесс приёма и расшифровки данных называется парсинг (parsing). Давайте примем в порт число 1234, используя готовый метод парсинга.

    Итак, мы используем конструкцию if (Serial.available()) <> чтобы опрашивать порт только в том случае, если в него что-то пришло. Отправив в порт число 1234 мы получим ответ ОК, отправив любое другое – error. Также вы заметите, что после отправки проходит секунда, прежде чем плата ответит. Эта секунда спрятана внутри метода parseInt, программа ждёт секунду после принятия данных, чтобы все данные успели прийти. Секунда это очень много, достаточно было ждать, скажем, 50 миллисекунд. Это можно сделать при помощи метода setTimeout.

    Теперь после отправки цифры программа будет ждать всего 50 мс, и сразу же вам ответит.

    В реальном устройстве часто требуется передавать несколько параметров, например у нас Bluetooth танк. Мы ему должны отправить например скорость правой гусеницы, скорость левой гусеницы, положение башни, состояние подсветки, команду на выстрел… Да что угодно. Как быть в таком случае? Тут начинается настоящий парсинг, и появляются варианты, нам придётся придумывать собственный протокол связи.

    Читайте также:  Микроволновая печь лджи инвертор

    Есть два базовых варианта: отправка пакета всех-всех данных и его парсинг, или отправка отдельно каждого параметра с уникальным “ключом” у каждого. Как это понимать: суть первого варианта состоит в принятии пакета данных, которые разделены разделителем. Также правильно будет выделить начало и конец посылки. Пример: $120 80 180 1; – начальный символ $, разделитель ” ” (пробел) и завершающий символ ; . Наличие начального и завершающего символа повышает скорость работы и помехозащищённость связи. Второй вариант – посылки вида MOT1_120, содержащие ключ и значение, соответствующее этому ключу.

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

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

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

    Среда Arduino IDE не содержит отладчика, что создает определенные проблемы в поиске ошибок кода программы. Без ошибок программы сразу не пишутся. Формальные ошибки выявляются при компиляции, а с алгоритмическими и вычислительными ошибками намного сложнее.

    В интернете описывается много способов отладки программ, которые используют дополнительные библиотеки, программы, аппаратные адаптеры. Но основная функция отладки это увидеть состояние программы, узнать значение переменных. Это можно сделать, передав нужную информацию на компьютер через последовательный интерфейс. Физическое подключение платы Ардуино к компьютеру через USB кабель существует всегда. Среда Arduino IDE имеет монитор последовательного порта, позволяющий получать и посылать данные обмена с платой. Можно передать на компьютер любую информацию о состоянии программы и вывести ее на дисплей. Меня такой способ отладки вполне устраивает. Только вместо монитора Arduino IDE я иногда использую свои программы, которые выводят данные в удобном мне виде.

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

    Последовательный интерфейс UART.

    UART в переводе это универсальный асинхронный приемопередатчик. Данные UART передаются последовательным кодом в следующем формате.

    Каждый бит передается за равные промежутки времени. Время передачи одного бита определяется скоростью передачи. Скорость передачи указывается в бодах (бит в секунду). Кроме битов данных интерфейс UART вставляет в поток биты синхронизации: стартовый и стоповый. Таким образом, для передачи байта информации требуется 10 битов, а не 8. Погрешность временных интервалов передачи битов должна быть не более 5% (рекомендуется не более 1,5%).

    Я описываю наиболее распространенный формат. Существуют варианты с разным количеством битов данных, битов синхронизации, может быть добавлен бит контроля четности и т.п. Но эти форматы используются редко. Главное запомнить:

    • в неактивном режиме выход UART находится в высоком состоянии;
    • передача байта начинается со стартового бита (низкого уровня);
    • передача байта заканчивается стоповым битом (высокого уровня);
    • данные передаются младшим битом вперед;
    • для передачи байта требуется 10 битов;
    • время передачи одного байта рассчитывается исходя из скорости передачи и количества битов (10).

    Часто используются следующие стандартные скорости передачи интерфейса UART.

    Скорость передачи,
    бод
    Время передачи одного бита, мкс Время передачи байта,
    мкс
    4800 208 2083
    9600 104 1042
    19200 52 521
    38400 26 260
    57600 17 174
    115200 8,7 87

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

    • TX – выход для передачи данных;
    • RX – вход для приема данных.

    При соединении двух UART устройств выход TX одного устройства соединяется со входом RX другого. А сигнал TX второго UART подключается к входу RX первого.

    Последовательный интерфейс UART в Ардуино.

    Любая плата Ардуино имеет, как минимум, один аппаратный последовательный интерфейс UART. Платы Arduino Mega и Arduino Due имеют по три порта.

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

    Плата Arduino UNO имеет один порт UART, сигналы которого подключены к выводам 0 (сигнал RX) и 1 (сигнал TX). Сигналы имеют логические уровни TTL (0…5 В). Через эти выводы (0 и 1) можно подключить к плате другое устройство имеющее интерфейс UART.

    Кроме функции связи с другими контроллерами порт UART платы Arduino UNO используется для загрузки в контроллер программы из компьютера. Для этого к этим же сигналам (RX и TX) подключены соответствующие выводы микросхемы ATmega16U2 – преобразователя интерфейса USB/UART. Микросхема преобразователя подключена через резисторы сопротивлением 1 кОм.

    Фрагмент схемы платы Arduino UNO R3.

    Таким образом, при свободных выводах 0 и 1 платы Ардуино сигналы с микросхемы ATmega16U2 поступают на контроллер ATmega328. А если к плате подключить внешнее UART устройство, то его сигналы будут иметь приоритет, т.к. ATmega16U2 подключена через резисторы.

    Преобразователь интерфейса ATmega16U2 позволяет подключать плату Ардуино к компьютеру через USB порт. На компьютер устанавливается драйвер. Он создает на компьютере виртуальный COM порт. Через него и происходит обмен. Такая технология описана на примере другого преобразователя интерфейсов PL2303 USB-UART по этой ссылке. Там же есть информация о вариантах UART интерфейсах с разными уровнями сигналов.

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

    Библиотека Serial для работы с UART Ардуино.

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

    Через последовательный интерфейс данные всегда передаются в двоичном коде. Вопрос как эти данные интерпретировать, как воспринимать. Например, передан двоичный код “01000001” (десятичный 65). Как его отобразить на экране? Может быть передано число 65 и на экране надо вывести ”65”. А может это код буквы ”A”, тогда на экране надо написать ”A”. Просто необходимо знать в каком формате передаются данные.

    В классе Serial данные могут передаваться в двух форматах:

    • как бинарный код;
    • как ASCII символы.

    Например, монитор последовательного порта в программе Arduino IDE принимает данные как ASCII текст. Для того, чтобы он вывел на экран компьютера число “65” надо передать коды символов “6” и “5”. А код ”65” монитор отобразит как символ “A”.

    Основные функции класса Serial.

    void begin(long speed)

    Разрешает работу порта UART и задает скорость обмена в бод (бит в сек). Для задания скорости передачи данных рекомендуется использовать стандартные значения (таблица в разделе “Последовательный интерфейс UART”).

    Serial.begin(38400); // инициализация порта, скорость 38400 бод

    void end(void)

    Отключает порт UART, освобождает выводы RX и TX.

    Serial.end(); // закрыть порт UART

    int available(void)

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

    Читайте также:  Можно ли удалить видео с ютуба свое

    int n;
    n= Serial. available(); // в n число принятых байтов

    int read(void)

    Возвращает очередной байт из буфера последовательного порта. Если буфер пуст – возвращает число – 1 (0xffff).

    receiveByte= Serial.read(); // чтение байта из буфера

    void flush(void)

    Ожидает окончания передачи данных из буфера последовательного порта.

    Serial.flush(); // ждем окончания передачи

    print()

    Выводит данные через последовательный порт UART в виде ASCII символов. Функция имеет различные формы вызова для разных форматов и типов данных.

    print(char d) Если аргумент типа char выводит в порт код символа

    char d= 83;
    Serial.print(d); // выводит код 83 (символ S)
    Serial.print(‘S’); // выводит код 83 (символ S)

    print(byte d)

    Данные типа byte выводятся кодом числа

    byte d= 83;
    Serial.print(d); // выводит код 83 (символ S)
    Serial.print(byte(83)); // выводит код 83 (символ S)

    print(int d) Если аргумент – целый тип, то выводит строку с десятичным представлением числа

    int d= 83;
    Serial.print(d); // выводит строку “83”
    Serial.print(83); // выводит строку “83”

    print(float) Вещественные типы выводятся символами ASCII, два знака после запятой

    float d= 7.65432;
    Serial.print(d); // выводит строку “7.65”
    Serial.print(7.65432); // выводит строку “7.65”

    print(* str) Если аргумент указатель на массив или строка, то массив или строка побайтно передается в порт.

    char letters[3]= <65, 66, 67>;
    Serial.print(“Буквы”); // выводит строку “Буквы”
    Serial.print(letters); // выводит строку из 3 символов с кодами 65, 66, 67

    print(int d, DEC) Выводит строку ASCII – десятичное представление числа

    int d= 83;
    Serial.print(d, DEC); // вывод строки “83”

    print(int d, HEX) Выводит строку ASCII – шестнадцатиричное представление числа

    int d= 83;
    Serial.print(d, HEX); // вывод строки “53”

    print(int d, OCT) Выводит строку ASCII – восьмеричное представление числа

    int d= 83;
    Serial.print(d, OCT); // вывод строки “123”

    print(int d, BIN) Выводит строку ASCII – двоичное представление числа

    int d= 83;
    Serial.print(d, BIN); // вывод строки “01010011”

    print(int d, BYTE) Выводит код младшего байта числа

    int d= 0x0283;
    Serial.print(d, BYTE); // вывод числа 83 (код символа S)

    print(float d, N) Для вещественных чисел параметр N задает количество цифр после запятой.

    Serial.print(7.65432, 0); // выводит строку “7”
    Serial.print(7.65432, 2); // выводит строку “7.65”
    Serial.print(7.65432, 4); // выводит строку “7.6543”

    println()

    Выводит данные через последовательный порт UART в виде ASCII символов с добавлением символов переноса строки (
    , код 13) и (
    , код 10). Т.е. следующее сообщение будет отображаться с новой строки. В остальном аналогична функции print().

    int d= 83;
    Serial.print(d, DEC); // вывод строки “83”
    Serial.println(d, DEC); // вывод строки “83

    int write()

    Выводит двоичные данные через последовательный порт UART. Возвращает количество переданных байтов.

    int write(val) Передает байт

    Serial.write(83); // передает байт 83

    int write(str) Передает строку, как последовательность байтов

    int bytesNumber; // число байтов
    bytesNumber= Serial.write(”Строка”); // передает строку ”Строка”, возвращает длину строки

    int write(* buf, len) Передает байты из массива, число байтов – len.

    char buf= “Строка”;
    Serial.write(buf, 3); // выводит строку “Стр”

    int peek(void)

    Возвращает следующий байт из буфера последовательного порта, не удаляя его из буфера. Если буфер пуст, то возвращает значение -1. Функция возвращает то же значение, что и функция read().

    int readBytes(* buf, len)

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

    setTimeout(long time)

    Задает время тайм-аута для функции readBytes(). Время time указывается в мс, по умолчанию оно равно 1000 мс.

    void serialEvent()

    Вызывается при поступлении данных в последовательный порт. По сути – прерывание по приему данных последовательным портом.

    // код для обработки данных порта

    Применение класса Serial.

    Класс Serial встроенный. Для него не надо искать библиотеку и подключать ее. Чтобы использовать UART достаточно в setup() разрешить работу порта и задать скорость:

    void setup() <
    Serial.begin(9600); // инициализируем порт, скорость 9600
    >

    Теперь можно передавать данные с помощью функций print() или write().

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

    Вот программа, которая каждую секунду выводит в монитор последовательного порта сообщение и номер прохода.

    unsigned int i=0;
    void setup() <
    Serial.begin(9600); // инициализируем порт, скорость 9600
    >

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

    if( Serial.available() > 0 ) <
    // есть данные

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

    unsigned int i=0;
    void setup() <
    Serial.begin(9600); // инициализируем порт, скорость 9600
    >

    Отладка программ с помощью последовательного порта на Ардуино.

    Принцип отладки простой.

    • С помощью последовательного порта и функций класса Serial мы можем передать на компьютер информацию о состоянии программы.
    • С помощью монитора последовательного порта Arduino IDE или другой программы мы можем эти данные увидеть на экране компьютера.
    • Этими же программными средствами можно передать данные в программу Ардуино и повлиять на ее работу.

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

    Для кнопок, подключенных по схеме предыдущего урока, скетч программы выглядит так.

    // отладка кнопок с помощью порта UART

    #define BUTTON_1_PIN 12 // кнопка 1 подключена к выводу 12
    #define BUTTON_2_PIN 11 // кнопка 2 подключена к выводу 11

    Button button1(BUTTON_1_PIN, 20); // создание объекта кнопка 1
    Button button2(BUTTON_2_PIN, 20); // создание объекта кнопка 2

    void setup() <
    Serial.begin(9600); // инициализируем порт, скорость 9600
    MsTimer2::set(2, timerInterupt); // задаем прерывания по таймеру с периодом 2 мс
    MsTimer2::start(); // разрешаем прерывание
    >

    // проверка кнопки 1
    if ( button1.flagClick == true ) <
    button1.flagClick= false;
    Serial.println("Button 1 was pressed"); // сообщение для монитора
    >

    // проверка кнопки 2
    if ( button2.flagClick == true ) <
    button2.flagClick= false;
    Serial.println("Button 2 was pressed"); // сообщение для монитора
    >
    >

    // обработка прерывания
    void timerInterupt() <
    button1.scanState(); // вызов метода обработки сигнала кнопки 1
    button2.scanState(); // вызов метода обработки сигнала кнопки 2
    >

    Теперь на каждое нажатие кнопки 1 через последовательный порт платы Ардуино на компьютер будет передаваться сообщение “ Button 1 was pressed”, а по нажатию кнопки 2 – сообщение “Button 2 was pressed”. Приходится писать по английски. Монитор не воспринимает русские символы. В дальнейших уроках исправим.

    Чтобы увидеть эти сообщения надо запустить монитор порта: Инструменты -> Монитор порта. Теперь можно нажимать на кнопки и видеть реакцию в окне монитора.

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

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

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

    Читайте также:

    Добавить комментарий

    Ваш адрес email не будет опубликован. Обязательные поля помечены *

    Adblock detector