Serial ардуино: Serial | Аппаратная платформа Arduino

Таблица ASCII

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

int symbol = 33;

void setup() {
  Serial.begin(9600);
  Serial.println("ASCII Table ~ Character Map");
}

void loop() {
  Serial.write(symbol);
  Serial.print(", dec: ");
  Serial.print(symbol);
  Serial.print(", hex: ");
  Serial.print(symbol, HEX);
  Serial.print(", oct: ");
  Serial.print(symbol, OCT);
  Serial.print(", bin: ");
  Serial.println(symbol, BIN);
  if(symbol == 126) {
    while(true) {
      continue;
    }
  }
  symbol++;  
}

Переменная symbol хранит код символа. Таблица начинается со значения 33 и заканчивается на 126, поэтому изначально переменной symbol присваивается значение 33.
Для запуска работа порта UART служит функция Serial. begin(). Единственный ее параметр – это скорость. О скорости необходимо договариваться на передающей и приемной стороне заранее, так как протокол передачи асинхронный. В рассматриваемом примере скорость 9600бит/с.
Для записи значения в порт используются три функции:

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

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

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

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

Таблица ASCII

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

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

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

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

int val = 0;

void setup() {
        Serial.begin(9600); 
}

void loop() {
  if (Serial.available() > 0) {
    val = Serial.read();
    Serial.print("I received: ");
    Serial.write(val);
    Serial.println();
  }
}

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

int val = 0;

void setup() {
  Serial.begin(9600); 
}

void loop() {
  if (Serial.available() > 0) {
    val = Serial.read();
    Serial.print("I received: ");
    Serial.println(val,BIN);
  }
}

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

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

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

int val = 0;

void setup() {
        Serial.begin(9600); 
}

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

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

int val = '0';

void setup() {
        Serial.begin(9600); 
}

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

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

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

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

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

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

Arduino IDE для ESP8266 – esp8266

Arduino IDE для ESP8266 позволяет писать скетчи и загружать их одним кликом в ESP8266 в знакомой среде (я бы даже сказал «до боли знакомой») Arduino IDE. Для тех кому интерфейс Arduino IDE не очень по душе, есть поддержка плагина для Eclipse. Итак, обо всем по порядку. Самые нетерпеливые могут сразу перейти к Arduino IDE для ESP8266: быстрый старт

Arduino IDE для ESP8266 позволяет создавать прошивки и прошивать их в ESP8266 точно так же, как вы это делаете с Arduino. При этом никаких плат Arduino не требуется, это не тот случай, когда ESP8266 используется в качестве WiFi шилда для Arduino. Кроме того, вы можете использовать практически все Arduino библиотеки с ESP8266 после небольшой доработки. В настоящее время уже достаточно много библиотек адаптировано для использования с ESP8266, но о них чуть ниже.

Arduino IDE для ESP8266 поддерживает все существующие на сегодняшний день модули ESP8266 (потому что они особо и не отличаются), включая модули с флеш бОльшего, чем 512k объема. Поддерживаются модули NodeMCU (всех версий), Olimex-MOD-WiFi-ESP8266.

Поддерживается режим авторестарта и прошивки по RTS+DTR, как у обычной Arduino, для этого потребуется USB-TTL адаптер с разведенными пинами DTR и RTS. Если у вас только RX, TX и GND на USB-TTL, то придется по-старинке вручную притягивать к земле GPIO0 и передергивать питание модуля для прошивки.

Arduino IDE для ESP8266: краткий обзор реализованных в настоящее время функций

Базовые функции языка Wiring

Управление GPIO осуществляется точно также, как и управление pin для arduino: pinMode, digitalRead, digitalWrite,   analogWrite функционируют как обычно. GPIO нумеруются так, как мы уже привыкли: для чтения состояния GPIO2 нужно использовать команду digitalRead(2)

GPIO0-GPIO15 могут быть INPUT, OUTPUT, INPUT_PULLUP, и INPUT_PULLDOWN. GPIO16 может быть только INPUT, OUTPUT или INPUT_PULLDOWN. Команда analogRead(A0) считывает значение ADC (АЦП) с TOUT.

Команда analogWrite(pin, value) включает программный PWM (ШИМ) на указанном GPIO. Команда analogWrite(pin, 0) отключает PWM. value может быть в диапазоне от 0 до PWMRANGE. Константа PWMRANGE в настоящее время равна 1023.

Поддержка прерываний обеспечивается функциями attachInterrupt, detachInterrupt. Прерывания могут быть назначены на любой GPIO, кроме GPIO16. Стандартные прерывания Arduino CHANGE, RISING, FALLING тоже поддерживаются.

ESP8266 — функции пинов

Тайминг и delay

Функции millis и micros возвращают миллисекунды и микросекунды соответственно, прошедшие с момента старта модуля. Любимая многими функция delay также присутствует и приостанавливает выполнение скетча на указанное время в миллисекундах и позволяет отработать операциям WiFi и TCP/IP. Функция delayMicroseconds используется аналогично, только время задается в микросекундах.

Помните о том, что когда модуль поддерживает WiFi соединение, ему приходится выполнять множество фоновых задач, кроме вашего скетча. WiFi и TCP/IP функции библиотек SDK имеют возможность обработать все события в очереди после завершения каждого цикла вашей функции loop() или во время выполнения delay(…). Если в вашем коде есть фрагменты, которые выполняются более 50 миллисекунд, то необходимо использовать  delay(. ..) для сохранения нормальной работоспособности стека WiFi.

Также вы можете использовать функцию yield(), которая эквивалентна delay(0). С другой стороны, функция delayMicroseconds блокирует выполнение других задач, поэтому ее использование для временных задержек свыше 20 миллисекунд не рекомендуется.

Последовательные порты Serial и Serial1 (UART0 и UART1)

Объект Serial работает точно также, как и с Arduino. Помимо аппаратного FIFO (по 128 байт для приема и передачи) определен и программный буфер размером по 256 байт для приема и передачи данных. Прием и передача данных происходит по прерываниям, прозрачно для вашего скетча. Функции записи и чтения блокируют выполнение скетча только когда аппаратный FIFO и программный буфер переполняются.

Serial использует аппаратный UART0, работающий на GPIO1(TX) и GPIO3(RX). Эти пины могут быть переназначены на GPIO15 (TX) и GPIO13 (RX) вызовом функции Serial.swap(); после Serial.begin();. Повторный вызов Serial.swap(); вернет все на свои места.

Serial1 использует аппаратный UART1, работающий только на передачу. UART1 TX это GPIO2. Для включения Serial1 используйте Serial1.begin();

По умолчанию, отладочная информация библиотек WiFi выключается, когда вы вызываете функцию Serial.begin();. Для включения отладочной информации на UART0 используйте Serial.setDebugOutput(true); Для перенаправления вывода отладочной информации на UART1 используйте команду Serial1.setDebugOutput(true);

И Serial и Serial1 поддерживают 5, 6, 7, 8 бит данных, odd (O), even (E), и no (N) режимы четности, и 1 или 2 стоп бита. Для выбора нужного режима вызывайте Serial.begin(baudrate, SERIAL_8N1); или Serial.begin(baudrate, SERIAL_6E2); и т.д.

PROGMEM

Макрос PROGMEM работает точно также, как в Arduino, помещая read only данные и строковые константы (литералы) во флеш память, высвобождая HEAP. Важное отличие состоит в том, что в ESP8266 одинаковые литералы не хранятся в одном месте, поэтому использование строковых констант внутри конструкций F(«») и/или PSTR(«») приводит к расходованию флеш памяти при каждом вызове этих функций. Вы должны самостоятельно управлять одинаковыми строками для экономичного расходования места во флеш памяти.

Библиотека WiFi ESP8266 (ESP8266WiFi)

Функции библиотеки WiFi ESP8266 очень схожи с функциями библиотеки для обычного WiFi шилда.

Список отличий:

• WiFi.mode(m): выбрать режим WIFI_AP (точка доступа), WIFI_STA (клиент), или WIFI_AP_STA (оба режима одновременно).
• WiFi.softAP(ssid) создает открытую точку доступа
• WiFi.softAP(ssid, password) создает точку доступа с WPA2-PSK шифрованием, пароль должен быть не менее 8 символов
• WiFi.macAddress(mac) позволяет получить MAC адрес в режиме клиента
• WiFi.softAPmacAddress(mac) позволяет получить MAC адрес в режиме точки доступа
• WiFi.localIP() позволяет получить IP адрес в режиме клиента
• WiFi.softAPIP() позволяет получить IP адрес в режиме точки доступа
• WiFi.RSSI() пока не реализована
• WiFi.printDiag(Serial); выводит диагностическую информацию

• Класс WiFiUDP поддерживает прием и передачу multicast пакетов в режиме клиента. Для передачи multicast пакета используйте вместо udp.beginPacket(addr, port) функцию udp.beginPacketMulticast(addr, port, WiFi.localIP()). Когда вы ожидаете multicast пакеты, используйте вместо udp.begin(port) функцию udp.beginMulticast(WiFi.localIP(), multicast_ip_addr, port). Вы можете использовать udp.destinationIP() для определения того, был ли пакет отправлен на multicast адрес или предназначался именно вам. Multicast функции не поддерживаются в режиме точки доступа.

WiFiServer, WiFiClient, и WiFiUDP работаю точно так же, как и с библиотекой обычного WiFi шилда. Четыре примера идет в комплекте с этой библиотекой.

Тикер

Библиотека Ticker может быть использована для выполнения периодически повторяющихся событий через определенное время. Два примера включено в поставку.

В настоящее время не рекомендуется блокировать операции ввода-вывода (сеть, последовательный порт, файловые операции) в callback функциях тикера. Вместо блокирования устанавливайте флаг в callback функциях и проверяйте этот флаг в основном цикле.

EEPROM

Эта библиотека немного отличается от стандартной Arduino EEPROM. Необходимо вызвать функцию EEPROM.begin(size) каждый раз перед началом чтения или записи, размер (указывается в байтах) соответствует размеру данных, которые вы намереваетесь использовать в EEPROM. Размер данных должен быть в диапазоне от 4 до 4096 байт.

