Serial readstring. Последовательная связь UART в Arduino: полное руководство

alexxlabРазное
Что такое UART в Arduino. Как настроить и использовать UART для обмена данными. Какие методы предоставляет библиотека Serial. Как работать с последовательным монитором и плоттером.

Содержание

Основы последовательной связи UART в Arduino

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

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

Ключевые особенности UART:

  • Асинхронная передача данных (не требует общего тактового сигнала)
  • Полнодуплексная связь (одновременная передача и прием)
  • Настраиваемая скорость передачи данных
  • Поддержка различных форматов кадров данных

Настройка последовательной связи в Arduino

Для использования UART в Arduino необходимо выполнить несколько шагов по настройке:


1. Инициализация последовательного порта

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


void setup() {
  Serial.begin(9600); // Установка скорости 9600 бод
}

Стандартные скорости передачи данных включают 9600, 19200, 57600 и 115200 бод. Выбирайте скорость в зависимости от требований вашего проекта и возможностей подключаемых устройств.

2. Настройка формата кадра данных

По умолчанию Arduino использует формат кадра 8N1 (8 битов данных, без бита четности, 1 стоповый бит). При необходимости можно изменить эту конфигурацию:


Serial.begin(9600, SERIAL_8E1); // 8 битов данных, бит четности, 1 стоповый бит

Передача данных через UART

После настройки UART вы можете начать отправлять данные. Arduino предоставляет несколько методов для этого:

Serial.write()

Метод Serial.write() используется для отправки двоичных данных:


Serial.write(65); // Отправка байта со значением 65 (ASCII код 'A')
Serial.write("Hello"); // Отправка строки байтов

Serial.print() и Serial.println()

Эти методы удобны для отправки форматированного текста:



Serial.print("Температура: ");
Serial.println(25.5);

Serial.println() автоматически добавляет символы возврата каретки и новой строки в конце.

Прием данных через UART

Для приема данных через UART используются следующие методы:

Serial.available()

Этот метод возвращает количество байтов, доступных для чтения в буфере приема:


if (Serial.available() >
 
 0) {
  // Есть данные для чтения
}

Serial.read()

Метод Serial.read() считывает один байт из буфера приема:


if (Serial.available() > 0) {
  char incomingByte = Serial.read();
  // Обработка полученного байта
}

Serial.readString()

Для чтения целой строки можно использовать метод Serial.readString():


if (Serial.available() > 0) {
  String incomingString = Serial.readString();
  // Обработка полученной строки
}

Работа с последовательным монитором Arduino IDE

Последовательный монитор в Arduino IDE — это мощный инструмент для отладки и взаимодействия с вашим скетчем. Вот как его использовать:

Открытие последовательного монитора

Чтобы открыть последовательный монитор:


  1. Подключите Arduino к компьютеру
  2. Загрузите скетч, использующий последовательную связь
  3. Нажмите кнопку «Последовательный монитор» в верхнем правом углу IDE или выберите «Инструменты» >
    «Последовательный монитор»

Настройка последовательного монитора

Убедитесь, что скорость передачи данных в мониторе соответствует скорости, установленной в вашем скетче (например, 9600 бод). Это можно настроить в выпадающем меню в нижней части окна монитора.

Отправка данных

Для отправки данных на Arduino, введите текст в поле ввода в верхней части окна и нажмите «Отправить» или клавишу Enter.

Прием данных

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

Использование последовательного плоттера

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

Открытие последовательного плоттера

Чтобы открыть плоттер, выберите «Инструменты» > «Последовательный плоттер» в Arduino IDE.


Отправка данных на плоттер

Для отображения данных на плоттере, отправляйте числовые значения через Serial.println():


void loop() {
  int sensorValue = analogRead(A0);
  Serial.println(sensorValue);
  delay(100);
}

Этот код будет отображать график значений с аналогового входа A0.

Отображение нескольких переменных

Вы можете отображать несколько переменных на одном графике, разделяя их запятыми:


void loop() {
  int sensor1 = analogRead(A0);
  int sensor2 = analogRead(A1);
  Serial.print(sensor1);
  Serial.print(",");
  Serial.println(sensor2);
  delay(100);
}

Расширенные возможности UART в Arduino

UART в Arduino предоставляет ряд дополнительных возможностей для более гибкой работы с последовательными данными:

Установка таймаута

Метод Serial.setTimeout() позволяет установить максимальное время ожидания для операций чтения:


