Ардуино монитор: Уроки Arduino. Монитор порта

Подключаем к ардуино датчик сердечного ритма и Oled дисплей \ Arduino Heart Rate Monitor

Этот простой и недорогой проект основан на плате анализатора MAX30100 , для визуализации использован  0,91-дюймовый OLED-дисплей, чтобы сообщать о частоте сердечных сокращений и уровне оксигенации.

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

Используемые детали  + ссылки на алиэкспресс с лучшей ценой

Ардуино Нано     http://ali.pub/1imsc4

0.91 «OLED-дисплей с интерфейсом I2C  http://ali.pub/1imse2

Частота сердечных сокращений MAX30100  http://ali.pub/1imsgl

Провода для соединения

На дисплее OLED и на плате MAX30100  4 провода, подключаем  к плате Arduino по след. схеме:

земля       земля

VCC           +5

SDA           A4

SCL            A5

Линии данных для интерфейса I2C будут зависеть от конкретной версии используемой платы Arduino. В этом случае я использую A4 для SDA и A5 для SCL, так как это аппаратные  контакты для Uno и Nano.

Работает данная система следующим образом :

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

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


Скетч с пояснениями можно скачать на гитхабе Скачать скетч

Так же не забываем о экономии при покупке товаров на Алиєкспресс с помощью кэшбэка

Для веб администраторов и владельцев пабликов  главная страница ePN

Для пользователей покупающих на Алиэкспресс с быстрым выводом % главная страница ePN Cashback

Удобный плагин кэшбеэка браузерный плагин ePN Cashback

Датчик пыли SAMON1 PM2.5 для Arduino, воздушный монитор uno climate dht11 GP2Y1051AU0F|Интегральные схемы|

информация о продукте

Характеристики товара

  • Состояние:
    Новый
  • Тип:
    Регулятор напряжения
  • Номер модели:
    SAMON1 PM2.5 for Arduino Air Monitor Kit
  • Применение:
    Компьютер
  • Индивидуальное изготовление:
    Да

описание продукта

Другое горячая распродажа:

Монитор воздуха SAMON1 PM2.5 Arduino, отображение PM2.5, температуры и влажности

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

-Плата Arduino uno R3 (версия ch440) и модуль ЖК-клавиатуры
— YW-51GJ (3rd поколения GP2Y1051AU0F совместимый) датчик пыли с помощью 2400bps TTL серийный протокол
-DHT11 датчик температуры и влажности
-Плата Arduino uno предварительно загружена (не нужно программировать и загружать)
-Исходный код, технические характеристики и драйвер включены в CD-диск.

* Посылка
— Комплект монитора воздуха для Arduino SAMON1
-USB кабель
-CD-диск с данными (исходный код arduino, база данных и драйвер)

отзывах покупателей ()

Нет обратной связи

Serial Port Monitor — Сниффер COM порта. RS232/485 Analyzer

Запуск/остановка мониторинга последовательного порта, открытого другим приложением (доступно в версииях Professional и Company)
Serial Port Monitor полностью совместим с Windows 10 (x32 и x64)
Serial Port Monitor и все его драйверы имеют цифровую подпись
Одновременный контроль неограниченного количества последовательных портов
Возможность добавления нескольких портов для мониторинга в рамках одной сессии
Поддерживает все виды COM-портов: стандартные встроенные порты, порты плат расширения, виртуальные программные последовательные порты, COM-порты Bluetooth, USB to SERIAL адаптеры и др.
Мониторинг передачи данных и ее логирование
Расширенный диалог отправки: легко отправлять различные типы данных, применять псевдонимы для быстрого набора текста и автоматизации, отправлять файлы и замыкать функции и команды, изменять параметры последовательного порта в процессе работы (доступно в версииях Professional и Company)
Сбор данных в режиме реального времени
Различные визуализаторы мониторинга: табличное представление, вид строки, дамп и терминал
Логирование входящих и исходящих потоков данных
Файл с данными можно разбить на несколько файлов или задать ему определенный размер
Возможность экспорта необработанных данных в файл из терминального вида
Разноцветная визуализация команд в табличном видовом представлении
Любое программное/аппаратное обеспечение, работающее с последовательным портом, может контролироваться
Возможность перехватывать и записывать все последовательные управляющие коды ввода/вывода (IOCTLs), отслеживая все их данные и параметры
Настраиваемое логирование сессии мониторинга (несколько форматов временных меток, различные системы счисления, настраиваемая длина строки и т.д.)
Удобное и гибкое управление сессией мониторинга: сохранение и загрузка всех данных мониторинга, функции экспорта и перенаправления в файл
Экспорт сессии мониторинга (HTML, ASCII текст, Unicode текст, Exсel CSV) и автоматическое перенаправление в файл (Serial Port Monitor автоматически добавит в файл все данные мониторинга в режиме реального времени)
Поддерживает копирование всех записанных данных в буфер обмена
Поддерживает автоматическое добавление данных до и после передачи пакета
Поддерживается полнодуплексный режим
Визуализируется статус управляющих линий
Уникальные инструменты фильтрации потока с пресетами
Поддерживаются все скорости передачи данных
Гибкая конфигурация: стоп-биты, управление потоком, контроль четности, биты данных, выделение и пр.
Удобный гибкий интерфейс: программное обеспечение разработано специально для обеспечения легкого доступа к последовательным портам, никаких навыков программирования не требуется
Раздел комментариев для табличного отображения
Быстрая настройка фильтров на панели инструментов
Если мониторинг неактивен, может быть создан новый файл перенаправления данных
Статистика в строке состояния от первого до последнего подсвечивает IRP в виде «Таблица». В IRP появились подсказки по их расшифровке
Фильтрация данных по портам
Данные, которые приложение пыталось записать в порт, отображаются дополнительно к фактически записанным данным
Автоматическую прокрутку для представления терминала можно отключить
Опция командной строки позволяет продолжить запись в файл, вместо того, чтобы перезаписывать существующие данные

Arduino. Работа с COM-портом | CUSTOMELECTRONICS.RU

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

Подготовка к работе

