Как установить последовательный порт в arduino ide
Перейти к содержимому

Как установить последовательный порт в arduino ide

  • автор:

Arduino IDE : Работа с Serial Monitor

Самой популярной средой разработки для Arduino является официальная программа от итальянских разработчиков — Arduino IDE. Можно конечно использовать и другие программы, например, имеющая обширный функционал, Atmel Studio и другие. Но сегодня мы остановимся на самом оптимальном варианте для начинающих, да и просто для любителей пошаманить долгими вечерами за компьютером, проектируя очередной проект.

Скачать Arduino IDE можно на официальном сайте Arduino, в разделе программное обеспечение. Вы можете скачать любую версию, как самую новую, так и самую старую. Однако, советую также использовать версию 1.6.5 или 1.6.9, поскольку они является одними из самых стабильных и реже выдают ошибки при компиляции, казалось бы, правильно написанного кода.

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

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

С помощью раздела “Файл” мы можем управлять нашими файлами и скетчами: создавать, открывать, сохранять и распечатать, то есть самые стандартные функции в подобного рода программах. Особое внимание стоит уделить здесь нескольким подразделам.

Функция “Открыть недавние” достаточна полезная, так как поможет вам открыть программные кода, с которыми вы ранее работали, и не придется тратить лишнее время на их поиски. В подразделе “Примеры” содержится огромное множество уже готовые программных кодов (скетчей), взятых на разные направления: механика, мигание светодиодом, циклы, работа с дисплеями и аналоговыми выходами и так далее. При установке новых библиотек в Arduino (для различных модулей и датчиков) число примеров увеличится. Также, эти коды содержат подробные пояснения, и поэтому данный раздел будет очень полезен начинающим, программировать на платформе Ардуино. Еще есть подраздел “Настройки”. В нем стоит обратить внимание на отдельное поле для вставки ссылок, которые позволят загрузить в программу возможность работы с другими платформами и модулями, например с семейством интернет модулей на чипе ESP.

Раздел “Правка” служит для редактирования текста, кода и пояснений для него.

Раздел “Скетч” позволит выполнить различные действия с вашим кодом, например, проверить его (отправить на компиляцию) или загрузить в память вашего устройства.

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

И также имеется раздел “Помощь”, который, вроде как, должен решать возникающие проблемы при работе с Arduino IDE.

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

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

В данной статье хотелось бы затронуть возможность открытия в программе специального дополнительного окна, на котором будут выводиться значения сигналов и различные данные с датчиков и модулей, подключенных к Ардуино. Называется эта функция Serial Monitor (в русскоязычной версии – монитор порта). Ее, также, можно открыть с помощью сочетания клавиш Ctrl+Shift+M

По сути, это окно отвечает за последовательный порт соединения и служит для принятия или отправки различных данных на этот самый порт. В первом поле вы можете вводить различные значения (отправлять их в порт с помощью кнопки “отправить”) и получать, засчет этого, определенную информацию с Ардуино (если это прописано в вашем коде). Есть также поле для получения данных, а внизу справа можно менять скорость последовательного соединения (измеряется в битах и или в бод на секунду). Чаще всего используется значение в 9600. При использовании монитора порта, смотрите, чтобы скорости передачи данных, одна из которых прописана в скетче, а другая – установлена в самом мониторе порта, совпадали.

Чаще всего для работы с этим окном, используют две функции — Serial.print () и Serial.read(). Первая позволяет отправлять данные через порт последовательного соединения, а вторая – принимать их.

Приведем два кода для работы с монитором порта в Arduino IDE

Управление светодиодом с помощью монитора порта. Суть кода такова, что если мы введем цифру 1 в поле ввода и нажнем “отправить”, то светодиод загорится, если введем 0, то погаснет.

void setup() < Serial.begin(9600); // устанавливаем скорость передачи данных последовательного соединения pinMode(13, OUTPUT); // указываем номер контакта на плате, к которому подключен светодиод (13 - это встроенный светодиод на плате) >void loop() < // Получаем команды на включение-выключение светодиода на 13 порту. String str = Serial.readString(); // Если команда «1» то включаем светодиод. if (str == "1") digitalWrite(13, 1); // Если команда «0» то выключаем светодиод. if (str == "0") digitalWrite(13, 0); // Делаем временную задержку в 1 секунду (1000 миллисекунд) delay(1000); >

Следующий программный код позволит нам передавать данные из Arduino в Монитор порта, например слово «Amperkot»