Функция EEPROM.write не производит запись данных во флеш память немедленно, вы должны использовать функцию EEPROM.commit() каждый раз, когда вы хотите сохранить данные в память. Функция EEPROM.end() тоже производит запись данных, а также освобождает оперативную память от данных, запись которых произведена. Библиотека EEPROM использует один сектор во флеш памяти, начиная с адреса 0x7b000 для хранения данных. В поставку включено три примера работы с EEPROM.

I2C (Библиотека Wire)

Реализован только режим ведущего, частота ориентировочно до 450 кГц. Перед использованием шины I2C, нужно выбрать пины SDA и SCL путем вызова функции Wire. pins(int sda, int scl), например Wire.pins(0, 2) для модуля ESP-01. Для других модулей пины по умолчанию 4(SDA) и 5(SCL).

SPI

Библиотека SPI поддерживает весь Arduino SPI API, включая транзакции, в том числе фазу синхронизации (CPHA). Clock polarity (CPOL) пока не поддерживается (SPI_MODE2 и SPI_MODE3 не работают).

ESP8266 API

Поддержка функций, специфичных для ESP8266 (режим глубокого сна и сторожевой таймер), реализована в объекте ESP. Функция ESP.deepSleep(microseconds, mode) переводит модуль в режим глубокого сна. Параметр mode может принимать значения: WAKE_DEFAULT, WAKE_RFCAL, WAKE_NO_RFCAL, WAKE_RF_DISABLED. GPIO16 должен быть соединен с RESET для выхода из режима глубокого сна.

Функции ESP.wdtEnable(), ESP.wdtDisable(), и ESP.wdtFeed() управляют сторожевым таймером.

ESP.reset() перезагружает модуль

ESP.getFreeHeap() возвращает размер свободной памяти

ESP.getFreeHeap() возвращает размер свободной памяти

ESP. getChipId() возвращает ESP8266 chip IDE, int 32bit

ESP.getFlashChipId() возвращает flash chip ID, int 32bit

ESP.getFlashChipSize() возвращает размер флеш памяти в байтах, так, как его определяет SDK (может быть меньше реального размера).

ESP.getFlashChipSpeed(void) возвращает частоту флеш памяти, в Гц.

ESP.getCycleCount() возвращает количество циклов CPU с момента старта, unsigned 32-bit. Может быть полезна для точного тайминга очень коротких операций

Библиотека OneWire

Библиотека OneWire была адаптирована для ESP8266 (внесены изменения в OneWire.h) Если у вас установлена библиотека OneWire в папку Arduino/libraries, то будет использоваться именно она, а не из комплекта поставки.

mDNS библиотека ESP8266mDNS

Библиотека позволяет реализовать в вашей программе ответ на мультикастовые DNS запросы для локальной зоны, например «esp8266.local». В настоящее время поддерживается только одна зона. Позволяет обращаться к WEB серверу ESP8266 по имени, а не только по IP адресу. Дополнительную информацию вы можете найти в прилагаемом примере и в файле readme данной библиотеки.

Библиотека Servo

Библиотека позволяет управлять сервомоторами. Поддерживает до 24 сервоприводов на любых доступных GPIO. По умолчанию первые 12 сервоприводов будут использовать Timer0 и будут независимы от любых других процессов. Следующие 12 сервоприводов будут использовать Timer1 и будут разделять ресурсы с другими функциями, использующими Timer1. Большинство сервоприводов будут работать с управляющим сигналом ESP8266 3,3в, но не смогут работать на напряжении 3,3в и потребуют отдельный источник питания. Не забудьте соединить общий провод GND этого источника с GND ESP8266

Другие библиотеки, не включенные в поставку Arduino IDE

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

• arduinoWebSockets — WebSocket сервер и клиент для esp8266 (RFC6455)
• aREST REST API handler библиотека, позволяет управлять GPIO через http запросы вида http://192. 168.1.101/digital/6/1
• Blynk — легкий в освоении IoT фреймворк (страница на Kickstarter). Статья на нашем сайте об этой библиотеке и мобильном приложении ESP8266 – Управляем со смартфона через Blynk
• DallasTemperature DS18B20, DS1820, DS18S20, DS1822
• DHT11 — используйте для инициализации следующие параметры DHT dht(DHTPIN, DHTTYPE, 15)
• NeoPixelBus — Arduino NeoPixel библиотека для esp8266
• PubSubClient Библиотека MQTT by @Imroy. Статья на нашем сайте об этой библиотеке ESP8266 подключаемся к OpenWRT+Mosquitto+mqttwarn и передаем данные на ThingSpeak, EMAIL, Android, iOS, Twitter, CloudMQTT в 100 строчек кода в Arduino IDE
• RTC — библиотека for Ds1307 & Ds3231 для esp8266
• Souliss, Smart Home — фреймворк для Умного Дома, построенный на Arduino, Android и OpenHAB

Установка Arduino IDE через Boards Manager

1. Установите Arduino IDE с официального сайта Arduino.cc
2. Запустить Arduino IDE, далее Файл — Настройки — в поле Additional Boards Manager URLs вставить ссылку на стабильную версию http://arduino.esp8266.com/package_esp8266com_index.jsonили для nightly build http://arduino.esp8266.com/staging/package_esp8266com_index.json, нажать OK (В это поле вы можете вводить несколько ссылок, разделенных запятой)
3. Инструменты — Плата — Boards Manager
4. В Boards Manager в поле фильтра введите esp8266 или вручную пролистайте список и кликните на ESP8266 by ESP8266 Community Forum
5. Кликните Install и дождитесь окончания загрузки (около 130 Мегабайт). Если загрузка произошла слишком быстро, возможно, что вы уже устанавливали Arduino IDE для ESP8266 и потребуется почистить кэш Boards Manager, иначе у вас останется установленной старая версия. Нужно сначала деинсталлировать старую версию, а потом необходимо удалить файлы кэша. Для Win7 x64 удалите файлы из папки C:\Users\Пользователь\AppData\Roaming\Arduino15 и повторите все, начиная с п.2
6. Закройте Boards Manager и в меню Инструменты выберите Плата — Generic ESP8266
7. Установите частоту вашего модуля 80 или 160Mhz, размер флеш памяти и выберите последовательный порт, к которому подключен ваш USB-TTL адаптер

Схема подключения ESP8266

Оптимальное подключение ESP8266 для Arduino IDE

Оптимальное подключение ESP8266

Примечания.

1. Не на всех модулях выведены все пины. Перед приобретением модуля ознакомьтесь с видами модулей и их распиновкой.

2. Если на вашем USB-TTL конвертере выведены пины CTS и DSR — для автозагрузки прошивки они вам не помогут, т.к. работают только на вход.

3. Для стабильной работы ESP8266 требуется источник стабилизированного питания 3,3 вольт, ток более 250 миллиампер. Использование питания от USB-TTL конвертера может привести к нестабильности в работе.

Минимальное подключение ESP8266

Минимальное подключение ESP8266 (повышенная стабильность)

Более подробно, со всеми деталями, о подключении ESP8266 вы можете прочитать в нашей статье ESP8266 – подключение и обновление прошивки

Arduino IDE для ESP8266: быстрый старт

1. Подключить USB-TTL к USB

2. Подключить ESP8266 к USB-TTL как обычно. Если вы подключили ESP8266 по схеме без поддержки автозагрузки прошивки (не подключены DTR и RTS), то вручную соедините GPIO0 с землей, передерните питание модуля — все готово для  прошивки

3. Запускаем Arduino IDE

4. В меню Инструменты — Плата — Generic ESP8266 board (в самом низу)

5. В меню Инструменты выбираем порт, к которому подключен наш USB-TTL

6. В меню Инструменты — выбираете частоту, размер флеш памяти вашего модуля

7. В меню Файл — Примеры (Образцы) — ESP8266WiFi — WiFiWebServer

8. В скетче заполняете SSID и пароль вашей WiFi сети

9. Жмем кнопку компиляции и загрузки скетча

10. Ждем окончании процесса прошивки. После прошивки, если модуль подключен по схеме без поддержки автопрошивки, отсоедините GPIO0 от земли и передерните питание модуля без отключения USB-TTL от питания

11. В меню Инструменты — Монитор последовательного порта

12. Выбираем скорость 115200

13. Смотрим что происходит в терминале

14. Когда модуль подключится к сети, то появятся надписи в мониторе «WiFi connected» и «Server started»

15. Ниже будет IP адрес вашего модуля ESP8266, например 192.168.1.248

16. Открываете любой браузер, в строке адреса вбиваете «http://192.168.1.248/gpio/1»

17. Смотрите монитор последовательно порта и если к ESP8266 к GPIO2 у вас подключен светодиод (через резистор, разумеется), то он включится.

18. Profit!

Автором этого проекта адаптации Arduino IDE для ESP8266 является наш соотечественник из Санкт-Петербурга Иван Грохотков.

Скачать Arduino IDE для ESP8266 с github

Скачать Arduino IDE для ESP8266 с build сервера

Скачать исходный код Arduino IDE для ESP8266

Задать вопросы автору проекта Ивану Грохоткову aka igrr или сообщить об ошибке в Arduino IDE для ESP8266 можно в специальном разделе на нашем форуме.

Общение с Arduino по Bluetooth при помощи модуля HC-05

Ранее в заметке Мой первый радиоуправляемый робот на Arduino мы управляли гусеничным роботом при помощи пары устройств NRF24L01. Если помните, для этого приходилось использовать дополнительную Arduino с Joystick Shield. Притом вся эта конструкция получалась довольно громоздкой и неудобной, особенно если учитывать, что джойстику нужно от чего-то питаться, а также тот факт, что NRF24L01 для работы нужен дополнительный переходник со стабилизатором напряжения. Поэтому сегодня мы рассмотрим альтернативный подход, заключающийся в использовании Bluetooth-модуля HC-05.

Примечание: Существует похожий модуль HC-06. В отличие от HC-05, который может быть как ведущим (мастером), так и ведомым устройством, HC-06 может быть только ведомым. В остальном HC-05 и HC-06 практически не отличаются. Также существуют модули HC-07, HC-08 и HC-09. Прочитать про различия между ними можно здесь.