Большинство микроконтроллеров обладают множеством портов ввода-вывода. Для связи с ПК наиболее пригоден из них протокол UART. Это протокол последовательной асинхронной передачи данных. Для его преобразования в интерфейс USB на плате есть конвертор USB-RS232 – FT232RL.
Для выполнения примеров их этой статьи вам будет достаточно только Arduino-совместимая плата. Мы используем EduBoard. Убедитесь, что на вашей плате установлен светодиод, подключенный к 13му выводу и есть кнопка для перезагрузки.

Таблица 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(). Эта функция возвращает количество байт в буфере. Чтобы вычитать эти байты необходимо воспользоваться функцией Serial.read(). Рассмотрим работу этих функций на примере:


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.available() > 0. Далее функция Serial.read() вычитывает этот байт, тем самым очищая буфер. После чего при помощи уже известных вам функций происходит вывод.
Использование встроенного в Arduino IDE монитора COM-порта имеет некоторые ограничения. При отправке данных из платы в COM-порт вывод можно организовать в произвольном формате. А при отправке из ПК к плате передача символов происходит в соответствии с таблицей ASCII. Это означает, что когда вы вводите, например символ “1”, через COM-порт отправляется в двоичном виде “00110001” (то есть “49” в десятичном виде).
Немного изменим код и проверим это утверждение:


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.

CuteCom монитор порта

В работе с микроконтроллерами, программированием и отладкой, приёмом и передачей данных может понадобиться монитор последовательного порта. Под Linux для этих целей подойдёт программа CuteCom.

Установка:

sudo apt install cutecom

Для доступа к устройству программу следует запускать от имени суперпользователя или добавить пользователя в группу dialout:

sudo usermod -a -G dialout yourUserName

Запускаем программу, нажимаем кнопку Settings, делаем настройки и подключаемся к порту:

Заметим, программа позволяет устанавливать скорость передачи из списка и вручную. У меня устройство /dev/ttyUSB0 плата ESS8266-01 подключённая к USB порту через микросхему QinHeng Electronics HL-340 USB-Serial adapter.

Файл конфигурации CuteCom Вы найдёте по адресу ~/.config/CuteCom/CuteCom.conf

[CuteCom]
CharacterDelay=0
LineTerminator=2
LogFileLocation=/home/dior/cutecom.log
Protocol=0
SendingStartDir=/home/dior
[email protected](331 299 911 561)
session=Default

[sessions]
1\BaudRate=74880
1\DataBits=8
1\Device=/dev/ttyUSB0
1\FlowControl=0
1\History=AT
1\OpenMode=3
1\Parity=0
1\StopBits=1
1\name=Default
1\showCtrlCharacters=false
1\showTimestamp=false
size=1

Я отключил вывод времени и спецсимволов:

 ets Jan  8 2013,rst cause:2, boot mode:(3,7)

load 0x40100000, len 2408, room 16 
tail 8
chksum 0xe5
load 0x3ffe8000, len 776, room 0 
tail 8
chksum 0x84
load 0x3ffe8310, len 632, room 0 
tail 8
chksum 0xd8
csum 0xd8

2nd boot version : 1.6
  SPI Speed      : 40MHz
  SPI Mode       : QIO
  SPI Flash Size & Map: 8Mbit(512KB+512KB)
jump to run user1 @ 1000

rf cal sector: 249
rf[112] : 00
rf[113] : 00
rf[114] : 01

SDK ver: 2.0.0(5a875ba) compiled @ Aug  9 2016 15:12:27
phy ver: 1055, pp ver: 10.2

<0x02>hJ<0xd4>)

<<< ESP8266-01 подключение USB-UART Ω ESP8266-01 AT интерпретатор >>>

Курс Arduino Starter. Урок №6. Монитор последовательного

Обзор.

В этом уроке Вы узнаете, как в созданный проект на уроке 5, добавить возможность управления светодиодами с вашего компьютера используя монитор последовательного порта в Arduino. Монитор последовательного порта это своеобразный «трос» между компьютером и вашим Arduino — он позволяет отправлять и принимать текстовые сообщения, удобен для отладки, а также позволяет управлять Arduino с клавиатуры!

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

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

Загрузите представленный ниже код на плату. Позднее мы разберем как он работает.

После загрузки шаблона плату, нажмите на крайнюю правую кнопку на панели инструментов в Arduino IDE. Кнопка обведена ниже.

Откроется следующее окно.

Это окно называется серийный монитор это часть Arduino IDE. Его работа состоит в том, чтобы позволить вам отправлять сообщения с компьютера на плату Arduino (через USB), а также получать сообщения от Arduino.

Сообщение “Enter LED Number 0 to 9 or ‘x’ to clear” отправлено на Arduino, это означает, что мы можем отправлять команду в Arduino, которая либо отправит ‘х’ (чтобы включить все выключеные светодиоды) или количество светодиодов которое вы хотите включить (где 0-самый нижний светодиод, 1 следующий и  7 самый верхний).

Попробуйте ввести следующие команды в верхней строке серийного монитора, которая расположена на одном уровне с кнопкой «Отправить». Нажмите «Отправить», после ввода каждого из этих знаков: х 0 3 5

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

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

Код.

Как и следовало ожидать, шаблон основан на шаблоне, использованном в уроке 5. Так что, мы будем просто разберем новые части кода.

Во-первых, в “Setup”-функции, есть две новых строки в конце:

Во-первых, у нас есть команда Serial.begin(9600). Эта команда начинает серийную коммуникацию, так что Ардуино может посылать команды через USB-соединение. Значение 9600 называется ‘скорость’ соединения. Настолько быстро данные должны быть отправлены на плату. Значение можно изменить на более высокое, но также нужно изменить то же значение в серийном мониторе. Мы обсудим это позже, а пока оставьте его на 9600.

Последняя из новых строк в ‘настройках’ посылает сообщение, которое мы видим в верхней части серийного монитора.

Ниже Loop функция, где собраны все команды:

Все, что происходит внутри цикла содержится в операторе «if». Так если вызов встроенной в Arduino функции ‘Serial.available()’ вернет состояние ‘true’ больше ничего не произойдет.

Serial.available() вернет значение True, если данные были отправлены в Arduino и готовы к исполнению. Входящие сообщения хранятся в так называемом буфере и Serial.available() возвращает True, если буфер не пуст.

