COM-port в Arduino: что означает Serial.begin 9600

Содержание
  1. Краткое описание
  2. Скетч
  3. Serial.begin()
  4. Serial.available()
  5. Serial.read()
  6. Serial.write()
  7. Отправка и парсинг
  8. Отправка команд с ПК
  9. Принцип действия
  10. Прием последовательных данных
  11. Таблица ASCII
  12. Параметры UART
  13. Скорость передачи
  14. Длина данных
  15. Бит четности
  16. Количество стоп-битов
  17. Управление потоком
  18. Использование пинов
  19. Простой проект
  20. Компоненты
  21. Схема соединения
  22. Как соединить две ардуины по UART (serial) порту
  23. Схема соединения двух ардуин:
  24. Управление светодиодом с клавиатуры
  25. Синтаксис функции
  26. Скорость для последовательного порта в Serial.begin()
  27. Второй параметр для последовательного порта
  28. Функции Serial.find() и Serial.findUntil()
  29. Основные функций для работы с последовательным портом (Serial)
  30. Разные варианты функции print:
  31. Функция write:
  32. Управляющие символы
  33. Приём данных
  34. Функции Serial.print() и Serial.println()
  35. Плоттер
  36. Пример 1. Передача данных по Serial-порту с Arduino на компьютер
  37. UART логический уровень
  38. Вопросы и ответы
  39. Serial begin 9600 – что это значит?
  40. На каких платах работает функция?
  41. Что будет, если не использовать функцию в скетче?
  42. Возможные проблемы
  43. Видео
  44. Другие варианты

Краткое описание

Функция begin () — это метод класса Serial. Для работы с этим классом нет необходимости включать внешние библиотеки, так как он интегрирован в среду разработки arduino. Рекомендуется использовать Serial.begin () один раз в начале скетча в функции void setup (). Скорость передачи последовательного порта должна быть указана в качестве аргументов. Наиболее распространенное значение — 9600 — это скорость передачи данных по умолчанию в мониторе порта Arduino IDE. После выполнения функции arduino сможет как отправлять данные на внешние устройства, так и получать их.

На платах с несколькими «железными» последовательными портами, например Arduino Mega, для каждого из них создается свой объект Serial, поэтому вместе с Serial могут происходить обращения к объектам Serial1, Serial2, Serial3.

Скетч

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

Сначала мы устанавливаем режим контакта 8 (кнопка) на INPUT_PULLUP, режим контакта 13 (светодиод) на OUTPUT и устанавливаем начальное состояние контакта 13 на LOW (светодиод выключен).

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

Serial.begin()

Для связи через интерфейс UART его сначала необходимо настроить. Самый простой способ настроить Arduino UART — использовать функцию Serial.begin (скорость). Параметр скорости — это скорость передачи данных, с которой мы хотим запустить UART. С помощью этой функции для остальных параметров UART будут установлены значения по умолчанию:

  • Длина данных = 8 (длина данных)
  • Бит четности = 1 (бит четности)
  • Количество стоповых битов = нет

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

Следующий код добавляет Serial.begin (9600); внутри setup () для инициализации Arduino Uno UART со скоростью 9600 бит / с и другими параметрами, установленными по умолчанию.

Следующая часть кода — это чтение и сохранение значения, полученного от последовательного интерфейса. Для этого мы будем использовать функцию Serial.available () вместе с оператором If, чтобы проверить, были ли получены данные. Затем мы вызываем Serial.read (), чтобы получить байт полученных данных и сохранить значение в переменной data_rcvd. Значение data_rcvd управляет включением / выключением встроенного светодиода.

Serial.available()

Чтобы проверить данные, ожидающие чтения в буфере UART (или последовательном интерфейсе), мы будем использовать функцию Serial.available (). Serial.available () возвращает количество байтов, ожидающих чтения в буфер.

Serial.read()

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

Serial.write()

Для отправки данных через контакты Arduino TX0 мы будем использовать функцию Serial.write (val). Параметр val — это байт (или серия байтов), который будет отправлен.

В нашем скетче мы отправим символьное значение в зависимости от состояния контакта 8. Мы отправим символьное значение «1», если на контакте 8 установлено ВЫСОКОЕ значение, или символьное значение «0», если на контакте 8 установлено значение НИЗКИЙ.

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

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