void setup() < // устанавливаем скорость передачи данных последовательного соединения. Serial.begin(9600); >void loop() < // Отправляем «Amperkot». Serial.print("Amperkot"); // Отправляем «Amperkot» включая спецсимволы, означающие переход на новую строку. Serial.println("Amperkot"); // Делаем временную задержку в 1 секунду (1000 миллисекунд). delay(1000); >

Получаем такую картину:

Таким образом, прочитав данную статью, вы поняли основные функции и интерфейс программы Arduino IDE — среды разработки для Arduino и подобных ей плат, а также узнали о мониторе порта, о предназначении функций Serial.print () и Serial.read(), о том как и для чего их используют. Надеемся, что материал был для вас интересен, а главное полезен, и желаем всем удачной компиляции!

Данная статья является собственностью Amperkot.ru. При перепечатке данного материала активная ссылка на первоисточник, не закрытая для индексации поисковыми системами, обязательна.

Монитор порта, отладка

Как мы с вами знаем из урока “Что умеет микроконтроллер“, у многих микроконтроллеров есть интерфейс UART, позволяющий передавать и принимать различные данные. У интерфейса есть два вывода на плате – пины TX и RX. На большинстве Arduino-плат к этим пинам подключен USB-UART преобразователь (расположен на плате), при помощи которого плата может определяться компьютером при подключении USB кабеля и обмениваться с ним информацией. На компьютере создаётся виртуальный COM порт (последовательный порт), к которому можно подключиться при помощи программ-терминалов и принимать-отправлять текстовые данные. Таким же образом кстати работают некоторые принтеры и большинство станков с ЧПУ.

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

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

  • Конец строки: тут есть несколько вариантов на выбор, чуть позже вы поймёте, на что они влияют. Лучше поставить нет конца строки, так как это позволит избежать непонятных ошибок на первых этапах знакомства с платформой.
    • Нет конца строки – никаких дополнительных символов в конце введённых символов после нажатия на кнопку отправка или клавишу Enter.
    • NL – символ переноса строки в конце отправленных данных.
    • CR – символ возврата каретки в конце отправленных данных.
    • NL+CR – и то и то.

    Объект Serial

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

    Serial.begin(speed)

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

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

    Прекратить связь по Serial. Также освобождает пины RX и TX.
    Serial.available()
    Возвращает количество байт, находящихся в буфере приёма и доступных для чтения.
    Serial.availableForWrite()

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

    Serial.write(val), Serial.write(buf, len)

    Отправляет в порт val численное значение или строку, или отправляет количество len байт из буфера buf. Важно! Отправляет данные как байт (см. таблицу ASCII), то есть отправив 88 вы получите букву X: Serial.write(88); .

    Serial.print(val), Serial.print(val, format)

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

    Serial.print(78); // выведет 78 Serial.print(1.23456); // 1.23 (по умолч. 2 знака) Serial.print('N'); // выведет N Serial.print("Hello world."); // Hello world. // можно сделать форматированный вывод в стиле Serial.print("i have " + String(50) + " apples"); // выведет строку i have 50 apples // вместо чисел можно пихать переменные byte appls = 50; Serial.print("i have " + String(appls) + " apples"); // выведет то же самое

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

    Serial.print(78, BIN); // вывод "1001110" Serial.print(78, OCT); // вывод "116" Serial.print(78, DEC); // вывод "78" Serial.print(78, HEX); // вывод "4E" Serial.print(1.23456, 0); // вывод "1" Serial.print(1.23456, 2); // вывод "1.23" Serial.print(1.23456, 4); // вывод "1.2345"

    Serial.println(), Serial.println(val), Serial.println(val, format)

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

    Serial.flush()
    Ожидает окончания передачи данных.
    Serial.peek()

    Возвращает текущий байт с края буфера, не убирая его из буфера. При вызове Serial.read() будет считан тот же байт, но из буфера уже уберётся.

    Serial.read()
    Читает и возвращает крайний символ из буфера.
    Serial.setTimeout(time)

    Устанавливает time (миллисекунды) таймаут ожидания приёма данных для следующих ниже функций. По умолчанию равен 1000 мс (1 секунда).

    Serial.find(target), Serial.find(target, length)

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

    // будем искать слово hello char target[] = "hello"; void setup() < Serial.begin(9600); >void loop() < if (Serial.available() >0) < if (Serial.find(target)) Serial.println("found"); // вывести found, если было послано >>

    Serial.findUntil(target, terminal)

    Читает данные из буфера и ищет набор символов target (тип char ) либо терминальную строку terminal. Ожидает окончания передачи по таймауту, либо завершает приём после чтения terminal.

    Serial.readBytes(buffer, length)

    Читает данные из порта и закидывает их в буфер buffer (массив char[] или byte[] ). Также указывается количество байт, который нужно записать – length (чтобы не переполнить буфер).

    Serial.readBytesUntil(character, buffer, length)

    Читает данные из порта и закидывает их в буфер buffer (массив char[] или byte[] ), также указывается количество байт, который нужно записать – length (чтобы не переполнить буфер) и терминальный символ character. Окончание приёма в buffer происходит при достижении заданного количества length, при приёме терминального символа character (он в буфер не идёт) или по таймауту

    Serial.readString()

    Читает порт, формирует из данных строку String , и возвращает её (урок про стринги). Заканчивает работу по таймауту.

    Serial.readStringUntil(terminator)

    Читает порт, формирует из данных строку String , и возвращает её (урок про стринги). Заканчивает работу по таймауту или после приёма символа terminator (символ char ).

    Serial.parseInt(), Serial.parseInt(skipChar)

    Читает целочисленное значение из порта и возвращает его (тип long ). Заканчивает работу по таймауту. Прерывает чтение на всех знаках, кроме знака – (минус). Можно также отдельно указать символ skipChar, который нужно пропустить, например кавычку-разделитель тысяч (10’325’685), чтобы принять такое число.

    Serial.parseFloat()
    Читает значение с плавающей точкой из порта и возвращает его. Заканчивает работу по таймауту.

    Плоттер

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

    void setup() < Serial.begin(9600); >void loop()

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

    значение1 пробел_или_запятая значение2 пробел_или_запятая значение3 пробел_или_запятая перенос_строки

    Давайте выведем значения с аналоговых пинов A0, A1 и A2:

    void setup() < Serial.begin(9600); >void loop()

    Получим вот такие графики:

    blank

    В Arduino IDE с версии 1.8.10 добавили возможность подписать графики, для этого перед выводом нужно отправить названия в виде название 1, название 2, название n с переносом строки, и дальше просто выводить данные:

    Отправка в порт

    blank

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

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

    Давайте вспомним урок циклы и массивы и выведем в порт элементы массива:

    void setup() < Serial.begin(9600); byte arr[] = ; for (byte i = 0; i < 8; i++) < Serial.print(arr[i]); Serial.print(' '); >> void loop()

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

    Чтение из порта

    Проблемы возникают при попытке принять данные в порт. Дело в том, что метод read() читает один символ, а если вы отправите длинное число или строку – программа получит его по одному символу. Чтение сложных данных называется парсинг. Его можно делать вручную, об этом мы поговорим в отдельном уроке из блока “Алгоритмы”. В рамках этого урока рассмотрим встроенные инструменты для парсинга Serial.

    Чтобы не нагружать программу чтением пустого буфера, нужно использовать конструкцию

    if (Serial.available()) < // тут читаем >

    Таким образом чтение будет осуществляться только в том случае, если в буфере есть какие-то данные.

    Парсинг цифр

    Для чтения целых цифр используем Serial.parseInt() , для дробных – Serial.parseFloat() . Пример, который читает целое число и отправляет его обратно:

    void setup() < Serial.begin(9600); >void loop() < if (Serial.available()) < int val = Serial.parseInt(); Serial.println(val); >>

    Если при парсинге у вас появляются лишние цифры – поставьте “Нет конца строки” в настройках монитора порта

    Вы заметите, что после отправки проходит секунда, прежде чем плата ответит в порт. Эта секунда является таймаутом, о котором мы говорили чуть выше. Программа ждёт секунду после принятия последнего символа, чтобы все данные успели прийти. Секунда это очень много, ожидать, скажем, 50 миллисекунд. Это можно сделать при помощи метода setTimeout() .

    void setup() < Serial.begin(9600); Serial.setTimeout(50); >void loop() < if (Serial.available()) < int val = Serial.parseInt(); Serial.println(val); >>

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

    Парсинг текста

    Проще всего прочитать текст в String-строку (урок про них). Это максимально не оптимально, но зато довольно просто для восприятия:

    void setup() < Serial.begin(9600); Serial.setTimeout(50); >void loop() < if (Serial.available()) < String str = Serial.readString(); Serial.println(str); >>

    Данный пример выводит любой текст, который был отправлен в монитор порта.

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

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

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

    Также если в тексте вы захотите использовать одинарные кавычки ‘ , двойные кавычки « , обратный слэш \ и некоторые другие символы – их нужно экранировать при помощи обратного слэша, он просто ставится перед символом:

    • \» – двойные кавычки
    • \’ – апостроф
    • \\ – обратный слэш
    • \0 – нулевой символ
    • \? – знак вопроса

    Выведем строку с кавычками:

    Serial.println("\"Hello, World!\""); // выведет "Hello, World!"

    Комбинация \r\n переведёт строку и вернёт курсор в левое положение:

    Serial.print("Hello, World!\r\nArduino Forever"); // выведет // Hello, World! // Arduino Forever

    Символы табуляции позволят удобно отправлять данные для последующей вставки в таблицу. Например выведем несколько степеней двойки в виде таблицы, используя символ табуляции \t :

    for (byte i = 0; i < 16; i++) < // i от 0 до 16 Serial.print(i); // степень Serial.print("\t"); // табуляция Serial.println(round(pow(2, i))); // 2 в степени i >

    Результат скопируем и вставим в excel Удобно!

    Видео

    Полезные страницы

    • Набор GyverKIT – большой стартовый набор Arduino моей разработки, продаётся в России
    • Каталог ссылок на дешёвые Ардуины, датчики, модули и прочие железки с AliExpress у проверенных продавцов
    • Подборка библиотек для Arduino, самых интересных и полезных, официальных и не очень
    • Полная документация по языку Ардуино, все встроенные функции и макросы, все доступные типы данных
    • Сборник полезных алгоритмов для написания скетчей: структура кода, таймеры, фильтры, парсинг данных
    • Видео уроки по программированию Arduino с канала “Заметки Ардуинщика” – одни из самых подробных в рунете
    • Поддержать автора за работу над уроками
    • Обратная связь – сообщить об ошибке в уроке или предложить дополнение по тексту ([email protected])

    Мониторинг работы устройства через последовательный порт

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

    Доступ к последовательному просту очень просто получить через Arduino IDE.

    При этом, обычно необходимо установить и драйвер CH340 (СР341), например, отсюда: http://deviceinbox.com/drivers/752-usb-serial-ch340.html. Иначе китайский клон ардуино не будет опознан компьютером.

    • Подключите устройство к компьютеру с помощью Data-кабеля USB,
    • Запустите Arduino IDE,
    • Выберите порт, к которому подключено устройство
    • Откройте монитор последовательного порта.

    • Если окно вывода порта не пустое – нажмите кнопку[Очистить вывод].
    • Выберите 9600 бод

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

    Как скопировать текст из монитора порта ардуино

    1. Щелкните мышкой в текст
    2. Нажмите Ctrl+A (латинская буква) – выделится весь текст
    3. Нажмите Ctrl+C (латинская буква) – текст поместить в буфер
    4. Откройте почтовую или другую программу, через которую отправляете текст в поддержку
    5. Нажмите Ctrl+V – текст вставится из буфера. Можно отправлять.

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

    Свежие записи

    • Защищено: Загрузка прошивки
    • Синхронная розетка для пылесоса и струшкоотсоса в мастерскую своими руками на ардуино
    • Множим выходы Ардуино, сдвиговый регистр 74HC595
    • Эксперимент №15. Аналоговые порты ардуино и потенциометр
    • Скетч не загружается в Ардуино. Что делать?

    Свежие комментарии

    • chs2k@mail.ru к записи Эксперимент № 1. Привет, Мир!
    • jarduino к записи Как загрузить HEX прошивку Ардуино
    • Andrey Master к записи Как загрузить HEX прошивку Ардуино
    • jarduino к записи Умная зимняя удочка
    • Mel к записи Умная зимняя удочка

    Урок 12. Последовательный порт UART в Ардуино. Библиотека Serial. Отладка программ на Ардуино.

    UART

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

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

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

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

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

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

    Протокол UART

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    Схема Arduino UNO R3

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

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

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

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

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

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

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

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

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

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

    void begin(long speed)

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

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

    void end(void)

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

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

    int available(void)

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

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

    int read(void)

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

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

    void flush(void)

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

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

    print()

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

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

    println()

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

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

    int write()

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

    int peek(void)

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

    int readBytes(* buf, len)

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

    setTimeout(long time)

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

    void serialEvent()

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

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

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

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

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

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

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

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

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

    Тестовое окно

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

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

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

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

    Тестовое окно

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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