Если сообщение не получено, то смотрим следующую строку кода:

Эта строка читает следующий символ в буфере и удаляет его из буфера. Она также присваивает это значение переменной ‘ch’. Переменная ‘ch’ имеет Тип ‘char’, которая расшифровывается как «символ» и как следует из названия, вмещает один символ.

Если вы следовали инструкциям в строке в верхней части серийного монитора символ будет представлять собой либо единозначное число между 0 и 7 или букву ‘х’.

В операторе ‘if’ на следующей строке проверяется, если ‘ch’ больше или равно ‘0’ и меньше или равно ‘7’. Это выглядит немного странно сравнивать символы в эту сторону, но вполне приемлемо.

Каждый символ имеет уникальный номер, называемый ASCII кодом. Это означает, что когда мы сравниваем используя символы <= и >= на самом деле мы используем ASCII-значения. Если тест пройден, то мы приходим к следующей строке:

Сейчас мы выполняем арифметические действия над символами! Мы вычитаем цифру ‘0’ независимо от того что было введено. Итак, если вы набрали ‘0’, то ‘0’ – ‘0’ будет равно 0. Если вы ввели ‘7’, то ‘7’ – ‘0’ будет равно число 7, потому что это на самом деле ASCII-значения, которые используются в вычитание.

Поскольку мы знаем число светодиодов, которые мы хотим включить, надо просто установить бит в переменной ‘светодиоды’ и обновить регистр сдвига.

Следующие две строки отправляют обратно сообщение с подтверждением для серийного монитора.

Первая строка использует Serial.print, а не Serial.println. Разница между этими двумя функциями заключается в том, что Serial.print не переходит на новую строку после печати всего что есть в ее параметре. Мы используем эту функцию в первой строке, потому что мы печатаем сообщение состоящее из двух частях. Во-первых основной бит: “включение светодиодов», а затем количество светодиодов.

Количество светодиодов хранится в переменной типа ‘int’, а не в переменной строчного типа. Функция печати Serial.print может обрабатывать текстовые строки, заключенные в двойные кавычки, переменные типа ‘int’ и почти любой тип переменных.

После оператор ‘if’ обрабатывает случай, когда одиночный разряд был обработан, и есть второй оператор ‘if’ на случай если ‘ch’ содержит букву ‘х’.

Если это так, то он очищает все светодиоды и отправляет сообщение с подтверждением.

Что попробовать еще?

Мы отправляли символы управления светодиодам отдельно, нажимали “отправить” после каждого символа. Тем не менее, все будет работать так же хорошо, если вы пошлете все символы-команды в одну строку. Попробуйте ввести следующие команды в поле серийный монитор и нажмите кнопку ‘Отправить’:

x0246

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

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

Также, попробуйте несовпадение скоростей передачи данных — используйте функцию Serial.begin(9600) и выберите пункт 57600 в выпадающем меню серийного монитора. Смотрите, как все это выглядит? Все искажено? Вот и несоответствие. Если вы когда-нибудь увидите странные данные в последовательном мониторе, то трижды проверьте вашу скорость и убедитесь, что они совпадают!

Серийный монитор это отличный способ отладки шаблона, который плохо себя ведет. Иногда, когда шаблон ведет себя не так, как вы считаете он должен себя вести, размещения оператора Serial.println() в ключевых местах помогут вам увидеть, что происходит.

Простейший измеритель CO2 за 2000 рублей и полчаса: ammo1 — LiveJournal

Я разобрался с подключением датчиков углекислого газа с Aliexpress, нашёл примеры их использования и сделал простейшие измерители уровня CO2, которые очень просто повторить.

В большинстве самоделок используют датчик MH Z19B, но у него есть нехорошая особенность — если помещение не проветривается до состояния уличного воздуха каждый день, показания начинают «уплывать» (датчик автоматически калибруется каждый день и считает минимальный уровень CO2 в помещении за 400 ppm). Я заказал два более продвинутых датчика — Sensair S8 004-0-0053 (он обошёлся мне в $28.86, сейчас стоит $32.30) и Telaire T6703 (его я купил за $19.41, сейчас он стоит $28.35).

Я подключил датчики к Arduino Nano (его можно купить за $2.98), но можно использовать и другую плату Arduino. Для отображения значения CO2 используется дешёвый светодиодный экранчик TM1637 (он стоит $0.67). Для соединения удобно использовать готовые провода с коннекторами Dupont F-F (20 штук по 10 см стоят $0.87), для подключения сенсоров их можно разрезать пополам и подпаять.

Помимо индикации на экранчике, мои измерители передают данные в порт, поэтому их можно подключить к компьютеру, зайти в режим платформы Arduino «Монитор порта» (скорость 9600), наблюдать значения CO2 и использовать измеритель, как даталоггер (нужно просто скопировать данные из окошка монитора порта в Excel).

Кстати, экран можно не подключать и пользоваться только монитором порта.

Оба сенсора дают точные результаты (я сравнивал с хорошими измерителями уровня углекислого газа Даджет МТ8057s и AZ Instruments 7798 CO2 datalogger). Более дешёвый Telaire T6703 мне понравился даже больше — он выходит на правильные показания секунд за тридцать после включения и его результаты ближе к результатам дорогих приборов с двухлучевыми сенсорами.

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