Serial.setTimeout(1000); // Установка таймаута в 1 секунду

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

Метод Serial.find() ищет указанную последовательность байтов во входящих данных:



if (Serial.find("START")) {
  // Найдено слово "START"
}

Парсинг числовых данных

Методы Serial.parseInt() и Serial.parseFloat() позволяют извлекать числовые значения из входящего потока данных:


int value = Serial.parseInt();
float floatValue = Serial.parseFloat();

Применение UART в проектах Arduino

UART находит широкое применение в различных проектах Arduino. Вот несколько примеров:

Взаимодействие с датчиками

Многие цифровые датчики используют UART для передачи данных. Например, GPS-модули часто отправляют данные о местоположении через UART.

Беспроводная связь

Модули Bluetooth и WiFi часто используют UART для обмена данными с Arduino, позволяя создавать беспроводные проекты.

Отладка и мониторинг

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

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

Через UART можно отправлять команды с компьютера на Arduino, позволяя дистанционно управлять различными устройствами и процессами.

Заключение

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


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


Кодирование, совместимое с Arduino 16: Последовательная связь UART

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

В последнем уроке мы считывали пакет данных, опрашивая один из цифровых выводов ввода-вывода Arduino, и обнаруживали биты данных, измеряя ширину импульса цифрового сигнала. Однако это не типичный способ вывода данных цифровых датчиков. Большинство цифровых датчиков используют стандартные протоколы передачи данных, такие как UART, SPI или I2C, для передачи данных контроллеру/компьютеру.

Протокол универсального асинхронного приемника/передатчика (UART) является наиболее распространенным протоколом передачи данных, доступным практически на всех встроенных устройствах. Большинство встроенных устройств используют UART для обмена данными консоли . В качестве альтернативы они могут использовать I2C для той же цели. Это просто зависит от того, предназначено ли устройство быть одноранговым устройством или подчиненным компьютерной системе.

Цифровые датчики ничем не отличаются. Почти все цифровые датчики, которые взаимодействуют с контроллером/встроенным компьютером в качестве однорангового устройства, используют UART. Это особенно верно для тех датчиков и устройств, которые предполагают двунаправленную передачу данных с компьютерной системой. Однако большинство датчиков предназначены только для передачи данных на контроллер/компьютерную систему в качестве ведомого устройства и могут использовать последовательные протоколы, такие как I2C или SPI, для передачи данных датчика. (Узнайте больше о основы последовательной связи  из этого руководства по Raspberry Pi.)

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

А вот softwareSerial не справляется с аппаратным UART. Итак, давайте обсудим функцию UART в Arduino.

Что такое UART?
Универсальный асинхронный приемник/передатчик (UART) представляет собой схему, которая передает данные точка-точка (полудуплекс или полный дуплекс) по протоколу UART. Схема доступна в виде автономных ИС и обычно интегрирована в периферийные устройства микроконтроллеров и встроенных компьютеров.

Протокол UART
Узнать о протоколе UART можно здесь .

UART/USART в Arduino(s)
Последовательные порты используются для обмена данными с компьютерами или другими устройствами. Все платы Arduino имеют один или несколько последовательных портов, которые могут быть UART или USART.

В этой таблице перечислены порты UART на разных платах Arduino:

Уровень напряжения TTL UART Arduino может составлять 5 или 3,3 В, в зависимости от

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

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

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

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

Это особенно важно для интерфейсов RS-232, поскольку они передают данные по протоколу UART. Эти интерфейсы можно легко взломать, чтобы открыть контакты Rxd и Txd. На этих выводах используются положительные и отрицательные напряжения в диапазоне от -15 В до 15 В для логических битов. Если контакты Rxd и Txd порта RS-232 напрямую подключены к порту TTL UART, порт TTL будет разрушен.

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

При подключении к другим последовательным портам (если таковые имеются, как на платах Mega и Due) эти порты могут быть подключены к компьютеру только через последовательную плату USB. Другие последовательные порты не подключены к USB Arduino.

UART через контакты GPIO
Встроенный UART Arduino подключается к контактам GPIO. Последовательный порт имеет два канала:

  • Txd для передачи последовательных данных
  • Rxd для получения последовательных данных по протоколу UART

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

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

Данные передаются в виде пакетов в стандарте USB, а UART передает данные в виде символов. Нет ничего похожего на скорость передачи данных в USB-коммуникациях.

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