Вывод: 0 50 68 85 15 214 63 254 — элементы массива, разделенные пробелами! Проблемы возникают при попытке получить данные по порту. Дело в том, что метод read () считывает символ, даже если вы отправляете длинное число — программа будет получать его по одной цифре за раз, и вам придется вручную набирать номер из цифр. Проблема усугубляется тем, что read () читает именно символ, то есть код символа в таблице ASCII.
Давайте посмотрим на этот пример, где полученные в нем данные (так называемое эхо) отправляются в порт):

Теперь после отправки цифры программа будет ждать всего 50 мс и сразу же вам ответит. Остальные алгоритмы отправки и анализа, включая обмен различными типами данных между Arduino и другими платами, см. В уроке Serial.

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

Перед тем как это сделать, вы должны иметь представление о том, как работает COM-порт.
Прежде всего, вся подкачка происходит через буфер памяти. То есть, когда вы отправляете что-то с ПК на устройство, данные помещаются в специальный раздел памяти. Как только устройство готово, оно считывает данные из буфера. Функция Serial.avaliable () позволяет вам проверять состояние буфера. Эта функция возвращает количество байтов в буфере. Чтобы прочитать эти байты, используйте функцию Serial.read (). Давайте посмотрим, как работают эти функции на примере:

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

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

Использование монитора COM-порта, встроенного в IDE Arduino, имеет некоторые ограничения. При отправке данных с карты в COM-порт вывод можно организовать в произвольном формате. А при отправке с ПК на карту символы передаются согласно таблице ASCII. Это означает, что когда вы вводите, например, символ «1», «00110001» (т.е. «49» в десятичном формате) отправляется через COM-порт в двоичном формате).

Давайте немного подправим код и проверим это объявление:

После загрузки в мониторе порта при отправке «1» вы увидите в ответ: «Я получил: 110001». Вы можете изменить формат вывода и посмотреть, что карта принимает с другими символами.

Принцип действия

UART работает путем преобразования данных в пакеты для отправки или получения данных из полученных пакетов.

Прием последовательных данных

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

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

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

Таблица ASCII

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

В переменном символе хранится код символа. Таблица начинается с 33 и заканчивается 126, поэтому символу изначально присвоено значение 33.

Функция Serial.begin () используется для запуска операции порта UART. Единственный его параметр — скорость. Необходимо заранее согласовать скорость на отправляющей и принимающей сторонах, так как протокол передачи асинхронный. В этом примере скорость 9600 бит / с.
Для записи значения в порт используются три функции:

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

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

Дверной монитор

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

Таблица ASCII

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

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

Параметры UART

У UART есть настройки, которые должны быть одинаковыми на обоих устройствах для правильной связи. Эти настройки UART включают скорость передачи данных, длину данных, бит четности, количество стоповых битов и управление потоком.

Скорость передачи

Скорость передачи — это количество бит в секунду (бит / с), которое устройство UART может передавать / принимать. Для правильной передачи данных оба устройства UART должны быть настроены на одинаковую скорость передачи данных. Стандартные скорости передачи: 9600, 1200, 2400, 4800, 19200, 38400, 57600 и 115200 бит / с.

Длина данных

Длина данных — это количество бит на байт данных.

Бит четности

Бит четности — это бит, добавляемый к передаваемым данным, который сообщает получателю, является ли количество единиц в переданных данных четным или нечетным. Возможная установка бита четности — нечетный (НЕЧЕТНЫЙ) или четный (ЧЕТНЫЙ).

  • ODD — бит четности равен «1», если данные содержат нечетное число 1. В противном случае бит четности устанавливается в ноль.
  • ЧЕТНЫЙ — Бит четности равен «1», если в данных есть четное число, равное единице. В противном случае бит четности устанавливается в ноль.

Количество стоп-битов

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

Управление потоком

Управление потоком — это метод предотвращения риска потери данных при передаче данных по UART. Устройство UART использует специальные символы в качестве управления потоком для запуска / остановки передачи данных.

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

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

Простой проект

Узнав, как работает UART, давайте теперь создадим простой проект и напишем скетч, демонстрирующий, как использовать связь UART с помощью Arduino Uno.

Наш проект заключается в удаленном управлении встроенным светодиодом Arduino через UART. Кнопка, подключенная к первой карте Uno, будет управлять встроенным светодиодом второй карты Uno и наоборот.

Компоненты

Для создания нашего проекта нам потребуются следующие компоненты:

  1. Arduino Uno (2 шт.)
  2. Пуговицы (2 шт.)
  3. Договоренность
  4. Джемперы

Схема соединения

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

Как соединить две ардуины по UART (serial) порту

Схема соединения двух ардуин:

1-й —- 2