Я планирую добавить к моим измерителям поддержку дешёвого цветного TFT-экрана (https://ammo1.livejournal.com/1191683.html) и трёх или четырёх реле для управления вентиляцией в зависимости от уровня углекислого газа в помещении. Как только сделаю это, напишу такую же инструкцию для повторения этих самоделок.

© 2021, Алексей Надёжин


Десять лет я каждый день пишу о технике, скидках, интересных местах и событиях. Читайте мой блог на сайте ammo1.ru, в ЖЖ, Дзен, МирТесен.
Мои проекты:
Lamptest.ru. Тестирую светодиодные лампы и помогаю разобраться, какие из них хорошие, а какие не очень.
Elerus.ru. Собираю информацию об отечественных электронных устройствах для личного использования и делюсь ей.
Вы можете связаться со мной в Телеграм @ammo1 и по почте [email protected]
Последовательный порт

— ссылка на Arduino

Описание

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

Доска Имя USB CDC Последовательные контакты Контакты Serial1 Последовательный 2 контакта Serial 3 контакта

Uno, Nano, Mini

0 (прием), 1 (TX)

Мега

0 (прием), 1 (TX)

19 (прием), 18 (передача)

17 (прием), 16 (передача)

15 (прием), 14 (TX)

Леонардо, Микро, Юнь

Серийный

0 (прием), 1 (TX)

Uno WiFi Rev.2

Подключено к USB

0 (прием), 1 (TX)

Подключено к NINA

Платы MKR

Серийный

13 (прием), 14 (TX)

Ноль

SerialUSB (только собственный порт USB)

Подключено к порту программирования

0 (прием), 1 (TX)

Срок погашения

SerialUSB (только собственный порт USB)

0 (прием), 1 (TX)

19 (прием), 18 (передача)

17 (прием), 16 (передача)

15 (прием), 14 (TX)

101

Серийный

0 (прием), 1 (TX)

На 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 — к земле вашего устройства.

Повышение производительности последовательного монитора Arduino

Недавно я работал над улучшением последовательного монитора Arduino.Здесь он работает с Teensyduino 1.48-beta1.

Раньше, если плата отправляла данные так быстро (как Teensy 4.0), у Java не хватало памяти, и IDE Arduino аварийно завершала работу.

Код USB

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

Deja Vu с 2014 года

Это не первый случай, когда Teensy вылетает из строя Arduino, слишком быстро отправляя сообщения на Serial Monitor.Еще в 2014 году такая же проблема существовала с Teensy 3.1. Serial.print () без задержки в Teensy 3.1 приведет к нехватке памяти Java и сбою Arduino IDE.

Arduino Due также может таким образом привести к сбою Arduino IDE. В октябре 2014 года разработчики Arduino пытались решить эту проблему, ограничив размер буферизованных данных, что помогло, но все же в Java в конечном итоге не хватало памяти и зависало.

6 декабря 2014 года мне, наконец, удалось обойти проблему достаточно хорошо, чтобы Arduino могла постоянно обрабатывать входящие данные USB на полной скорости (12 Мбит / с).Мое решение обошло ужасную медлительность добавления и удаления данных из компонента JTextArea путем сбора входящих данных в буфер и использования таймера для добавления данных с частотой всего 30 Гц. Он также ограничивал скорость удаления до одного раза на каждые 150 добавлений и удалял по количеству символов, а не по количеству строк. Через 4 дня разработчики Arduino адаптировали мое решение и объединили его с Arduino. Этот код есть во всех версиях Arduino, начиная с 1.6.0.

В то время я написал это объяснение деталей и разглагольствования о производительности Java.Тогда я написал: «Java — это ужасно». Теперь, оглядываясь назад, я понимаю, что приравнивал классы JTextArea и JTextComponent в Swing (и скрывающуюся за ними сложную инфраструктуру хранения данных) с Java в целом. Я также написал: «Если будет сделано значительно более быстрое оборудование… в будущем этот буфер может нуждаться в увеличении».

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

Что на самом деле использует так много памяти?

Я быстро обнаружил ужасную медлительность внутри JTextArea и JTextComponent, быстро увеличивающихся (или «уменьшающихся») с размером данных. Сохранение тех же 30 обновлений в секунду, но с большими данными, не сработает. Это зрелищно провалилось. Под нагрузкой печати Teensy 4.0 без задержки, Arduino IDE будет работать медленно в течение нескольких секунд, затем в Windows и Mac начнет генерировать исключения OutOfMemoryError и в конечном итоге заблокируется. В Linux он продолжал бы работать, но был бы непривычно медленным и потреблял много гигабайт памяти.Нехорошо.

Чтобы начать разбираться в проблеме, я запустил VisualVM, профилировщик Java. Это одна из программ, входящих в комплект Java SDK. Если у вас есть SDK и переменная среды JAVA_HOME (обычная установка для компиляции Arduino из исходного кода), ее можно запустить из командной строки с помощью «$ JAVA_HOME / bin / jvisualvm».

VisualVM очень прост в использовании. Каждая программа на основе Java, запущенная на вашем компьютере, отображается в группе «Локальные». Arduino отображается как «processing.app.Base (pid [номер])».Щелчок по нему подключает профилировщик к работающей Arduino IDE. Затем щелкнув вкладку «Профилировщик», вы увидите, какие классы Java используют столько памяти.

На этом снимке экрана показано использование памяти после нескольких секунд быстрой печати Teensy 4.0 на Serial Monitor. Хотя 100 мегабайт используются необработанными символьными данными, по-настоящему поразительным результатом является почти 2 миллиона живых экземпляров GapContent $ MarkData, GapContent $ UnfoPosRef, AbstractDocument $ LeafElement и GapContent $ StickyPosition.Ой!

Даже в Linux, с дополнительным бременем профилировщика VisualVM, Java быстро вылетает из-за напряжения печати Teensy 4.0 без задержек. Но профилировщик выполнил свою задачу, так что пролить свет на то, что занимает такой безумный объем памяти. GapContent явился виноватому.

Гибкий или раздутый, вопрос перспективы?

Java содержит довольно много хорошей документации. При поиске в Google всегда можно найти справочные материалы Oracle. Обычно при поиске можно найти много хороших руководств по Java и ответы на вопросы на таких сайтах, как Stack Overflow.Но из-за отсутствия не справочного материала, даже без ответов на вопросы (кроме людей, пытающихся использовать JTextArea или JTextComponent в качестве терминала или отображения файла журнала в реальном времени и сталкивающихся с теми же проблемами использования памяти), кажется, что эта часть Java редко пройденный путь. Это основная причина, по которой я трачу некоторое время на то, чтобы написать эту длинную статью в блоге, чтобы поделиться с вами тем, что я узнал на этом пути оптимизации.

Я потратил много времени на чтение справочных страниц по Java. Много времени…

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

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

Если вы сравните со страницей Oracle, вы увидите, что я добавил к этой диаграмме часть GapContent. Оказывается, класс Document фактически передает все хранилище данных на аутсорсинг GapContent.В какой-то момент я представил, что просто заменил GapContext чем-то более эффективным. Но, к сожалению, API GapContent основан на предположении, что размер данных увеличивается до любого произвольного размера. Я хотел заменить все хранилище кольцевым буфером FIFO фиксированного размера и избежать * любого * использования динамического выделения классов или больших данных в куче во время длительной обработки данных.

FifoDocument Class

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

Идея была проста. Поскольку мы добавляем новые строки только в конце и удаляем самые старые строки с начала, это должно быть просто, верно?

Элементы и события

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

Ссылка на документ — единственная другая страница (которую я нашел) с описанием элементов. Но он описывает только то, как они могут использоваться в общем виде. Это изображение структуры элемента совершенно неверно для варианта использования JTextComponent.

Оказывается, JTextComponent ожидает, что один элемент верхнего уровня будет контейнером для всего документа, у которого есть дочерние элементы, представляющие каждую строку. Ближе к концу объяснения на этой справочной странице документа есть мертвая ссылка на «см. The Swing Connection и, в частности, статью The Element Interface ».Все указывает на то, что Oracle удалил блог «Swing Connection» много лет назад, а мертвые ссылки автоматически перенаправляют на общую страницу Java.

К счастью, я нашел копию статьи «Интерфейс элемента» в архиве на академическом сайте. Эта статья важна для понимания того, какую структуру элементов фактически используют различные классы Java Document, если вы хотите создать свой собственный класс Document, чтобы заменить один из них. Для корпуса Arduino Serial Monitor это структура PlainDocument.

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

С этим дополнением и множеством тестов методом проб и ошибок, чтобы выяснить, какие функции на самом деле вызываются, * наконец * окно Serial Monitor начало отвечать на уведомления DocumentEvent и отображать текст.

Ранний эксперимент также показал, что FifoDocument может удалять данные, не получая никакого ввода от JTextArea.Просто отправив событие для уведомления JTextArea о том, что данные были удалены, Serial Monitor действительно обновится должным образом. Этот очень гибкий дизайн, основанный на событиях, который можно было рассматривать как раздувание, оказался очень полезным для реализации эффективного FIFO, который автоматически отбрасывает старые данные.

Позже эта способность Документа уведомлять графический интерфейс об изменениях (которые он не инициировал и не участвовал) оказалась даже более полезной для прямого добавления данных в FIFO.

Ошибки и безопасность потоков

Без помощи нескольких замечательных людей на форуме PJRC, особенно Тима (Defragster), FifoDocment, вероятно, никогда бы не достиг рабочего состояния. Интерфейс DocumentEvent включает в себя множество сложных требований, которые практически не задокументированы. Чтобы все сделать правильно, потребовалось много попыток. Defragster очень быстро обнаружил практически все ошибки.

Даже после исправления «легких» ошибок, острые проблемы с потоками остались. В итоге я синхронизировал почти все общедоступные методы FifoDocument.Поток, который добавляет новые данные в FifoDocument, также вызывается с помощью SwingUtilities.invokeAndWait (). Это менее чем оптимально. Возможно, позже станет возможным даже лучшее исполнение?

Прямая запись в память FIFO

Даже при всех этих оптимизациях Java все равно не хватало бы памяти на некоторых компьютерах Macintosh. Традиционная реализация монитора последовательного порта в Arduino делает несколько копий входящих данных, прежде чем они, наконец, будут сохранены в FifoDocument (или GapContent).

Во-первых, у класса Serial есть обработчик событий, который принимает входящие символы в буфер, который размещается в куче. Затем этот буфер преобразуется в строку и передается в функцию message (), которая является абстракцией, позволяющей различным классам получать данные. Затем содержимое этой String копируется в экземпляр StringBuffer, что является улучшением, которое я внес 5 лет назад. Затем с частотой 30 Гц StringBuffer копирует другие экземпляры String, которые передаются в JTextArea, который затем передает их в Document, где хранятся данные.

Я заменил все это копирование данных на путь прямо из поступающих символов в символьный буфер FifoDocument.

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

С этой окончательной оптимизацией даже старые Mac могли непрерывно получать данные от Teensy 4.0 без нехватки памяти или блокировки.

Однако класс Java InputStreamReader по-прежнему используется для преобразования необработанных байтов из формата UTF8 во внутреннюю обработку всех символов Java, а API событий документа по-прежнему использует временные выделения на основе кучи для некоторых функций.Это по-прежнему приводит к постепенному увеличению использования памяти Java, а затем к внезапному сокращению того, что выполняет сборка мусора Java. Но, по крайней мере, первоначальное тестирование выглядит так, как будто эти накладные расходы приемлемы.

Поведение автопрокрутки

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

Начиная с Arduino 1.6.0, Serial Monitor использовал целевой размер в 4 000 000 символов для своего буфера (половина размера maxChars в классе TextAreaFIFO).Но это проверяется только каждые 150 обновлений, что может происходить не быстрее, чем 30 Гц. Независимо от флажка автопрокрутки, если размер сохраненных данных превышает 4 000 000 символов, самые старые данные удаляются, поэтому остается только 4 000 000 символов.

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

Для FifoDocument я реализовал политику управления буфером, при которой буфер может заполняться до 60% емкости при прокрутке. При длительной прокрутке 40% буфера остается свободным.

Когда автоматическая прокрутка отключена, FifoDocument позволяет новым данным полностью заполнить буфер. Когда буфер заполняется на 100%, FifoDocument отбрасывает новые данные.Это может быть спорное решение. Идея состоит в том, чтобы позволить пользователю читать все, что уже находится в буфере, и все новое, что поступает, пока буфер не заполнится на 100%. Окно Serial Monitor не может перескакивать и становиться пустым, если во время чтения пользователем поступает слишком много новых данных. Но как только буфер фиксированного размера заполнится, больше ничего нельзя будет захватить, пока автопрокрутка не будет снова включена.

FifoDocument в настоящее время реализует буфер размером 10 000 000 символов и максимум 1 000 000 строк.Это позволяет собирать больше данных, но поведение не совсем такое же, как в текущих версиях Arduino, когда автопрокрутка отключена.

Производительность

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

Как ни странно, наиболее эффективной системой для этого использования является Microsoft Windows 10.

Кажется, что виртуальная машина Java выполняет код Java более эффективно в Windows, чем в Macintosh и Linux. Возможно, Oracle (или Sun) приложили больше усилий для оптимизации JRE для Windows?

На этом снимке экрана вы можете увидеть, как работает программа teensy_serialmon, также с низкой загрузкой ЦП.Эта вспомогательная программа общается с Teensy, используя встроенные в Windows функции WIN32, а затем передает данные в Java, используя потоки stdin и stdout. В Windows 10 как встроенный последовательный драйвер, так и облегченные анонимные каналы, используемые для stdin / stdout, кажутся очень эффективными при доступе с помощью собственных функций WIN32.

Хотя Linux не сильно отстает от Windows, к сожалению, Macintosh имеет значительные накладные расходы на ЦП для доступа к последовательным устройствам.

Этот снимок экрана был сделан на том же Macbook Air, что и тест Windows 10, описанный выше (изначально запущенный через двойную загрузку Bootcamp).

Однако драйверы USB для Macintosh позволяют Teensy 4.0 передавать данные примерно на 60% быстрее, чем драйверы в Windows и Linux. При запуске теста скорости печати через USB-порт Linux и Windows обычно поддерживают около 200 000 строк в секунду. Macintosh обычно обрабатывает чуть более 300 000 строк в секунду.

Эти различия, скорее всего, являются артефактом, вызванным неоптимальным кодом драйвера USB в Teensy 4.0, взаимодействующим с небольшими различиями в синхронизации в драйверах хоста USB в каждой системе.Я откладывал работу по оптимизации USB на Teensy 4.0 до тех пор, пока Serial Monitor не сможет обрабатывать входящую скорость без сбоев в Arduino IDE. Теперь, с этими улучшениями, я могу сосредоточить свои усилия на оптимизации стороны Teensy!

Вклад Arduino

Как всегда, я намерен внести вдохновленные Teensy улучшения в Arduino IDE обратно в проект Arduino. Несколько недель назад я обменялся несколькими электронными письмами с разработчиками Arduino об этой работе по оптимизации Serial Monitor, поэтому они знают о моих усилиях.Одна из причин написания этой пространной статьи состоит в том, чтобы задокументировать эту работу с точки зрения «высокого уровня», что невозможно из-за комментариев в коде, которые дают более подробную информацию.

Весь этот исходный код опубликован на Github. Это файлы:

  • FifoDocument.java — весь FIFO и код документа
  • TeensyPipeMonitor.java — «Подключаемый» последовательный монитор Teensy с использованием FifoDocument. Этот файл создает потоки слушателя, которые получают данные stdin непосредственно в буфер FifoDocument и анализируют stderr на предмет обновлений статуса.
  • FifoEvent.java — Информация о событии, которую FifoDocument отправляет в JTextComponent. Методы просто вызывают фактическую реализацию в FifoDocument.
  • FifoElementLine.java — Экземпляры Element, представляющие отдельные строки текста. Методы просто вызывают фактическую реализацию в FifoDocument.
  • FifoElementRoot.java — Элемент верхнего уровня, требуемый JTextComponent.
  • FifoPosition.java — Интерфейс Position, который JTextComponent требует от пользователей для выделения текста и копирования в буфер обмена.Позиции фактически реализуются с 64-битным полным историческим смещением, как объясняется в этом комментарии.

Эту работу можно рассматривать как два отдельных вклада, хотя их код теперь довольно тесно интегрирован. Другая работа могла бы быть названа «Подключаемый последовательный монитор», по концепции схожая с Pluggable Discovery. Концепция, как и в случае обнаружения портов, заключается в том, что плата может предоставлять программу, подобную «teensy_serialmon», которая осуществляет фактическую связь и делает ее доступной для IDE Arduino, используя потоки stdin и stdout.Teensy использует этот подход в бета-тестировании с начала 2017 года и выпущен в Teensyduino 1.42 июня 2018 года). Примерно в то время Arduino приняла часть открытия порта. Мы надеемся, что часть последовательного монитора станет официальной функцией Arduino в какой-то момент в будущем.