HC-05 имеет шесть пинов, но из них нам понадобится только четыре: VCC, GND, RX и TX. Кроме того, мы временно припаяем дополнительный провод к пину 34 непосредственно используемого в HC-05 Bluetooth-модуля EGBT-045MS, чтобы сменить имя, под которым будет видно устройство. Если вас устраивает имя по умолчанию, «HC-05», то можете ничего и не припаивать. Итак, VCC и GND пины подключаем к пинам 5V и GND Ардуины, TX пин HC-05 — к пину 2, а RX пин — к пину 3, и, наконец, пин 34 EGBT-045MS — к пину 4 Ардуины.

Получившаяся конструкция:

Ответ на вопрос где искать этот 34-ый пин у EGBT-045MS, содержится в EGBT-045MS / EGBT-046S Bluetooth Module Manual [PDF]:

Пример кода прошивки:

/* Connect HC-05 TX to Arduino RX and HC-05 RX to Arduino TX */
SoftwareSerial Bluetooth(2, 3); /* RX, TX */

const int pin34 = 4;
bool newline_printed = false;

void setup()
{  
  Serial.begin(9600);
  Serial.println(«Arduino is ready»);
 
  Bluetooth.begin(9600);  
  Serial.println(«Bluetooth is ready»);

  pinMode(pin34, OUTPUT);
  digitalWrite(pin34, HIGH);
  Bluetooth.println(«AT+NAME=ARDUINO-BLUETOOTH»);
  digitalWrite(pin34, LOW);
}