GND <—> GND

RX <—> TX

TX <—> RX

Длина и скорость кабеля: RS-232 (рекомендуемый стандарт 232) — это стандарт физического уровня для асинхронного интерфейса (UART).

Максимальное расстояние связи RS232 15 метров.

Но все зависит от скорости.

Управление светодиодом с клавиатуры

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

Часть кода нам уже знакома: мы используем светодиод номер 13.

Сигнал с компьютера поступает в виде байтов. Для этого создадим новую переменную incomingByte.

Последовательный порт включается командой begin () с указанной скоростью.

Если от компьютера получен сигнал, функция available () вернет количество байтов, доступных для чтения. Итак, мы просто убеждаемся, что пришел сигнал (больше нуля).

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

Как это выглядит на практике. Скомпилируйте скетч и запустите Serial Monitor (Ctrl + Shift + M). Окно Serial Monitor имеет текстовое поле вверху. Введите цифры 1 или 0 и нажмите кнопку «Отправить». Вы также можете нажать клавишу Enter для быстрого ввода.

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

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

Функция Serial.end () закрывает последовательное соединение, порты RX и TX освобождаются и могут использоваться для ввода-вывода.

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

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

Также существует библиотека SoftwareSerial. Позволяет последовательную передачу данных через другие цифровые контакты на Arduino.

Синтаксис функции

Команда Serial.begin () состоит из двух частей. Первая часть, Serial, — это имя класса библиотеки для работы с дверным монитором. Вторая часть, begin (), обозначает имя метода, которому нам нужно передать аргумент: скорость обмена данными. Функция не возвращает значений.

Синтаксис функции, два варианта:

Параметры:

  • speed — скорость передачи данных (бит / сек или бод).
  • config — настройки режима работы последовательного порта. По умолчанию используется наиболее распространенный вариант — SERIAL_8N1.

Скорость для последовательного порта в Serial.begin()

Стандартное значение скорости в аргументе функции begin () — 9600. Эта цифра означает, что плата Arduino будет отправлять данные через последовательный порт со скоростью 9600 бит в секунду (обратите внимание, что стоповый бит службы также отправляется каждые 8 ​​бит). Конечно, приемное и передающее устройства на другом конце кабеля также должны быть настроены на ту же скорость, иначе он потеряет несколько бит или будет излишне спешить, что приведет к десинхронизации — информация будет разорвана на части. Поэтому не меняйте без надобности параметр по умолчанию — 9600.

Помимо стандартного значения можно установить другие: 300, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 38400, 57600, 115200. Чем выше число, тем выше курс обмена, но необходимо внести убедитесь, что эта скорость поддерживается внешним устройством… В некоторых ситуациях слишком высокая скорость обмена может привести к ошибкам, и это следует учитывать. Так, например, значение 115200 обычно устанавливается специальными высокоскоростными устройствами, например, полетными контроллерами. Значения ниже 9600 используются редко.

Второй параметр для последовательного порта

Параметр config в функции begin обычно не указывается, так как значения по умолчанию меняются крайне редко. Но на всякий случай вот возможные варианты параметров, которые можно найти в HardwareSerial.h:

  • #define SERIAL_5N1 0x00
  • #define SERIAL_6N1 0x02
  • #define SERIAL_7N1 0x04
  • #define SERIAL_8N1 0x06
  • #define SERIAL_5N2 0x08
  • #define SERIAL_6N2 0x0A
  • #define SERIAL_7N2 0x0C
  • #define SERIAL_8N2 0x0E
  • #define SERIAL_5E1 0x20
  • #define SERIAL_6E1 0x22
  • #define SERIAL_7E1 0x24
  • #define SERIAL_8E1 0x26
  • #define SERIAL_5E2 0x28
  • #define SERIAL_6E2 0x2A
  • #define SERIAL_7E2 0x2C
  • #define SERIAL_8E2 0x2E
  • #define SERIAL_5O1 0x30
  • #define SERIAL_6O1 0x32
  • #define SERIAL_7O1 0x34
  • #define SERIAL_8O1 0x36
  • #define SERIAL_5O2 0x38
  • #define SERIAL_6O2 0x3A
  • #define SERIAL_7O2 0x3C
  • #define SERIAL_8O2 0x3E

Эти константы указывают на разные варианты структуры пакета данных. Например, SERIAL_8N2 означает, что через последовательный порт Arduino будет передавать 8-битный пакет без бита четности (обозначен N) и со стоповым битом, который будет добавлен после байта данных.