UART/USART Arduino также подключен к этому дополнительному контроллеру, который преобразует данные UART в USB. Когда Arduino подключен к компьютеру через USB-кабель, он действует как устройство CDC/ACM через USB. Это похоже на последовательную связь с ПК. В некоторых платах Arduino обмен данными по USB не обрабатывается дополнительным контроллером, а управляется основным встроенным контроллером. С этими платами Arduino идентифицирует себя как ведомое устройство USB CDC.

Когда Arduino подключен к Mac, он использует имя устройства, такое как /dev/tty.wchusbserial*, где звездочка («*») может быть любым числом. В системах Linux он может отображаться вместе с именем устройства, например, /dev/ttyACM*. где звездочка — любое число. В Windows он может отображаться в виде имени порта, например COM*, где звездочка — это любое число.

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

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

Serial.begin(скорость)
или
Serial.begin(скорость, конфигурация)

Скорость передачи данных может быть любой стандартной скоростью передачи данных с максимальным значением 115200 бит/с. Конфигурация UART по умолчанию — 8N1.

Конфигурация может быть установлена ​​на эти аргументы:
Serial_5n1, serial_6n1, serial_7n1, serial_8n1 (по умолчанию), serial_5n2, serial_6n2, serial_7n2, serial_8n2, serial_5e1, serial_6e1, serial_8, serial_8, serial_8, serial_8, serial_8. SERIAL_6O1, SERIAL_7O1, SERIAL_8O1, SERIAL_5O2, SERIAL_6O2, SERIAL_7O2 и SERIAL_8O2.

В платах Arduino, которые идентифицируются как подчиненные USB CDC, такие как Leonardo, Serial.begin() не имеет значения. Такие платы могут использовать любую конфигурацию и скорость передачи для UART. Исходный код этого метода доступен в файле Arduino/hardware/arduino/avr/cores/arduino/HardwareSerial.cpp.

Метод Serial.begin() имеет следующий исходный код:

if(Serial) или if(SerialUSB) — эти операторы if можно использовать, чтобы узнать, готов ли последовательный порт. Для портов CDC, отличных от USB, используется if(Serial). Для портов USB-CDC условием проверки является if(SerialUSB). Если порт готов, условие вернет True. Если порт не существует — скажем, на конкретной плате Arduino нет порта USB CDC или он есть, но не готов — условие вернет False.

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

Serial.availableForWrite()

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

Исходный код этого метода:

Serial.write()   – используется для отправки двоичных данных на последовательный порт. Данные отправляются в виде байта или серии байтов. Этот метод имеет следующий синтаксис:

Serial.write(val)
или
Serial.write(str)
или
Serial.write(buf, len)

Для этого метода требуется значение (один байт) или строка (серия байт) в качестве параметра. Если массив передается в качестве аргумента (buf), длина массива (len) также должна передаваться в качестве аргумента.

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

Исходный код этого метода:

Serial.print() — используется для отправки символов ASCII на последовательный порт. Этой функции требуется значение или строка в качестве аргумента. Он также принимает BIN, OCT, DEC или HEX в качестве необязательных аргументов для указания базового формата (двоичного, восьмеричного, десятичного или шестнадцатеричного) символов. Если переданное значение является числом с плавающей запятой, количество десятичных разрядов может быть передано в качестве аргумента. Эта функция имеет следующий синтаксис:

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

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

Serial.println() – этот метод аналогичен print(), за исключением отправляемых символов ASCII, но с последующим возвратом каретки (‘\r’) и символом новой строки (‘\n’). Он имеет такой синтаксис:

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

Serial.available() — проверяет, доступны ли последовательные данные для чтения из последовательного порта. Это данные, которые уже поступили и сохранены в 64-байтном буфере последовательного приема. Этот метод наследуется от служебного класса Stream. Она имеет следующий синтаксис:

Serial.available()

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

Исходный код этого метода:

Serial.read() — используется для чтения входящих данных с последовательного порта. Он имеет следующий синтаксис:

Serial. read()

Он возвращает первый байт входящих последовательных данных или -1, если данных нет.

Исходный код этой функции:

Serial.peek() – этот метод возвращает следующий байт (символ) входящих последовательных данных, не удаляя их из внутреннего последовательного буфера. Он имеет такой синтаксис:

Serial.peek()

Этот метод имеет следующий исходный код:

Serial.readBytes() – считывает символы из последовательного порта в буфер. Он завершается, если определенная длина была прочитана или есть тайм-аут. Он имеет следующий синтаксис:

Serial.readBytes(buffer, length)

Serial.readBytesUntil() – считывает символы из последовательного буфера в массив. Он завершается, если была прочитана определенная длина, если есть тайм-аут или если обнаружен символ завершения. Сам терминатор не возвращается в буфер. Этот метод имеет следующий синтаксис:

Serial.readBytesUntil(символ окончания, буфер, длина)

Serial.readString() – считывает символы из последовательного буфера в строку. Он завершается, если есть тайм-аут. Он имеет следующий синтаксис:

Serial.readString()

Serial.readStringUntil() – считывает символы из последовательного буфера в строку. Он завершается, если есть тайм-аут или если обнаружен символ завершения. Он имеет такой синтаксис:

Serial.readStringUntil(терминатор)

Serial.setTimeout() – устанавливает максимальное количество миллисекунд для ожидания последовательных данных. Тайм-аут по умолчанию составляет 1000 миллисекунд. Его используют следующие методы: Serial.find(), Serial.findUntil(), Serial.parseInt(), Serial.parseFloat(), Serial. readBytes(), Serial.readBytesUntil(), Serial.readString(), Serial. читатьСтрокуУнтил(). Он имеет следующий синтаксис:

Serial.setTimeout(время)

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

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

Serial.findUntil() – считывает данные из последовательного буфера заданной длины или найдена терминаторная строка. Он возвращает true, если целевая строка найдена, и false, если истекло время ожидания. Он имеет такой синтаксис:

Serial.findUntil(целевая строка для поиска, строка терминатора)

Serial.flush() – заставляет последовательный порт ожидать завершения передачи исходящих последовательных данных. Он имеет следующий синтаксис:

Serial.flush()

Исходный код этого метода:

Serial.readBytes()   – считывает символы из последовательного порта в буфер. Он завершается, если определенная длина была прочитана или есть тайм-аут. Он имеет такой синтаксис:

Serial.readBytes(buffer, length)

Serial.readBytesUntil()   –  считывает символы из последовательного буфера в массив. Он завершается, если была прочитана определенная длина, если есть тайм-аут или если обнаружен символ завершения. Сам терминатор не возвращается в буфер. Этот метод имеет следующий синтаксис:

Serial.readBytesUntil(знак конца, буфер, длина)

Serial.readString()   –  считывает символы из последовательного буфера в строку. Он завершается, если есть тайм-аут. Он имеет следующий синтаксис:

Serial. readString()

Serial.readStringUntil()   – считывает символы из последовательного буфера в строку. Он завершается, если есть тайм-аут или если обнаружен символ завершения. Он имеет следующий синтаксис:

Serial.readStringUntil(терминатор)

Serial.setTimeout()   –  устанавливает максимальное количество миллисекунд для ожидания последовательных данных. Тайм-аут по умолчанию составляет 1000 миллисекунд. Его используют следующие методы: Serial.find(), Serial.findUntil(), Serial.parseInt(), Serial.parseFloat(), Serial.readBytes(), Serial.readBytesUntil(), Serial.readString(), Serial. читатьСтрокуУнтил(). Он имеет следующий синтаксис:

Serial.setTimeout(time)

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

Serial.find(target)

Serial.parseFloat()   –  возвращает первое допустимое число с плавающей запятой из буфера Serial. Эта функция завершается после обнаружения первого символа, не являющегося числом с плавающей запятой, или по истечении времени ожидания. Он имеет следующий синтаксис:

Serial.parseFloat() 
или
смотреть вперед в потоке для числа с плавающей запятой. Этот аргумент может принимать значения: SKIP_ALL, SKIP_NONE и SKIP_WHITESPACE. Аргумент «игнорировать» используется для пропуска указанного символа в поиске.

Serial.parseInt()   –  этот метод аналогичен Serial.parseFloat(). Он возвращает первое допустимое целое число из последовательного буфера. Он также завершается, если истекает время ожидания. Он имеет этот синтаксис:

Serial.parseint ()
или
Serial. parseint (Lookahead)
или
Serial.parseint (Lookahead, Ignore)

Serial.end () –8

. отключает последовательную связь, позволяя использовать выводы RX и TX для общего ввода и вывода. Выводы включаются для последовательной связи только при вызове Serial.begin(). Он имеет такой синтаксис:

Serial.end()

Исходный код:

Взаимодействие Arduino с компьютером
Самый простой способ соединить Arduino с компьютером — использовать кабель USB-to-USB. Если к компьютеру подключаются другие последовательные порты, необходимо использовать плату USB-to-serial.