Неясно, может ли это улучшение производительности последовательного монитора когда-либо быть принято Arduino. Arduino анонсировала на Maker Faire и Arduino Day (март 2018 г.) среду разработки Arduino следующего поколения, которая больше не будет использовать Java.Как они относятся к слиянию такого большого изменения в существующий код Java, неясно, особенно когда Teensy 4.0 (вероятно) является единственной доступной сегодня платой, которая может передавать данные на таких скоростях, которые приводят к сбою существующей IDE.

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

Если кто-то позже заинтересован в этой оптимизации Serial Monitor, надеюсь, эта длинная статья и код на github помогут.

Arduino: Монитор последовательного порта — Робо Индия || Учебники || Изучите Arduino |

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

Программа:

/ *
 Arduino: последовательный монитор
 Эта программа печатает целочисленное значение переменной и строку на последовательном мониторе.

  http: // www.roboindia.com/tutorials/ 
* /

// объявляем целочисленную переменную
int value = 25;
// объявляем строковую переменную
Строковые данные = "мое_имя";
// процедура установки запускается один раз при нажатии кнопки сброса:
void setup () {
 // инициализируем последовательную связь со скоростью 9600 бит в секунду:
  Серийный . Начало (9600);

}

// процедура цикла запускается снова и снова бесконечно:
void loop () {
 // распечатать целочисленное значение:
  Серийный номер  .print ("Целочисленное значение:");
  Серийный  .println (значение);

  Серийный .печать ("Строка:");
  Серийный номер  .println (данные);
 задержка (1000); // задержка для замедления скорости печати
}

 