Функции Serial.find() и Serial.findUntil()

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

В этом примере программа считывает данные из буфера, и когда полученные данные соответствуют строке поиска (test), отображается сообщение (ok).

Serial.find () ожидает данных в течение времени, указанного с помощью функции Serial.setTimeout (). В случаях, когда в буфере находится большой объем данных, его можно обработать практически мгновенно. Когда буфер пуст, функция некоторое время ожидает следующих данных и завершается, возвращая соответствующее значение.

Serial.findUntil () — это вариант Serial.find (), который отличается от своего предшественника дополнительным аргументом, который позволяет остановить загрузку буфера последовательного порта. Пример синтаксиса показан ниже:

Функция будет считывать данные из последовательного порта до тех пор, пока не найдет строку поиска (текст) или не прочитает символ «K», или пока не истечет определенное время (по умолчанию — 1 секунда).

Основные функций для работы с последовательным портом (Serial)

Serial.begin (скорость) — открывает последовательный порт и устанавливает скорость последовательной передачи данных. Типичная скорость передачи данных для компьютерной связи составляет 9600 бод.

Очевидно, что когда последовательный порт включен, контакты 0 (RX) и 1 (TX) не могут использоваться для каких-либо других целей.

Serial.println (данные) — отправляет данные в последовательный порт с последующим переносом слов и новой строкой.

Serial.print (data) — тоже самое без возврата каретки и новой строки.

count = Serial.available (); — Байты, полученные через последовательный порт, попадают в буфер микроконтроллера, откуда ваша программа может их прочитать. Функция возвращает количество байтов, накопленных в буфере. В последовательном буфере может храниться до 128 байт.

Разные варианты функции print:

Серийный принт (b, DEC); — вывести строку ASCII — десятичное представление числа b.

Serial.print (b, BYTE) — выводит младший байт числа b.

(аналогично HEX, OCT, BIN).

Serial.print (str) // если str является строкой или символьным массивом, передать str в COM-порт по байтам.

Serial.println (); — разница в том, что после данных выводятся два дополнительных символа: символ возврата каретки (ASCII 13 или ‘ r’) и символ новой строки (ASCII 10 или ‘ n’).

Функция write:

Serial.write (uint8_t c); — Записывает данные в последовательный порт. Данные отправляются в виде байта или последовательности байтов.

Serial.write (val); // где val — это переменная, которая должна быть передана в виде одного байта

Serial.write (ex); // где str — строка, которая должна быть передана как последовательность байтов

Serial.write (buf, len); // где buf — массив, который нужно передать как последовательность байтов; len — это длина массива.

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

Существуют так называемые управляющие символы, позволяющие форматировать вывод. Их около десятка, но вот самые полезные

  • n — новая строка
  • r — возврат каретки
  • v — вертикальная табуляция
  • t — горизонтальная табуляция

Кроме того, если вы хотите использовать одинарные или двойные кавычки для вывода «или обратную косую черту «, вам необходимо вывести их, используя соответствующий специальный символ, иначе вывод будет «сломанным», я думаю, нет необходимости объяснять, почему:

  • «- цитаты
  • ‘- апостроф
  • — обратная косая черта
  • 0 — нулевой символ
  • ? — Вопросительный знак

Как использовать? Просто напишите на выходе. Например, комбинация r n переместит строку и вернет курсор в левую позицию:

Так работает функция println (), кстати, она просто добавляет вывод r n после print () =) Символы табуляции позволят вам удобно отправлять данные для последующей вставки в Excel или другие таблицы. Например, мы показываем несколько степеней двойки в табличной форме с помощью символа табуляции t:

Скопируйте и вставьте результат в Excel
Комфортный!

Приём данных

данные легко отправить в дверь. Но получить данные с компьютера и других источников сложнее. Когда данные отправляются, они добавляются в буфер, ожидая, пока карта их прочитает. Размер буфера составляет 64 байта. Чтобы не читать постоянно пустой буфер, есть специальная функция проверки буфера Serial.available (). Возвращает количество байтов в буфере. Обычно в коде создается управляющее условие: если в буфере больше 0 байт, мы выполняем какие-то команды.

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

Контроль над числами. Мы отправляем число 9, но получаем 57. Если вы получаете две строки с номерами 57 и 10, в нижней части окна выберите параметр «Без новой строки» вместо «Новая строка.

Также попробуем отправить письмо. Опять же вместо t возвращается 116. Ерунда. Все просто, функция read () работает со значениями символов, и мы видим код символа из стандартной таблицы символов ASCII.

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

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