Последовательный монитор
Arduino IDE имеет встроенный последовательный монитор, который можно использовать для получения и отправки последовательных данных через USB-порты настольного компьютера. Последовательный монитор можно открыть, выбрав Tools->Serial Monitor.

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

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

Передача данных на компьютер
Результат

Получение данных с компьютера

Результат

Получающие строки данных от компьютера

. используется для визуализации полученных данных графически. Его можно открыть, выбрав Tools->Serial Plotter.

Нанесение одной переменной на последовательный плоттер
Чтобы отобразить одну переменную, скетч Arduino должен вывести одну переменную в последовательный порт в функции loop().

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

Результат Плоттер, между двумя функциями печати должен быть напечатан пробел.

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

Результат

В следующем уроке мы узнаем о SoftwareSerial в Arduino.

Рубрики: Arduino
С тегами: Arduino
 

Практическое руководство. Получение строк из последовательных портов — Visual Basic

Редактировать

Твиттер LinkedIn Фейсбук Электронная почта

  • Статья
  • 2 минуты на чтение

В этом разделе описывается, как использовать My.Computer.Ports для получения строк от последовательных портов компьютера в Visual Basic.

Для получения строк с последовательного порта

  1. Инициализировать возвращаемую строку.

     Dim returnStr As String = ""

  2. Определите, какой последовательный порт должен предоставлять строки. В этом примере предполагается, что это COM1 .

  3. Используйте метод My.Computer.Ports.OpenSerialPort для получения ссылки на порт. Дополнительные сведения см. в разделе OpenSerialPort.

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

     Dim com1 As IO. Ports.SerialPort = Ничего
Пытаться
    com1 = Мой.Компьютер.Порты.OpenSerialPort("COM1")
    com1.ReadTimeout = 10000
Поймать ex As TimeoutException
    returnStr = "Ошибка: истекло время чтения последовательного порта."
Окончательно
    Если com1 не является ничем, тогда com1.Close()
Завершить попытку

  4. Создайте цикл Выполните для чтения строк текста до тех пор, пока не закончатся доступные строки.

     Делать
Петля

  5. Используйте метод ReadLine() для чтения следующей доступной строки текста из последовательного порта.

     Dim Incoming As String = com1.ReadLine()

  6. Используйте оператор If , чтобы определить, возвращает ли метод ReadLine() Ничего (что означает, что больше нет доступного текста). Если он возвращает Nothing , выходим из цикла Do .

     Если входящие ничего, то
    Выход Сделать
Конец, если

  7. Добавьте блок Else в оператор If для обработки случая, когда строка действительно прочитана. Блок добавляет строку из последовательного порта к возвращаемой строке.

     Остальное
    returnStr &= Входящие и vbCrLf

  8. Вернуть строку.

     Возврат returnStr

Пример 

 Функция ReceiveSerialData() как строка
    ' Получение строк из последовательного порта.
    Dim returnStr As String = ""
    Dim com1 As IO.Ports.SerialPort = Ничего
    Пытаться
        com1 = Мой.Компьютер.Порты.OpenSerialPort("COM1")
        com1.ReadTimeout = 10000
        Делать
            Dim Incoming As String = com1.ReadLine()
            Если входящий ничего тогда
                Выход Сделать
            Еще
                returnStr &= Входящие и vbCrLf
            Конец, если
        Петля
    Поймать ex As TimeoutException
        returnStr = "Ошибка: истекло время чтения последовательного порта."
    Окончательно
        Если com1 не является ничем, тогда com1. Close()
    Завершить попытку
    Возврат
Конечная функция

Этот пример кода также доступен в виде фрагмента кода IntelliSense. В средстве выбора фрагментов кода он находится в Connectivity and Networking . Дополнительные сведения см. в разделе Фрагменты кода.

Компиляция кода

В этом примере предполагается, что компьютер использует COM1 .

Надежное программирование

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

В этом примере используется блок Try...Catch...Finally , чтобы убедиться, что приложение закрывает порт и перехватывает любые исключения тайм-аута. Дополнительные сведения см. в разделе Оператор Try…Catch…Finally.

См. также

  • Порты
  • Система.

Похожие записи

21.11.2024 0

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

19.11.2024 0

Новорожденный какает слизью: причины появления слизи в кале грудничка

19.11.2024 0

Гемангиома у новорожденных: причины, виды, лечение и профилактика

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

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