Как это работает:

Инициализируйте последовательный порт со скоростью 9600 бод.
Запомните вашу скорость передачи, т.е. 9600

 // инициализируем последовательную связь со скоростью 9600 бит в секунду:
  Серийный . Начало (9600);

 

Serial.print будет печататься в той же строке, тогда как Serial.println с «ln» в конце изменит строку после печати.
Все, что написано в двойных кавычках внутри скобок, будет напечатано как есть, например «Целочисленное значение:» ниже.
Если вы напишете имя переменной, то будет напечатано значение переменной. например значение.

  Серийный номер  .print ("Целочисленное значение:");
  Серийный  .println (значение);

 

Как открыть серийный монитор:

Нажмите кнопку последовательного монитора в правом верхнем углу Arduino IDE.

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

Практические задачи:

  1. Напечатайте свое имя и класс на серийном мониторе.
  2. Распечатайте номер 1-100 на последовательном мониторе, используя цикл for.

Альтернатива

Arduino Serial Monitor — Serial Port Monitor

Arduino Serial Monitor

Одна из лучших особенностей платформы заключается в том, что Arduino использует последовательную связь RS232 для взаимодействия с компьютерами.Это означает, что вы можете отправлять команды на плату Arduino с компьютера, который вы используете, и получать сообщения, отправленные Arduino через USB. Для этого необходимо открыть окно Arduino Serial Monitor, которое на самом деле является частью программного обеспечения платформы и находится на панели инструментов Arduino IDE. Утилита позволяет легко считывать серийный номер Arduino и контролировать поведение устройств, подключенных к плате.