Решение находится на полпути. Но как насчет больших чисел или слов?

Если вы отправите двузначное число 23, ответ разделится на части: 2 и 3. Получается, что переменная получит последнее число 3 (промежуточные значения перезаписываются). Для обработки всего числа нужно использовать метод parseInt().

Теперь вы можете ввести любое число. Но вы, вероятно, заметите небольшую задержку с ответом сейчас. Метод внутренне обрабатывает данные. Кстати, вы также можете использовать обычные символы. Если набор символов состоит только из букв, будет возвращено 0. Если числа найдены, будут возвращены числа. Попробуйте комбинировать различные комбинации цифр и букв, чтобы понять, как будут обрабатываться данные.

Функции Serial.print() и Serial.println()

Функция Serial.print () позволяет отправлять информацию через последовательный порт. Вы можете напрямую отправлять как текстовые, так и переменные значения или числа. Данные отправляются в кодировке ASCII. Это означает, что число вроде 12 будет отправлено как два символа 1 и 2. Вот типичный синтаксис для Serial.print():

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

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

Плоттер

В дополнение к монитору последовательного порта в Arduino IDE есть плоттер, графическое устройство в реальном времени, основанное на данных последовательного порта. Достаточно отправить значение через команду Serial.println (value) и открыть плоттер через последовательное соединение, например, мы сообщим значение с аналогового вывода A0:


Плоттер поддерживает несколько линий графиков одновременно, для их отображения необходимо следовать следующему протоколу передачи данных: значение1 пробел_или_заполненное значение2 пробел или запятое значение3 пробел_или_коммол значениеN разрыв строки, т. Е. Значения выводятся в строке по одному после другие по порядку, разделенные пробелом или запятой, и возврат каретки должен быть в конце строк. Выведем несколько случайных величин:

Значения выводятся каждые 10 миллисекунд, а значения обновляются каждые 300 миллисекунд. Получаем следующий график:
Начиная с версии 1.8.10, в Arduino IDE добавлена ​​возможность подписывать графики, для этого перед их просмотром вам нужно отправить имена в виде name 1, name 2, name n с разрывом строки, а затем просто просмотреть данные:

Пример 1. Передача данных по Serial-порту с Arduino на компьютер

Инициализация порта на скорости 9600 бот и передача данных (с Arduino на внешние устройства, например на компьютер):

UART логический уровень

Уровни логики UART могут варьироваться от производителя к производителю. Например, Arduino Uno имеет логический уровень 5 В, а порт RS232 компьютера имеет логический уровень +/- 12 В.

Подключение Arduino Uno напрямую к порту RS232 приведет к повреждению Arduino. Если оба устройства UART не имеют одинакового логического уровня, для подключения устройств требуется подходящая схема преобразователя логического уровня.

Вопросы и ответы

Serial begin 9600 – что это значит?

Эти три слова похожи на своего рода мантру. И действуют они одинаково: каким-то волшебным образом наша плата arduino организует канал связи и инициирует обмен информацией. Конечно, на самом деле никакой мистики во всем этом нет, но надо запомнить заклинание:

Эта строка сообщает контроллеру arduino доступ к последовательному порту через интерфейс UART, открытие его для записи и подписка на любое событие на его стороне (для получения данных). Его необходимо использовать перед отправкой информации на дверной монитор или считыванием данных.

На каких платах работает функция?

Эта функция работает на любой плате Arduino: Uno, Mega, Nano, Leonardo и т.д. Особенностью карт с несколькими «аппаратными» последовательными портами является возможность вызова последовательного объекта для каждого из этих портов.

Что будет, если не использовать функцию в скетче?

Все последующие команды для работы с последовательным портом работать не будут. Невозможно отправлять данные с помощью print () или println (), а также получать данные с помощью read () или readBytes().

Возможные проблемы

1) Автоматическая перезагрузка DTR: вы можете автоматически перезагружать MC при передаче на него данных в последовательном режиме. Чтобы выключить его, поместите конденсатор 10 мкФ между RES и GND. Поставил электролитический конденсатор (конечно + на РЭС).

Видео

Другие варианты

Чтение данных из последовательного порта возможно и другими способами. Ищите расширения, такие как Arduino Chrome Serial Monitor. В видео показано, как самому создать пристройку.

Вы также можете написать приложение на C #, которое может читать данные.

Processing также умеет работать с последовательным портом.

Оцените статью
Блог про Arduino
Adblock
detector