void loop()
{
  if(Bluetooth.available())
  {  
    char c = Bluetooth.read();
    if(c == ‘#’)
    {
      if(!newline_printed)
      {
        Serial.println(«»);
        newline_printed = true;
      }
    }
    else
    {
      Serial.print(c);
      newline_printed = false;
    }
  }
 
  if(Serial.available())
  {
    char c = Serial.read();
    Serial.write(c);
    Bluetooth.write(c);  
  }
}

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

Подавая высокое напряжение на 34-ый пин EGBT-045MS, мы переводим его в режим выполнения AT-команд. Полный список доступных команд можно найти в уже упомянутом EGBT-045MS / EGBT-046S Bluetooth Module Manual [PDF]. В приведенном примере просто меняется имя модуля. Сменив его один раз, лишний провод можно смело отпаивать, так как модуль запомнить свое новое имя в энергонезависимой памяти.

Можно найти великое множество готовых Android-приложений, подходящих для передачи команд модулю HC-05. Мне, к примеру, очень понравилось приложение Arduino BT Joystick. У него есть как платная, так и бесплатная версия с рекламой. Интерфейс приложения выглядит как-то так:

Жмем Connect, находим в списке наше устройство, вводим пин 1234, и можно отправлять команды при помощи кнопок, а также встроенного в телефон акселерометра. Другими словами, приложение позволяет, помимо прочего, управлять Arduino, просто вращая телефон в руках.

Важно! Насколько я смог выяснить, устройства от Apple вообще не работают с HC-05 / HC-06. Для решения этой проблемы предлагается использовать BLE модули, например HM-10 или HM-11. Судя по видео на YouTube, HC-08 тоже подойдет. Опыта использования данных модулей на момент написания этих строк у меня, к сожалению, нет. В России их довольно сложно достать, видел только в одном интернет-магазине. А так нужно ждать доставки из Китая.

Разные приложения посылают данные в разных форматах. В случае Arduino BT Joystick используется формат вроде:

… где ## — это разделитель, b= указывает на то, что далее содержится код кнопки, 0, 1 и так далее — это коды кнопок. Учтите, что если пользователь ничего не нажимает, то приложение непрерывно шлет ##b=0##b=0##.... Если в приложении вы разрешили использование акселерометра, то помимо значений b также будут передаваться значения x, y и z.

Преимущество использования Bluetooth заключается в том, что не нужно делать отдельный джойстик. Подойдет любой смартфон или планшет под управлением Android. Кроме того, EGBT-045MS производит впечатление модуля, который легко выпаять из HC-05 и затем использовать в самодельный платах.

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

Метки: AVR, Беспроводная связь, Электроника.

— ссылка на Arduino

Описание

Используется для связи между платой Arduino и компьютером или другими устройствами. Все платы Arduino имеют как минимум один последовательный порт (также известный как UART или USART), а некоторые — несколько.

На Uno, Nano, Mini и Mega контакты 0 и 1 используются для связи с компьютером.Подключение чего-либо к этим контактам может помешать этой связи, в том числе вызвать сбои при загрузке на плату.

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

Последовательная связь на контактах TX / RX использует логические уровни TTL (5 В или 3,3 В в зависимости от платы). Не подключайте эти контакты напрямую к последовательному порту RS232; они работают при +/- 12 В и могут повредить вашу плату Arduino.

Чтобы использовать эти дополнительные последовательные порты для связи с вашим персональным компьютером, вам понадобится дополнительный адаптер USB-to-serial, так как они не подключены к адаптеру Mega USB-to-serial. Чтобы использовать их для связи с внешним устройством с последовательным интерфейсом TTL, подключите контакт TX к контакту RX вашего устройства, RX — к контакту TX вашего устройства, а заземление Mega — к земле вашего устройства.

с использованием Serial.read () с Arduino | Академия Электроники Программирования

Вы пытаетесь использовать последовательный порт.read (), чтобы получить данные с последовательного порта на ваш Arduino? Возможно, вы используете окно Arduino Serial Monitor и отправляете данные, или, может быть, у вас есть программа, запущенная на вашем raspberryPi, отправляющая данные через последовательный порт на вашу плату Arduino.

Как использовать serial.read () для получения данных и их правильного объединения? В этом уроке вы точно узнаете, как использовать Serial.read () для получения данных из последовательного порта и объединения их в одно значение.

Часть 1:

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

Часть 2:

• Реализуйте стратегию в коде Arduino
• БОНУС: Как преобразовать последовательные данные из строки в целое число

Вы пытаетесь использовать Serial.read для получения данных с последовательного порта на ваш Arduino? Возможно, вы используете окно последовательного монитора Arduino и отправка данных, или, может быть, у вас есть программа, запущенная на вашем Raspberry Pi это отправляет данные через последовательный порт на вашу плату Arduino.Как вы используете Serial.read для получения данных и правильно собрать? На этом уроке вы точно узнаете как использовать Serial.read для получения данных из последовательного порта и сшиваем как одно значение. Следите за обновлениями. (живой телевизионный джингл)
Подпишитесь на наш канал на YouTube чтобы получить больше подобных видео. Хорошо, давайте сделаем краткий обзор о чем мы собираемся здесь поговорить. Сначала мы поговорим о большой картине последовательной связи.Поговорим о последовательном буфере. Поговорим о Serial.read и Serial.available. Разработаем протокол и стратегию для чтения данных из последовательного порта. Затем мы реализуем стратегию в коде Arduino. В качестве бонуса вы узнаете, как конвертировать последовательные данные. от строки до целого числа. Сделаем шаг назад от Serial.read и поговорим о последовательной связи. Последовательная связь — это процесс отправки одного бита данных за раз последовательно из одного места в другое, например, отправка данных с вашего Raspberry Pi к подключенному Arduino или наоборот.USB — один из наиболее распространенных используемых методов для последовательной связи. Отсюда и название Универсальная последовательная шина. Используя Arduino, мы можем легко отправлять и получать данные через USB-кабель. Все, что нам нужно сделать, это использовать встроенный Последовательная библиотека Arduino. Теперь, если вы не знаете, что такое библиотека Arduino, это в основном связка кода, который был объединен вместе потому что его часто используют вместе. Допустим, вы парикмахер. Может быть, у вас в парикмахерской есть особый ящик для всех ваших инструментов для стрижки.Каждый раз, когда кто-то заходит на стрижку, Вы точно знаете, где искать в этом ящике для стрижки. Вот куда вы кладете все свои инструменты для стрижки. Может быть, у вас есть еще один ящик со всем необходимым для окрашивания волос людей. Когда кто-то входит и просит покрасить волосы в красный цвет, вы точно знаете, какой ящик открыть. То же самое и с библиотеками Arduino. Библиотеки Arduino объединяют множество программных функций которые помогут вам с конкретными задачами.Для последовательной связи мы можем использовать встроенную последовательную библиотеку Arduino. В последовательной библиотеке есть такие функции, как начало серийного номера, чтение, доступность, parseInt, parseString, parseFloat, печать, так далее и так далее. Их много, и они очень удобны. Хорошо, быстрое резюме. Мы знаем, что последовательная связь через USB как мы можем общаться между нашим Arduino и другим устройством. И мы знаем, что последовательная библиотека Arduino это набор программных инструментов, которые мы собираемся использовать для последовательной связи.Но где, черт возьми, данные что мы получаем с другого устройства на самом деле в конечном итоге на Ардуино? Куда все это девается? Ответ — последовательный буфер, или, возможно, более точно, буфер последовательного приема. Когда биты данных начинают поступать с вашего компьютера, часть оборудования на вашем Arduino, называемая UART соберет каждый из восьми битов в байт и сохраните эти байты в последовательном приемном буфере. Буфер последовательного приема может содержать 64 байта.Данные, которые вы отправляете со своего компьютера на Arduino. попадет в буфер последовательного приема. Так как же получить эти данные? Вот где на помощь приходит Serial.read. Serial.read — это функция последовательной библиотеки Arduino. и что он делает, это считывает первый доступный байт из последовательного приемного буфера. Когда он его считывает, он удаляет этот байт из буфера. Допустим, вы отправили фразу SubSandwich на свой Arduino. Это означает, что вы поместите 12 байтов в буфер последовательного приема.Итак, у нас есть строка кода и сохраняем в переменную myFirstCharacter возвращаемое значение Serial.read. Serial.read, он вернет первое значение доступны в последовательном приемном буфере, которая в данном случае является заглавной S, и он оставит ubSandwich в последовательном приемном буфере. В смысле, убСэндвич? В смысле, это могло быть вкусно. Теперь персонаж, заглавная буква S, будет храниться в переменной myFirstCharacter и останется всего 11 байт в буфере последовательного приема.Если мы сделаем это снова, теперь сохраняем символ в mySecondCharacter, тогда mySecondCharacter будет содержать значение строчные буквы u и bSandwich будут оставлены в буфере последовательного приема. Итак, Serial.read занимает по одному байту за раз из последовательного приемного буфера. Теперь здесь есть небольшая проблема что ты собираешься высматривать. Часто, когда вы отправляете данные по последовательному каналу, будет невидимый завершающий символ добавлено в конце передачи.Эти завершающие символы помогают вашей программе знать когда передача закончится. Так что это может быть что-то вроде возврата каретки или перевод строки, который добавит дополнительный байт в буфер последовательного приема, или даже оба могут быть добавлены что добавит в буфер два дополнительных байта. Просто то, на что стоит обратить внимание. Если вы отправляете данные через окно последовательного монитора в Arduino IDE в правом нижнем углу вы увидите варианты добавления этих завершающих символов каждый раз, когда вы нажимаете кнопку отправки.Если вы выберете вариант без окончания строки, будут отправлены только ваши символы. Итак, мы знаем, что данные поступают по последовательному каналу идет в буфер последовательного приема, и мы знаем, что можем использовать Serial.read чтобы получить первый символ в этом буфере. Но как мы узнаем, есть ли что-нибудь в буфер последовательного приема в первую очередь? Ну так уж получилось есть еще одна функция в последовательной библиотеке Arduino под названием Serial.available. Мы можем использовать доступную функцию чтобы проверить, сколько байтов доступно для чтения в буфере последовательного приема.Serial.available вернет количество байтов в настоящее время хранится в последовательном приемном буфере. Скажем, фраза SubSandwich была в последовательном приемном буфере, тогда Serial.available вернет число 12. Если и который был в последовательном приемном буфере, тогда Serial.available вернет значение 7. Что круто, так это то, что Serial.available не влияет на содержимое буфера последовательного приема. Он просто сообщает нам, насколько он заполнен.Итак, если возвращаемое значение Serial.available больше нуля, тогда мы знаем часть нашего сообщения или, может быть, все наше сообщение все еще сидит в последовательном приемном буфере, ожидающем чтения. Хорошо, вся эта справочная информация великолепна. Речь идет о Serial.read, Serial.available, но кажется, что это просто втягивает по одному байту за раз. Что, если вы хотите отправить целую фразу, например SubSandwich к вашему Arduino и сохранить его в строку? Или произнесите числовое значение 462 и сохраните его в виде целого числа? Как собрать все эти байты вместе? в одну строковую переменную или одну целочисленную переменную или что там еще? Хорошо, давай закатим рукава и придумайте стратегию.Итак, здесь есть немного технических деталей. Я думаю, это будет взрыв. Теперь, если вы новичок в программе Arduino и ты хочешь научиться делать такие вещи, посетите Академию электроники программирования. В программе членства есть видеокурсы. что шаг за шагом шаг за шагом научить вас программировать Arduino чтобы вы могли прототипировать свои собственные проекты и напишите свой собственный код. Хорошо, вернемся к стратегии. Во-первых, нам нужно решить, как мы собираемся отправлять наши данные, который я буду называть нашими сообщениями.То есть нам нужно определиться с протоколом, которому мы будем следовать. Сделаем эти правила протокола что мы будем применять в нашей программе Arduino. Итак, первый, новые сообщения будут прочитаны, как только они появятся. Сообщения не будут длиннее 12 байт. Каждое сообщение заканчивается новым строковым символом. Это будет наш завершающий персонаж. Хорошо, это довольно простой протокол, но на самом деле это не стратегия. Итак, давайте немного подумаем о стратегии.Во-первых, нам нужно место, где мы можем хранить входящие байты которые мы читаем из последовательного буфера приема. Для этого мы могли бы использовать массив символов. Затем нам нужно проверить, доступно ли что-нибудь в буфере последовательного приема. Для этого мы могли бы использовать Serial.available. Тогда нам действительно нужно прочитать байт. Для этого мы могли бы использовать Serial.read. Прежде чем мы поместим какой-либо из байтов в наш массив, нам нужно проверить, что входящий байт не является завершающим символом, который бы сказал нам, что мы подошли к концу сообщения.Итак, давайте возьмем эти идеи и вроде напишу алгоритм. Сначала мы создаем массив символов для хранения входящих байтов. Во-вторых, мы проверяем, есть ли что-нибудь в буфере последовательного приема для чтения. В-третьих, пока есть что почитать, тогда что мы делаем в первую очередь, прочитать байт во временную переменную, проверьте, является ли то, что мы читаем, частью нашего сообщения или если это завершающий символ. Если это часть нашего сообщения, затем мы сохраним его в массив символов.Если это завершающий символ, тогда мы можем вывести сообщение и готовьтесь к следующему сообщению. Если сообщение превышает максимальную длину в протоколе, тогда нам нужно перестать читать больше байтов и вывести сообщение, или делаем с сообщением все, что захотим. Итак, теперь у нас есть стратегия чтения сообщения из последовательного приемного буфера. Во второй части мы реализуем все это в коде. Я с нетерпением жду встречи с вами.До свидания. (яркие электронные тона)

Вы пытаетесь использовать Serial.read () для получения данных с последовательного порта на ваш Arduino? Возможно, вы используете окно последовательного монитора Arduino и отправка данных или, может быть, у вас есть программа работает на вашем Raspberry Pi которые отправляют данные через последовательный порт на вашу плату Arduino. Как вы используете Serial.read () для получения данных и правильно собрать? Этот урок является продолжением первой части.В этом уроке вы изучите код для использования Serial.read (). получать данные из последовательного порта и сшивать их вместе как одно значение. Следите за обновлениями. (яркая веселая музыка)
Подпишитесь на наш канал на YouTube чтобы получить больше подобных видео. Хорошо, теперь я надеюсь, что у тебя все отлично. Опять же, это вторая часть использования Serial.reads (). Итак, если вы еще не видели первую часть ты действительно хочешь это посмотреть. В первой части мы говорили о большой картине последовательной связи.Мы говорили о буфере последовательного приема, Serial.read () и Serial.available (). Затем мы разработали протокол и стратегию для чтения данных из последовательного порта. В этом уроке мы собираемся реализовать эта стратегия в коде Arduino. И в качестве бонуса вы узнаете, как преобразовать последовательные данные от строки до целого числа. Хорошо, приступим. Итак, у меня открыта среда разработки Arduino и я только что написал список из двух взносов в своей программе.И это, по сути, алгоритм, о котором мы говорили об этом в прошлом уроке. Я просто расскажу о том, что нам нужно сделать. Итак, мы хотим создать массив символов для хранения входящих байтов. Мы хотим проверить, есть ли что-нибудь в полученном последовательном буфере для чтения. Пока есть что почитать затем мы хотим прочитать байт во временную переменную. Мы хотим проверить, является ли то, что мы читаем, частью нашего сообщения, или если это завершающий символ.Если это часть нашего сообщения, то мы его сохраним в массив символов. Если это завершающий символ, мы можем вывести сообщение или сделайте что-нибудь с ним и подготовьте для следующего сообщения. Если сообщение превышает максимальную длину в протоколе тогда нам нужно перестать читать больше байтов и просто выведите сообщение или сделайте с ним что-нибудь. Теперь мы собираемся перейти к некоторым действительно техническим вещам. Я думаю, это будет взрыв.Если вам интересно научиться программировать и создавать электронные прототипы, я определенно рекомендую посетить Академию электроники программирования. У нас есть подробные краткие видео-тренинги, которые помогут вам через все это, чтобы вы могли выйти и начните строить свои собственные проекты. Хорошо, теперь об этом. Итак, давайте продолжим и начнем с минимальной программой Arduino с настройкой и циклом. Мы также добавим Serial.начинать к настройке, чтобы установить последовательную связь.
Обратите внимание, что в Serial.begin мы передаем значение 9600. Это называется скоростью передачи. Устанавливает скорость последовательной связи и представляет собой байты в секунду. Таким образом, это будет 9600 байт в секунду. идет между двумя устройствами. Теперь на обоих устройствах должна быть выбрана одинаковая скорость передачи данных. для работы последовательной связи. Если вы используете последовательный монитор Arduino IDE окно для отправки данных затем скорость передачи данных можно установить с помощью раскрывающегося меню.И есть несколько распространенных скоростей передачи, которые вы можете использовать но сейчас мы не будем вдаваться в подробности. Вам просто нужно убедиться, что отправка и принимающие устройства имеют одинаковую скорость передачи данных. Итак, у нас есть базовая программа. Теперь приступим к первому шагу нашего алгоритма. Нам нужно создать массив символов для хранения входящих сообщение и переменная позиции, чтобы помочь нам двигаться через каждый элемент в массиве.Мы также создадим константу для хранения максимальной длины нашего сообщения и использовать его для инициализации наш массив символов. Хорошо, позволь мне сделать это. (мягкая музыка)
Хорошо, мы добавили постоянное целое число без знака. Мы назвали его MAX_MESSAGE_LENGTH, и я установил его равным 12. Это произвольная длина. Это то, что вы выберете. Затем мы создали массив символов с именем message. В массиве есть тип данных, который может содержать несколько элементов.Массивы могут содержать только один тип элементов. Итак, мы делаем массив символов. Это будет содержать персонажей. Итак, каждый из персонажей, которые мы читаем, из последовательного полученного буфера будет идти в этот массив символов. Наконец, у нас есть переменная позиции сообщения. Эта переменная позволит нам выбрать, где в массив для размещения входящих байтов. Хорошо, так что мы сделали это, я пойду и отмечу это из списка дел здесь.Теперь нам нужно проверить, чтобы увидеть если какие-либо байты доступны в последовательном полученном буфере. И пока там есть байты, нам нужно прочитать байты in и сохраните их во временную переменную. Мы можем использовать цикл while Serial.available () и серийное чтение, чтобы это произошло. (мягкая музыка)
Хорошо, теперь у нас есть цикл while, и условие в цикле while проверяет возвращаемое значение Serial.available (). Итак, если вы вспомните из предыдущего урока Серийный.available () возвращает число байтов, доступных для чтения в последовательном полученном буфере. Итак, если в буфере последовательного приема есть какие-либо данные, это значение, это возвращаемое значение будет больше нуля. Итак, мы говорим, что пока есть данные внутри последовательного полученного буфера этот код будет повторяться снова и снова. А затем, что мы будем делать внутри этого цикла while считывает эти байты по одному, используя функция Serial.read (), и мы сохраняем каждый этих байтов во временную переменную под названием invit.Хорошо, мы сделали это. Я собираюсь вычеркнуть это из нашего списка. Проверьте, есть ли что-нибудь в буфере последовательного приема. Мы делаем это с помощью Serial.available. А потом пока есть что почитать, мы читаем байт во временную переменную. Так что мы просто это сделали. Итак, теперь нам нужно проверить, есть ли то, что мы читаем является частью нашего сообщения или завершающим символом. Для этого мы могли бы использовать оператор if else.Если это не завершающий символ, сделает одно и если это завершающий символ сделаю что-нибудь еще. Так что давай сделаем это. (мягкая веселая музыка)
Хорошо, теперь у нас есть оператор if L. Итак, что мы пытаемся достичь здесь, мы хотим убедиться что мы не дошли до конца нашего сообщения. Если мы читаем сообщение, а есть другое сообщение после этого мы не хотим просто начать читать в другое сообщение.Нам нужно знать, где заканчивается первое сообщение. Вот почему у нас есть эти завершающие символы. Итак, что мы делаем, мы читаем в этом персонаже и нам нужно проверить, эй, это часть нашего сообщения или это завершающий символ и сообщает нам, что это конец сообщения. Итак, что мы делаем, мы проверяем, не новая ли это строка. Итак, эта мелочь — новая линия, а мы говорим не новая линия. Итак, мы проверяем, Эй, это только что полученный байт? Мы хотим убедиться, что это не новая строка.Если это не новая строка, значит, это часть нашего сообщения. и мы что-нибудь сделаем. Если это новая строка, то что это значит это то, что мы получили полное сообщение а потом мы захотим заняться чем-нибудь еще. Хорошо, мы делаем нашу проверку для завершающего символа. Давайте выберем это из нашего списка здесь. Хорошо, дела идут. Хорошо, если это часть нашего сообщения затем мы хотим сохранить его в массив символов.И тогда нам также нужно будет увеличить нашу позицию в массиве символов для следующего байта. Так что давай сделаем это. (мягкая музыка)
Хорошо. Итак, что мы делаем, у нас есть массив символов. Опять же, это будет то место, где мы храним входящие байты. Значение, заключенное в эти скобки сообщает нам, где мы ссылаемся. Итак, эта позиция сообщения прямо сейчас установлена ​​на ноль. Это то, что мы инициализировали, это ноль.Итак, что это значит в первой позиции этого символьного массива мы вставим в байт. Итак, если бы у нас было сообщение, если бы мы просто отправили сообщение например, sub, тогда буква S будет, вы знаете, что такое инвайт. И буква S будет первой в этом массиве. И это потому, что массивы имеют нулевой индекс. Теперь, если все это звучит для вас как греческое, снова посетите Академию электроники программирования. Мы говорим обо всем этом. Я знаю, ты можешь чувствовать себя мужчиной вы так много замалчиваете.Что ж, есть чему поучиться, но это определенно выполнимо. В общем, ладно, я отвлекся. Хорошо, поэтому мы сохраняем эту входящую переменную в наш массив. Затем мы увеличиваем наша переменная позиции. Итак, мы говорим «позиция сообщения плюс», «плюс». Мы добавляем единицу к этой переменной. Так что раньше, когда мы начинали, было нулевое значение. После этой строки кода он будет одним. Так что это значит, что в следующий раз здесь когда мы вытаскиваем следующий байт из буфера мы сохраним его в следующей позиции.Итак, вы можете видеть, что мы как бы перекомпоновываем сообщение. Мы берем его из последовательного полученного буфера и мы снова собираем его в наш массив символов. Хорошо, позвольте мне вычеркнуть это из нашего списка здесь. Мы взяли часть сообщения и затем сохранили его. в массив символов. Теперь, если мы получим завершающий символ это означает, что мы получили все наше сообщение и мы действительно можем что-то сделать с сообщением. Как и данные, которые мы получаем, мы можем делать все, что захотим.В этом случае мы напечатаем сообщение в окно монитора последовательного порта. И что мы также сделаем, так это сбросим персонажа массив, чтобы подготовить его к следующему сообщению. Так что давай сделаем это. (мягкая музыка)
Хорошо, когда мы получили полное сообщение, у нас есть завершающий нулевой символ и что мы собираемся сделать, так это добавить нулевой символ до конца строки. Мы напечатаем сообщение. А затем мы сбросим переменную позиции до нуля, чтобы подготовиться к следующему полученному сообщению.Итак, мы начнем с самого начала нашего массива символов, нашего массива символов сообщения. Хорошо, так что мы можем вычеркнуть это из списка но прежде чем мы сможем назвать это завершенным, мы все еще необходимо обеспечить максимальную длину сообщения, о котором мы говорили о в протоколе. Что это сделает, это помешает нам от превышения фактически выделенного пространства в нашем массиве символов. Итак, я думаю, что мы сделаем, это добавим этого охранника к нашему существующему оператору if.Так позволь мне сделать это.
Итак, мы добавили дополнительное условие внутри нашего оператора if. Итак, сначала мы хотим убедиться, эй это не завершающий символ. А теперь мы также хотим проверить, не превысили ли длина сообщения, о котором мы договорились в протоколе, которое было 12. Итак, если наша позиция больше чем наша максимальная длина сообщения минус один, это учитывает за то, что массив имеет нулевой индекс, и это улавливает и скажите: «Эй, погоди, сообщение слишком велико».Нам нужно перейти к этому, если а точнее это еще заявление. И вместо этого выведите сообщение. Хорошо, вот и все. Хорошо, я знаю, что это похоже на тонну. Это вроде как, но прежде, чем мы назовем это, уходит Я хочу показать вам способ принять сообщение, которое мы получили и преобразовать его в целое число. Так что, если вместо того, чтобы посылать слова как суб-бутерброд или буквы или что-то еще к последовательному порту, возможно, вы отправляете числовые значения как будто вы отправляете номер 42 или номер 314 внутри окна монитора последовательного порта или через ваше устройство, и они будут отправлены как символы ASCII.Как преобразовать эти цифры в целые числа? Что ж, есть классная функция под названием atoi (). И это займет строку с завершением Knoll и преобразовать его в целое число. Итак, строки на языке программирования C заканчиваются нулем. То есть они заканчиваются символом обратной косой черты ноль. Функция atoi () не будет работать, если символ где вы проходите, имеет завершающий символ null. Итак, давайте посмотрим, как мы могли бы добавить эту функцию atoi () к нашему текущему коду.
Теперь, что делает код помимо печати сообщения. он будет использовать функцию atoi () чтобы преобразовать этот массив символов в целое число. А потом мы просто выведем это целое число. Но вы знаете, вы можете делать с ним все, что хотите. Хорошо, ну, это было много всего. Итак, давайте сделаем небольшой обзор. Во-первых, мы говорили в основном о последовательной связи. Это средство отправки данных по одному бит за раз из одного места в другое.Мы говорили о буфере последовательного приема, и мы сказали что он содержит 64 байта. Мы обсудили основы Serial.read и Serial.available (), и мы знаем, что Serial.read удаляет по одному байту из последовательного буфера. Мы узнали, что функция serial available возвращает сколько байтов находится в последовательном полученном буфере. Мы разработали простой протокол и стратегию для получения сообщений с нашего последовательного порта а затем мы реализовали стратегию в коде Arduino.Наконец, мы поговорили об использовании функции atoi () для преобразования строки с завершающим нулем в целое число. Что ж, эй, надеюсь, тебе это действительно пригодится. Если тебе это нравится, тебе действительно понравится следующий урок где мы будем говорить о том, как вы можете взять весь код, который у нас был здесь, и мы собираемся сжать это всего за пару строк кода используя некоторые другие действительно удобные функции последовательной библиотеки. Успокойся, и тогда увидимся.До свидания. (мягкая музыка)

Общая картина последовательной связи

Давайте сделаем шаг назад от Serial.read () и поговорим о последовательной связи.

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

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

Теперь, если вы не знаете, что такое библиотека Arduino, это, по сути, набор кода, который был объединен вместе, потому что он часто используется вместе.

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

Может быть, у вас есть еще один ящик со всем необходимым для окрашивания волос людей. Когда кто-то входит и просит покрасить волосы в красный цвет, вы точно знаете, какой ящик открыть. То же самое и с библиотеками Arduino. Библиотеки Arduino объединяют набор программных функций, которые помогут вам с конкретными задачами.

Функции последовательной библиотеки

Для последовательной связи мы можем использовать встроенную последовательную библиотеку Arduino.

Последовательная библиотека имеет такие функции, как:

• Серийный.begin ()
• Последовательное чтение ()
• Последовательный. Доступный ()
• Serial.parseInt ()
• Serial.parseString ()
• Serial.parseFloat ()
• Серийный отпечаток ()
• Serial.captCrunch ()

Хорошо, мы знаем, что последовательная связь через USB — это то, как мы можем общаться между одним устройством и другим, и мы знаем, что последовательная библиотека Arduino — это набор инструментов, которые мы будем использовать для последовательной связи. Но куда на самом деле попадают данные, поступающие с другого устройства, на Arduino?

Последовательный буфер

Ответ — последовательный буфер, или, точнее, последовательный приемный буфер.Когда биты данных начинают передаваться с вашего компьютера, часть оборудования на вашем Arduino, называемая UART, соберет каждый из 8 битов в байт и сохранит эти байты для вас в последовательном буфере приема.

Буфер последовательного приема может содержать 64 байта.

Данные, которые вы отправляете со своего компьютера на Arduino, попадают в буфер последовательного приема.

Как получить эти данные? Вот где на помощь приходит Serial.read ().

Последовательное чтение ()

Серийный.read () — это функция библиотеки Serial. Он считывает первый доступный байт из последовательного приемного буфера. Когда он его считывает, он удаляет этот байт из буфера.

Допустим, вы отправили фразу «Sub Sandwich» на свой Arduino. Это означает, что вы поместили 12 байтов в буфер последовательного приема.

Если вы используете…

 char myFirstCharacter =  Serial  .read ();

 

Затем Serial.read () вернет первое значение, доступное в последовательном приемном буфере, которым в данном случае является «S», и оставит «ub Sandwich» в последовательном приемном буфере.Теперь значение «S» будет сохранено в переменной myFirstCharacter, а в последовательном буфере останется только 11 байтов….

Если мы сделаем это снова…

 char mySecondCharacter =  Серийный  .read ();

 

Тогда mySecondCharacter будет содержать значение «u», а «b Sandwich» останется в буфере последовательного приема. Serial.read () принимает по одному байту из последовательного приемного буфера.

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

Это может быть CR (возврат каретки) или LF (перевод строки), которые добавят дополнительный байт в буфер последовательного приема, или даже оба могут быть добавлены CR + LF, которые добавят два дополнительных байта в буфер!

Если вы отправляете данные через окно монитора последовательного порта, в правом нижнем углу вы увидите варианты добавления этих завершающих символов при каждом нажатии кнопки отправки.При выборе варианта «Без окончания строки» будут отправлены только ваши символы.

Serial.available () — серийный шпион

Мы можем использовать другую библиотечную функцию Serial, Serial.available (), чтобы проверить, есть ли что-нибудь доступное для чтения в последовательном приемном буфере.

Serial.available вернет количество байтов, хранящихся в текущий момент в последовательном приемном буфере. Скажем, фраза «Sub Sandwich» была в последовательном приемном буфере, тогда serial.available () вернет число 12. Если «andwich» было в последовательном приемном буфере, то serial.available () вернет значение 7.

Serial.available не влияет на содержимое приемного буфера последовательного порта — он просто сообщает нам, насколько он заполнен.

Итак, ЕСЛИ возвращаемое значение Serial.available () больше 0, мы знаем, что часть нашего сообщения все еще находится в последовательном приемном буфере.

Хорошо, все эти Serial.read и Serial.available — это здорово, но что, если я хочу отправить всю фразу «sub sandwich» на свой Arduino и сохранить ее в строке, или произнести значение 462 и сохранить его в целое число.

Как мне собрать все эти байты вместе в одну строковую переменную, или целое число, или любой другой тип данных, если на то пошло ?!

Как отправлять целые числа, строки и т. Д. Через последовательный порт

Хорошо, давай засучим рукава и придумаем стратегию…

Здесь будет немного технических деталей — я думаю, это будет взрыв!

Теперь Если вы новичок в программировании на Arduino и хотите научиться делать такие вещи, обязательно ознакомьтесь с членством в Programming Electronics Academy.У нас есть видеокурсы, в которых вы шаг за шагом узнаете, как программировать Arduino, чтобы вы могли создавать прототипы своих собственных проектов.

Хорошо, вернемся к нашей стратегии…

Во-первых, нам нужно решить, как мы собираемся отправлять наши данные (которые я буду называть «сообщениями»), то есть нам нужно выбрать протокол, которому мы будем следовать.

Наш протокол Serial.read ()

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

• Новые сообщения будут прочитаны сразу после их поступления
• Сообщения не должны быть длиннее 12 байтов
• Каждое сообщение заканчивается символом новой строки «\ n», который мы будем называть завершающим символом

Это довольно простой протокол, но он поможет нам в нашей стратегии.

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

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

1. Создать массив символов для хранения входящих байтов
2. Проверьте, есть ли что-нибудь в последовательном приемном буфере для чтения — Последовательный.в наличии ()
3. Пока есть что почитать тогда …
   • Чтение байта во временную переменную — Serial.read ()
   • Проверяем, является ли то, что мы читаем, частью нашего сообщения ИЛИ завершающим символом
   • Если это часть нашего сообщения, то сохраните его в массив символов
   • Если это завершающий символ, выведите сообщение и подготовьтесь к следующему сообщению
   • Если сообщение превысило максимальную длину сообщения в протоколе, прекратите чтение дополнительных байтов и выведите сообщение (или сделайте с ним что-нибудь еще)

Bare Minimum Arduino Sketch

Давайте начнем с минимальной программы Arduino с setup () и loop ().Мы добавим Serial.begin () в цикл, чтобы установить последовательную связь.

Обратите внимание, что в Serial.begin () мы передаем значение 9600. Это называется скоростью передачи — она ​​устанавливает скорость последовательной связи и представляет биты в секунду. Для работы последовательной связи оба устройства должны иметь одинаковую скорость передачи в бодах. Если вы используете окно Arduino IDE Serial Monitor для отправки данных, скорость передачи данных можно установить с помощью раскрывающегося меню.

 void setup () {
  Серийный .begin (9600);
}

void loop () {

}
 

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

 const unsigned int MAX_MESSAGE_LENGTH = 12;

void setup () {
 Серийный . Начало (9600);
}

void loop () {
// Создаем место для хранения входящего сообщения
сообщение статического символа [MAX_MESSAGE_LENGTH];
статический беззнаковый int message_pos = 0;
}

 

Теперь нам нужно проверить, доступны ли какие-либо байты в последовательном приемном буфере, и пока они есть, нам нужно прочитать байты и сохранить их во временную переменную.Мы можем использовать цикл while, Serial.available, Serial.read (), чтобы это произошло.

 const unsigned int MAX_MESSAGE_LENGTH = 12;

void setup () {
 Серийный . Начало (9600);
}

void loop () {

// Проверяем, доступно ли что-нибудь в последовательном приемном буфере
while ( Serial  .available ()> 0)
{
// Создаем место для хранения входящего сообщения
сообщение статического символа [MAX_MESSAGE_LENGTH];
статический беззнаковый int message_pos = 0;

// Считываем следующий доступный байт в последовательном приемном буфере
char inByte =  Serial .читать();
}
}

 

Теперь нам нужно проверить, является ли прочитанный байт завершающим символом или нет… Для этого мы можем использовать оператор if-else. Если это не завершающий символ, мы сделаем одно, а если это завершающий символ, мы сделаем что-нибудь другое.

 // Приходит сообщение (проверьте не завершающий символ)
если (inByte! = '\ n')
{
//Сделай что-нибудь
}
// Получено полное сообщение ...
еще
{
// Сделаем что-нибудь еще
}
 

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

 // Приходит сообщение (проверьте не завершающий символ)
если (inByte! = '\ n')
{
// Добавляем входящий байт в наше сообщение
сообщение [message_pos] = inByte;
message_pos ++;
}
// Получено полное сообщение ...
еще
{
//Сделай что-нибудь
}

 

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

 // Получено полное сообщение ...
еще
{
// Добавляем нулевой символ в строку
сообщение [message_pos] = '\ 0';

// Распечатать сообщение (или сделать что-то другое)
 Serial  .println (сообщение);

// Сброс для следующего сообщения
message_pos = 0;
}

 

Прежде чем мы сможем назвать это завершенным, нам нужно установить максимальную длину сообщения в протоколе.Это не позволит нам превысить пространство, которое мы выделили в нашем массиве символов. Мы можем добавить эту защиту к нашему существующему оператору if.

 если (inByte! = '\ N' && (message_pos 
 Full Serial.read () Код 
 Вот полный код для использования Serial.read () для чтения всего сообщения:
 // Большое спасибо Нику Гаммону за основу этого кода
//http://www.gammon.com.au/serial 
 const unsigned int MAX_MESSAGE_LENGTH = 12;

void setup () {
 Серийный .begin (9600);
}

void loop () {

// Проверяем, доступно ли что-нибудь в последовательном приемном буфере
while ( Serial  .available ()> 0)
{
// Создаем место для хранения входящего сообщения
сообщение статического символа [MAX_MESSAGE_LENGTH];
статический беззнаковый int message_pos = 0;

// Считываем следующий доступный байт в последовательном приемном буфере
char inByte =  Serial  .read ();

// Поступает сообщение (проверьте, не заканчивается ли символ) и следите за превышением размера сообщения
если (inByte! = '\ n' && (message_pos  Serial  .println (сообщение);

// Сброс для следующего сообщения
message_pos = 0;
}
}
}

 
 ОК. Это похоже на тонну - я знаю!
 Но прежде чем мы завершим его, я хочу показать вам способ вернуть эту строку c в целое число.
 Как преобразовать символ в Int с помощью Arduino 
 Что делать, если вместо отправки слов или букв через последовательный порт, возможно, вы отправляете числовые значения, например 42 или 314.Как преобразовать эти цифры в целые числа?
 Ну, есть классная функция под названием atoi () - она ​​берет строку с завершающим нулем и преобразует ее в целое число.
 Строки в языке программирования c заканчиваются нулем - они заканчиваются символом «\ 0». Функция atoi () не будет работать, если строка, которую вы передаете, не имеет завершающего нуля символа!
 Итак, в нашем текущем коде все, что нам нужно сделать, это добавить что-то вроде этого:
 еще
{
// Добавляем нулевой символ в строку
сообщение [message_pos] = '\ 0';

// Распечатать сообщение (или сделать что-то другое)
 Серийный .println (сообщение);

// Или преобразовать в целое число и распечатать
int number = atoi (сообщение);
 Серийный  .println (номер);

// Сброс для следующего сообщения
message_pos = 0;
}

 
 Вот и все, теперь последовательное сообщение преобразовано из строки c в целое число!
 Обзор урока Serial.read () 
 Давайте сделаем быстрый обзор.
 Во-первых, мы в основном говорили о последовательной связи - это средство передачи данных ______________.Мы говорили о буфере последовательного приема - вы помните, сколько байтов он может вмещать?
 Мы обсудили основы Serial.read () и Serial.available ().
 Serial.read () удаляет байт из ________________. Функция _________________ возвращает количество байтов в последовательном приемном буфере.
 Мы разработали простую _____________ и стратегию для получения сообщений через наш последовательный порт.
 Затем мы реализовали стратегию в коде Arduino. Наконец, мы поговорили об использовании функции atoi () для преобразования строки c в целое число.
 Если вам это понравилось - вам обязательно понравится следующий урок! В следующем уроке этой серии вы узнаете, как сократить этот код до пары строк, используя некоторые другие встроенные функции библиотеки последовательного интерфейса.
 Последовательная связь
 с Arduino Uno 
 Опубликовано 29 января, 2017, 30 января, 2017, electromaniaweb
 В этом проекте я дам вам введение в UART, который также называется последовательной связью, и пойму, как Arduino взаимодействует с компьютером.Как следует из названия, последовательная связь означает побитовую отправку и получение данных по одной линии. Плата Arduino uno имеет один последовательный порт на цифровых выводах 0 (RX) и 1 (TX) для связи с другими внешними последовательными устройствами или с компьютером через USB-кабель. Процесс отправки и получения данных можно наблюдать по миганию светодиодов TX и RX на плате Arduino.
 Рядом с чипом Atmega 8U2 на плате arduino uno мы можем увидеть два светодиода, это светодиоды TX и RX.
 В случае последовательной связи между Arduino и компьютером цифровые контакты 1 и 0 не должны использоваться в качестве контактов ввода / вывода.Чип Atmega 8U2 на плате Arduino действует как мост между компьютером и процессором Arduino. Он работает на программном обеспечении, называемом прошивкой, которое можно обновлять с помощью специального протокола, называемого DFU (Обновление прошивки устройства).
 ПОСЛЕДОВАТЕЛЬНАЯ СВЯЗЬ МЕЖДУ ARDUINO UNO И КОМПЬЮТЕРОМ 
 Связь между Arduino и компьютером устанавливается с определенной скоростью передачи данных. Скорость передачи определяет, насколько быстро данные передаются по последовательной линии или, проще говоря, скорость последовательной связи.Некоторые общие скорости для UART: 9600 бод, 11520 бод и т. Д. Чтобы начать последовательную связь, скорость передачи данных, установленная для Arduino и компьютера, должна быть одинаковой, если скорость передачи для обоих установлена ​​на 9600 бод, то для передачи 1 бита данных он будет взять 1/9600 сек = 0,014 мсек! Удивительно, не правда ли?
 Сначала я попытаюсь написать простую программу для отправки символа с компьютера на Arduino и получения его обратно компьютером. Во-первых, подключите Arduino и загрузите следующий эскиз на свою плату.
 Программа запускается с открытия последовательной связи между Arduino и компьютером с использованием последовательной функции «Serial.begin (9600) ”со скоростью 9600 бит / с. Еще одна полезная функция, используемая здесь, - это Serial.available (), которая возвращает количество байтов, которые в настоящее время присутствуют в последовательном буфере Arduino.
 Цикл while в программе продолжает ждать, пока от компьютера не будут получены какие-либо последовательные данные. Если какие-либо данные отправляются компьютером, они будут доступны в последовательном буфере Arduino, и цикл while прервется, поскольку функция Serial.available () вернет значение больше нуля. Если последовательные данные доступны, следующим шагом будет считывание данных с помощью последовательного порта.read () и сохраните ее в символьной переменной с именем ‘value’.
 После того, как данные, отправленные компьютером, были получены процессором Arduino, мы хотим отправить эти данные обратно на компьютер. Функция, которая помогает нам в этом, называется Serial.println (). Эта функция выводит данные на последовательный порт, к которому подключен Arduino.
 Нажмите Ctrl + Shift + M, чтобы запустить последовательный монитор в среде Arduino IDE. Последовательный монитор является частью IDE Arduino, которая позволяет пользователю отправлять данные с компьютера на плату Arduino, а также получать данные с платы Arduino.
 После загрузки программы напишите символ 0 в поле редактирования последовательного монитора и нажмите кнопку отправки. Это означает, что мы отправляем символ 0 с компьютера на плату Arduino.
 Согласно нашему коду, плата arduino отправляет полученные данные обратно на компьютер, поэтому мы увидим ноль на последовательном мониторе под полем редактирования.
 Повторите то же самое для 1, 2, 3, 4 и т. Д. И получите их обратно на свой экран, то есть на последовательный монитор.
 Основы последовательного терминала - изучение.sparkfun.com 
 Добавлено в избранное 
 Любимый 
 37
 Монитор последовательного порта Arduino (Windows, Mac, Linux) 
 Интегрированная среда разработки (IDE) Arduino - это программная часть платформы Arduino. И поскольку использование терминала - это большая часть работы с Arduinos и другими микроконтроллерами, они решили включить последовательный терминал в программное обеспечение. В среде Arduino это называется Serial Monitor.
 Установление соединения 
 Serial monitor поставляется с любой версией Arduino IDE. Чтобы открыть его, просто щелкните значок Serial Monitor.
  Значок расположен справа от других значков в Arduino 0023 и ниже. 
  Значок находится справа в Arduino 1.0 и более поздних версиях. 
 Выбор порта для открытия в Serial Monitor аналогичен выбору порта для загрузки кода Arduino.Перейдите в Инструменты  -> Последовательный порт  и выберите правильный порт.
 После открытия вы должны увидеть что-то вроде этого:
 Настройки 
 Serial Monitor имеет ограниченные настройки, но их достаточно, чтобы удовлетворить большинство ваших потребностей в последовательной связи. Первая настройка, которую вы можете изменить, - это скорость передачи данных. Щелкните раскрывающееся меню скорости передачи, чтобы выбрать правильную скорость передачи.
 Вы также можете изменить эмуляцию клавиши ввода на возврат каретки, перевод строки, оба варианта или ни то, ни другое.
 Наконец, вы можете включить или выключить автоматическую прокрутку терминала, установив флажок в нижнем левом углу.
 Плюсы 
 Serial Monitor - отличный быстрый и простой способ установить последовательное соединение с вашим Arduino. Если вы уже работаете в среде Arduino IDE, действительно нет необходимости открывать отдельный терминал для отображения данных.
 Минусы 
 Отсутствие настроек в Serial Monitor оставляет желать лучшего, а для расширенной последовательной связи он может не сработать.
 ← Предыдущая страница 
  Подключение к устройству 
 arduino / serial-discovery: подключаемое обнаружение Arduino IDE для последовательных портов 
 Инструмент  serial-discovery  - это программа командной строки, которая взаимодействует через stdio. Он принимает команды в виде простых строк ASCII, оканчивающихся LF  \ n , и отправляет ответ в формате JSON.
 Как построить 
 Установите недавнюю среду go (> = 13.0) и запустите  go build . Исполняемый файл  serial-discovery  будет создан в вашем рабочем каталоге.
 Использование 
 После запуска инструмент ждет команд. Доступные команды:  HELLO ,  START ,  STOP ,  QUIT ,  LIST  и  START_SYNC .
 Команда HELLO 
 Команда  HELLO  используется для установки подключаемого протокола обнаружения между клиентом и обнаружением.Формат команды:
  ПРИВЕТ  "" 
 например:
  ПРИВЕТ 1 "Arduino IDE" 
 или:
  HELLO 1 "arduino-cli" 
 в этом случае версия протокола, запрошенная клиентом, -  1  (на момент написания других ревизий протокола не было).
Ответ на команду:
 {
  "eventType": "привет",
  "protocolVersion": 1,
  "message": "ОК"
} 
  protocolVersion  - это версия протокола, которую обнаружение будет использовать в оставшейся части связи.
 Команда ПУСК 
  START  запускает внутренние подпрограммы обнаружения, которые ищут порты. Эта команда должна вызываться перед  LIST  или  START_SYNC . Ответ на команду запуска:
 {
  "eventType": "начало",
  "message": "ОК"
} 
 Команда СТОП 
 Команда  STOP  останавливает внутренние подпрограммы обнаружения и освобождает некоторые ресурсы. Эту команду следует вызывать, если клиент хочет на время приостановить обнаружение.Ответ на команду остановки:
 {
  "eventType": "стоп",
  "message": "ОК"
} 
 Команда QUIT 
 Команда  QUIT  завершает обнаружение. Ответ на выход:
.
 {
  "eventType": "выйти",
  "message": "ОК"
} 
 после этого вывода инструмент завершает работу.
 Команда СПИСОК 
 Команда  LIST  возвращает список доступных в настоящее время последовательных портов. Формат ответа следующий:
 {
  "eventType": "список",
  "порты": [
    {
      "адрес": "/ dev / ttyACM0",
      "ярлык": "/ dev / ttyACM0",
      "характеристики": {
        "pid": "0x804e",
        "vid": "0x2341",
        "serialNumber": "EBEABFD6514D32364E202020FF10181E"
      },
      "протокол": "серийный",
      "protocolLabel": "Последовательный порт (USB)"
    }
  ]
} 
 Поле  портов  содержит список доступных последовательных портов.Если последовательный порт поступает от последовательного преобразователя USB, свойства USB VID / PID и USB SERIAL NUMBER также сообщаются в свойствах  .
 Команда list - это однократная команда, если вам нужен непрерывный мониторинг портов, вы должны использовать команду  START_SYNC .
 Команда START_SYNC 
 Команда  START_SYNC  переводит инструмент в режим «событий»: обнаружение будет отправлять  добавить  и  удалить  события каждый раз, когда будет обнаружен или удален новый порт соответственно.Немедленный ответ на команду:
 {
  "eventType": "start_sync",
  "message": "ОК"
} 
 после этого открытие переходит в режим «событий».
  добавить  событий выглядит следующим образом:
 {
  "eventType": "добавить",
  "порт": {
    "адрес": "/ dev / ttyACM0",
    "ярлык": "/ dev / ttyACM0",
    "характеристики": {
      "pid": "0x804e",
      "vid": "0x2341",
      "serialNumber": "EBEABFD6514D32364E202020FF10181E"
    },
    "протокол": "серийный",
    "protocolLabel": "Последовательный порт (USB)"
  }
} 
 он в основном собирает ту же информацию, что и событие  list , но для одного порта.После вызова  START_SYNC  может быть сгенерирована последовательность событий  добавить , чтобы сообщить обо всех портах, доступных на момент запуска.
 Событие удаления   выглядит так:
 {
  "eventType": "удалить",
  "порт": {
    "адрес": "/ dev / ttyACM0",
    "протокол": "серийный"
  }
} 
, в этом случае сообщаются только поля  адреса  и  протокола .
 Пример использования 
 Возможная расшифровка использования открытия:
  $./ серийное открытие
НАЧАЛО
{
  "eventType": "начало",
  "message": "ОК"
}
СПИСОК
{
  "eventType": "список",
  "порты": [
    {
      "адрес": "/ dev / ttyACM0",
      "ярлык": "/ dev / ttyACM0",
      "протокол": "серийный",
      "protocolLabel": "Последовательный порт (USB)",
      "характеристики": {
        "pid": "0x004e",
        "serialNumber": "EBEABFD6514D32364E202020FF10181E",
        "vid": "0x2341"
      }
    }
  ]
}
START_SYNC
{
  "eventType": "start_sync",
  "message": "ОК"
}
{<--- это событие было немедленно отправлено
  "eventType": "добавить",
  "порт": {
    "адрес": "/ dev / ttyACM0",
    "ярлык": "/ dev / ttyACM0",
    "протокол": "серийный",
    "protocolLabel": "Последовательный порт (USB)",
    "характеристики": {
      "pid": "0x004e",
      "serialNumber": "EBEABFD6514D32364E202020FF10181E",
      "vid": "0x2341"
    }
  }
}
{<--- здесь отключена плата
  "eventType": "удалить",
  "порт": {
    "адрес": "/ dev / ttyACM0",
    "протокол": "серийный"
  }
}
{<--- плата снова подключена
  "eventType": "добавить",
  "порт": {
    "адрес": "/ dev / ttyACM0",
    "ярлык": "/ dev / ttyACM0",
    "протокол": "серийный",
    "protocolLabel": "Последовательный порт (USB)",
    "характеристики": {
      "pid": "0x004e",
      "serialNumber": "EBEABFD6514D32364E202020FF10181E",
      "vid": "0x2341"
    }
  }
}
ПОКИДАТЬ
{
  "eventType": "выйти",
  "message": "ОК"
}
$
  
 Безопасность 
 Если вы считаете, что обнаружили в этом проекте уязвимость или другую ошибку, связанную с безопасностью, прочтите наши
политики безопасности и сообщите об ошибке нашей команде безопасности 🛡️
Спасибо!
 Адрес электронной почты
: security @ arduino.куб.см
 Лицензия 
 Авторские права (c) 2018 ARDUINO SA (www.arduino.cc)
 Программное обеспечение выпущено под Стандартной общественной лицензией GNU, которая охватывает основную часть
кода последовательного обнаружения. С условиями этой лицензии можно ознакомиться по адресу:
https://www.gnu.org/licenses/gpl-3.0.en.html
 Подробнее см. LICENSE.txt.
 ✅ Использование программного обеспечения Последовательная библиотека в промышленной автоматизации ПЛК Arduino 
 Что такое последовательная связь с Arduino? Как библиотека используется в Arduino IDE? 
 
 Существуют различные типы последовательной связи.Когда вы используете плату Arduino в проекте, вы можете выбрать стандартные последовательные выводы в качестве программного обеспечения Arduino с серийным номером  Rx Tx из UART  внутри платы Arduino, поэтому это называется последовательным TTL. В этом случае вы будете использовать библиотеку Hardwareserial.h, но некоторые дополнительные контакты могут работать как Rx или Tx. Например, контакты связи  SPI  могут работать как MISO, MOSI и Select (SC), но они также являются контактами, которые  могут работать как цифровой вход или цифровой выход , или, если вам нужно, вы можете использовать эти контакты  как Rx, Tx  с использованием ПО.h Библиотека.
 Последовательная связь позволяет подключать два разных устройства, отправляющих и получающих данные между собой.
 Последовательный порт  TTL  может быть преобразован в соответствии с требованиями Industry  как RS232 и как RS485 . Когда вы используете RS232, функциональность очень похожа на работу с последовательным TTL, но если вы работаете с RS485, вы можете настроить сеть с помощью главного устройства, которое может подключаться к подчиненным устройствам. Таким образом, количество устройств увеличено с 2 до 32 устройств (узлов).Максимальное расстояние между ними может составлять до 1220 м, если проводка выполнена правильно и в соответствии с требованиями EMC, а электрические помехи исключены.
 Подводя итог, можно сказать, что если вы используете последовательный порт UART от Arduino или ПЛК на базе Arduino для промышленных проектов, использование других выводов, работающих в качестве последовательного TTL, может помочь вам в успешной разработке вашего проекта. Таким образом, этот дополнительный последовательный порт должен быть запрограммирован с использованием библиотеки  softwareserial.h .
 Если невозможно использовать HardwareSerial Library, потому что вам нужно использовать протокол связи, который требует использования физического UART вместо виртуального последовательного порта.Затем вы можете преобразовать стандартный RS232 или RS485 с устройства в последовательный TTL.  (Этот пример будет показан в другом сообщении) 
 В этом сообщении объясняется преимущество SoftwareSerial Library для имитации последовательного порта через программное обеспечение (виртуальный последовательный TTL) с использованием Arduino IDE. 
 Драйверы Ch440 для Windows, Mac и Linux 
 Микросхема Ch440 используется рядом плат, совместимых с Arduino, для обеспечения USB-подключения, вам может потребоваться установить драйвер, не паникуйте, это проще, чем упасть с бревна , и гораздо менее болезненно.
 Окна 
 (Информационная ссылка производителя на китайском языке)
 Загрузите драйвер Windows Ch440
 Распаковать файл
 Запустите программу установки, которую вы распаковали.
 В среде Arduino IDE, когда подключен Ch440, вы увидите COM-порт в меню Tools> Serial Port, номер COM для вашего устройства может отличаться в зависимости от вашей системы. 
 Более старая версия драйвера Windows и инструкции 
  Загрузите драйвер Windows Ch440  
  Распакуйте папку. 
   Если у вас 64-битная Windows:  - запустите установщик SETUP_64.EXE.  
   Если вы используете 32-битную Windows:  - запустите установщик SETUP_32.EXE.  
  Если вы не знаете, попробуйте 64-разрядную версию, а если не работает - 32-разрядную.  
  В среде Arduino IDE, когда подключен Ch440, вы увидите COM-порт в меню Tools> Serial Port, номер COM для вашего устройства может отличаться в зависимости от вашей системы. 
 Macintosh 
 (Информационная ссылка производителя на китайском языке)
 В следующем github на момент написания есть текущие файлы pkg для 1.3, 1.4 и 1.5, спасибо Джошуа Уоллису за то, что обратил на это мое внимание…
 https://github.com/adrianmihalko/ch440g-ch44g-ch44x-mac-os-x-driver
  Прямые ссылки для скачивания (из репозитория github выше): 
 V1.5 Ch440 Драйвер MaxOS, упаковка
 V1.4 Ch440 Драйвер MacOS, упаковка
 V1.3 Ch440 Драйвер MacOS Pkg
 См. Ссылку на github выше для получения инструкций по установке, если они вам нужны.
 Предыдущие загрузки macinstosh, если вышеуказанное не работает для вас… 
  (V1.3) Загрузите подписанный драйвер Ch440 Macintosh для Mavericks (10.9), Yosemite (10.10) и El Capitan (10.11) и Sierra (10.12) 
  Внутри zip-файла вы найдете PDF-файл и файл «pkg», короткую версию, дважды щелкните файл pkg, в PDF-файле есть дополнительная информация.
   OSX Sierra (10.12) Примечание  
  Любезный пользователь, сообщает Маартен Сегерс 
  FYI, драйвер, описанный здесь, БУДЕТ сбой на OSX Sierra. 
  Я лично не могу тестировать на MacOS и не могу поручиться за вышеперечисленные драйверы на github, но готово.
  См. Информацию об удалении внизу страницы, если драйвер вызывает у вас проблемы. 
   Вот более старая версия драйвера Mac, НЕ ДЛЯ 10.12 Sierra  
  (V1.0) Загрузите подписанный драйвер Ch440 Macintosh для Mavericks (10.9), Yosemite (10.10) и El Capitan (10.11) 
 Linux 
 (Информационная ссылка производителя на китайском языке)
 Драйверы
 почти наверняка уже встроены в ваше ядро ​​Linux, и, вероятно, оно будет работать, как только вы его подключите.Если нет, вы можете загрузить драйвер Linux Ch440 (но я бы рекомендовал просто обновить установленный Linux, чтобы вы получили «встроенный» драйвер).
 Удаление с Macinstosh 
 Несколько пользователей Mac сказали: «Драйвер выдает сбой в моем Mac Sierra, как мне удалить».
 Прежде всего, что касается сбоя, убедитесь, что вы установили версию драйвера 1.3, а не старую. Вы можете загрузить его прямо с веб-сайта производителей, если они выпустили обновление с тех пор, как я написал эту страницу.
 Во-вторых, быстрый поиск в Google показывает, что вы удаляете его следующим образом:
 Откройте терминал и введите:  cd / Library / Extensions / 
 Убедитесь, что файл .kext присутствует:  ls | grep usbserial.kext 
 Вывод должен быть:  usbserial.kext 
 Затем введите:  sudo rm -R usbserial.kext 
 Убедитесь, что файл .kext был удален:  ls | grep usbserial.kext 
 Выходной файл должен быть пустым.
 После того, как вы должны удалить файлы, хранящиеся в папке квитанций:  cd / private / var / db / квитанции / 
 Найдите объекты:  ls | grep usbserial * 
 Результат должен быть:  codebender.cc.ch44xinstaller.usbserial.pkg.bom codebender.cc.ch44xinstaller.usbserial.pkg.plist 
 Удалите каждый из файлов из приведенного выше списка:  sudo rm -r   filename  `
.