В дополнение к отображению данных, созданных с помощью платы, Serial Monitor также может быть очень полезен при разработке и отладке скетча Arduino.С помощью функции Serial.print (), которую он предоставляет, вы можете отправлять последовательные выходные данные Arduino на свой компьютер и отображать их на мониторе ПК. Почему удобно разрабатывать скетчи Arduino? Что ж, бывает, что после загрузки кода на плату Arduino результат, который вы получаете, отличается от того, что вы ожидали. Например, светодиод не делает того, что вам нужно, например, мигает чаще, чем должен, или что-то в этом роде. Причина может заключаться в том, что переменная увеличивается и выключается, поэтому Arduino Serial Monitor кажется самым простым способом увидеть ее изменяющиеся значения.

Serial Port Monitor: альтернативное решение

Благодаря ограниченной функциональности, которую он предлагает, Arduino Serial Port Monitor может поддерживать базовую последовательную связь, но что-либо еще, например, регистрация данных или мониторинг COM-портов в реальном времени, не представляется возможным с помощью этой утилиты. Вот где на помощь приходит Serial Port Monitor от Eltima (SPM).

Теперь любой может открывать и закрывать COM-порты, изменять их параметры во время работы или передавать данные в различных форматах (например, строковом, двоичном, восьмеричном, десятичном или шестнадцатеричном) благодаря встроенному терминалу, доступному в версии PRO. SPM.Отправка двоичных данных блоками также не проблема, если вы используете программное обеспечение.

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

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

Вот некоторые другие основные возможности SPM:

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

  • Одновременный мониторинг нескольких портов
  • Пользователи, которые хотят отслеживать активность нескольких COM-портов одновременно, могут сделать это с помощью SPM.Сбор данных основан на методе «первым пришел — первым ушел».

  • Режимы фильтрации и визуализации данных
  • Опция фильтрации, предлагаемая SPM, предназначена для упрощения анализа данных, предоставляя вам возможность видеть только релевантные сообщения. Кроме того, данные могут отображаться в разных представлениях: таблица, строка, дамп и терминал.

Обладая множеством выдающихся функциональных возможностей, но при этом дружественный и простой в использовании Serial Monitor Eltima для Arduino, дает возможность контролировать и анализировать последовательные данные в пределах досягаемости любого пользователя, независимо от его навыков программирования.Это делает программное обеспечение лучшим решением для мониторинга последовательной связи, доступным на сегодняшний день.

Gravity: датчик пульсометра для Arduino

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

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

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

Гравитационный интерфейс адаптирован, чтобы позволить plug & play облегчить барьер использования. Экран датчика ввода-вывода — лучший вариант для подключения этого датчика частоты сердечных сокращений к вашему Arduino или другим микроконтроллерам. Кроме того, этот датчик также может быть совместим с Raspberry Pi, Intel Edison, Joule и Curie посредством 3.Входное напряжение 3 В.

Система мониторинга сердечного ритма на основе Интернета вещей — это очень простой проект по отправке частоты пульса в приложение Blynk и его мониторингу из любого места.

ПРИМЕЧАНИЕ:
1. Этот продукт НЕ является профессиональным медицинским устройством и не должен использоваться для диагностики или лечения заболеваний.
2. Этот датчик предназначен для работы, когда пользователь не движется. Если использовать во время движения, это даст неточные результаты.

Руководство по выбору датчика частоты сердечных сокращений Gravity

Имя Гравитация : Аналоговый датчик сердечного ритма ЭКГ Гравитация : Аналоговый / цифровой датчик сердечного ритма PPG
SKU SEN0213 SEN0203
IC / модуль AD8232 SON1303
Рабочее напряжение (VCC) 3.3 ~ 6 В 3,3 ~ 6 В
Выход

Гравитация: аналог

(Цифровой 0 ~ 3,3 В)

Гравитация: аналоговый / цифровой

(Аналоговый 0 ~ VCC)

(Цифровой 0 ~ VCC)

Принцип измерения ЭКГ (электрокардиограмма) PPG (Photo Plethysmo Graphy)
Средняя мощность

Измерение

(Печатная плата)

35 * 22 мм 28 * 24 мм
Функции

1.Метод ЭКГ, точный и стабильный

2. три электрода

3.3.3 В / 5 В совместимый

1. метод PPG, удобный и быстрый

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

3.3.3 В / 5 В совместимый

Монитор загрузки Arduino | Подключение

Большинство Arduino запрограммированы и взаимодействуют с одним и тем же последовательным портом. Это может вызвать конфликты, если вы хотите загрузить новую программу, в то время как MegunoLink, скажем, занят графиком данных, которые он получает с того же порта.Монитор загрузки Arduino от MegunoLink помогает совместно использовать этот порт между MegunoLink и Arduino IDE.

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

Установка монитора загрузки Arduino

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

Использование монитора загрузки

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

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

Как работает монитор загрузки Arduino?

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

Когда вы установили монитор загрузки MegunoLink, мы переименовали AVRDude и удалили программу монитора на его место.

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

Arduino Upload Monitor 2015-11-072020-09-18 https://www.megunolink.com/wp-content/uploads/2015/10/img-megunolink-logo.pngMegunoLink https://www.megunolink.com/wp-content/uploads/2015/10/img-megunolink-logo.pngmegunolink.com/wp-content/uploads/2015/10/img-megunolink-logo.png200px200px

6 дисплеев для вывода данных с вашего Arduino

Итак, у вас есть Arduino. Вы узнали некоторые основы, возможно, вы следовали руководству для начинающих, чтобы начать работу. Что дальше?

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

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

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

1.Жидкокристаллический дисплей

Жидкокристаллический дисплей (ЖКД) — это самый распространенный дисплей, который можно найти как в проектах DIY, так и в бытовой технике.Это неудивительно, поскольку они просты в эксплуатации, маломощны и невероятно дешевы.

Этот тип дисплея может различаться по дизайну.Некоторые из них больше, с большим количеством пробелов и строк, некоторые с подсветкой. Большинство подключается непосредственно к плате через 8 или 12 соединений с выводами Arduino, что делает их несовместимыми с платами с меньшим количеством выводов. В этом случае купите экран с адаптером I2C, позволяющим управлять только с 4 контактов.

Доступно всего за несколько долларов (или всего за 1 доллар.95 на Aliexpress с включенным адаптером I2C), эти простые дисплеи можно использовать для обратной связи в реальном времени с любым проектом.

Экраны могут содержать большое количество предустановленных символов, которые охватывают большинство случаев использования на разных языках.Управляйте своим ЖК-дисплеем с помощью библиотеки жидких кристаллов, предоставляемой Arduino. Методы display () и noDisplay () записывают данные на ЖК-дисплей, как показано в официальном руководстве на веб-сайте Arduino.

Примечание. Если вы используете адаптер I2C для ЖК-экрана, вам потребуется вместо этого использовать библиотеку LiquidCrystal_I2C.

Если вы предпочитаете видеоуроки, Circuit Basics отлично подойдет для настройки и использования ЖК-дисплея 16×2:

2.Семисегментные дисплеи

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

Если вы раньше не сталкивались с этими удобными маленькими дисплеями, наша игра Buzz Wire использует их для отображения статуса игры:

Эти простые платы состоят из 7 светодиодов (8, если вы включаете точку) и работают так же, как обычные светодиоды с общим анодным или катодным подключением.Это позволяет им использовать одно соединение с V + (или GND для общего катода) и управлять ими с контактов вашего Arduino. Комбинируя эти контакты в коде, вы можете создавать числа и несколько букв, а также создавать более абстрактные рисунки — все, что вы можете придумать, используя доступные сегменты!

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

В качестве видеогида Кристиан Бласол посвятил эпизод из своей серии Anything Arduino семисегментным дисплеям:

3.5110 Дисплей

Следующим в нашем списке идет дисплей 5110, также известный как дисплей Nokia из-за его широкого использования в любимой и почти неразрушимой Nokia 3310.

Эти крошечные ЖК-экраны монохромны и имеют размер экрана 84 x 48 пикселей, но пусть это вас не вводит в заблуждение.Эти дисплеи стоят менее 2 долларов на Aliexpress, они невероятно дешевы и обычно поставляются с подсветкой в ​​стандартной комплектации.

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

У Sparkfun есть подробное руководство по использованию этих маленьких ЖК-дисплеев, а для быстрого знакомства с 5110 посмотрите это видео из MKMe Lab:

4.OLED-дисплеи

Для повышения разрешения и функциональности OLED-дисплей может быть тем, что вы ищете.На первый взгляд эти экраны похожи на экраны 5110, но представляют собой существенное обновление. Стандартные 0,96-дюймовые экраны имеют монохромный размер 128 x 64 и стандартно оснащены подсветкой.

Они подключаются к вашему Arduino с помощью I2C, а это означает, что наряду с выводами V + и GND для связи с экраном требуются только два дополнительных вывода.Благодаря наличию различных размеров и полноцветных вариантов эти дисплеи невероятно универсальны.

Для проекта, который поможет вам начать работу с OLED-дисплеями, наша сборка Electronic D20 научит вас всему, что вам нужно знать, и в итоге вы получите потрясающие цифровые игральные кости для игровых сессий!

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

5.ЖК-экран TFT

Жидкокристаллические дисплеи (TFT LCD) на тонкопленочных транзисторах — это во многих отношениях еще один шаг вперед в качестве, когда речь идет о вариантах добавления экрана к вашему Arduino.Доступные с сенсорным экраном или без него, они также добавляют возможность загружать файлы растровых изображений из встроенного слота для карт памяти micro SD.

У Arduino есть официальное руководство по настройке несенсорного экрана TFT LCD.В виде видеоурока, который научит вас основам настройки версии с сенсорным экраном, YouTuber education8s.tv предлагает вам следующие материалы:

Поскольку базовая версия этих экранов стоит менее 4 долларов, а версии для сенсорных экранов — менее 10 долларов [Broken Link Removed], эти дисплеи являются еще одним отличным выбором, когда вам нужен красивый дисплей для вашего проекта.

6.Дисплеи для электронной бумаги

Ищете что-то немного другое? Экран электронной бумаги (или E-ink в зависимости от того, кого вы спрашиваете) может подойти вам.Эти экраны отличаются от других, обеспечивая более естественное чтение. Неудивительно, что эта технология является краеугольным камнем почти всех доступных электронных книг.

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

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

Эти высокотехнологичные дисплеи действительно стоят дороже — 4.3-дюймовый экран Waveshare стоит более 50 долларов. Чтобы получить полное изложение того, как подключить и запрограммировать эти дисплеи, YouTuber education8s.tv снова здесь, чтобы помочь:

Экранные мечты

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

Теперь, когда у вас есть идея, почему бы не включить экран в свой умный дом своими руками? Если вам больше нравятся ретро-игры, почему бы не создать свою собственную крошечную версию классического ретро-понга на Arduino?

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

Дайте нам знать в разделе комментариев ниже!

Как скрыть свой реальный адрес электронной почты

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

Читать далее

Об авторе

Ян Бакли
(Опубликовано 212 статей)

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

Более
От Яна Бакли

Подпишитесь на нашу рассылку новостей

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

Еще один шаг…!

Пожалуйста, подтвердите свой адрес электронной почты в письме, которое мы вам только что отправили.

.