Serial available: Serial.available() | Arduino Reference

недействительная установка () {
  Серийный номер  .begin(9600); // USB всегда 12 или 480 Мбит/сек
}
недействительный цикл () {
  Серийный номер  .println("Hello World...");
 задержка(1000); // не печатайте слишком быстро!
}
 

На самом деле Teensy не станет серийным устройством, пока ваш скетч не будет запущен. поэтому вы должны выбрать последовательный порт (меню Tools -> Serial Port) после начинается ваш эскиз.

Стандартные последовательные функции

Последовательный.начало()

Ввод скорости передачи игнорируется и используется только для совместимости с Arduino. Последовательная связь USB всегда происходит на полной скорости USB. Однако, см. функцию baud() ниже.

Serial.begin() может ждать до 2,5 секунд для последовательной связи USB быть готовым. Для быстрого запуска программы просто не используйте этот ненужная функция. Его единственная цель — совместимость с программы, написанные для Arduino. Задержка предназначена для программ которые не проверяют логическое значение Serial.

(логический) Серийный номер

недействительная установка () {
  Серийный номер  .println("Это может быть отправлено до того, как ваш ПК сможет получить");
 пока (!  серийный номер ) {
 // ждем, пока Arduino Serial Monitor будет готов
 }
   Serial  .println("Эта строка обязательно появится в последовательном мониторе");
}
 

В качестве альтернативы ожидание может быть выполнено с тайм-аутом.

 в то время как (!  серийный номер  && миллис () < 15000) {
 // ждем до 15 секунд для серийного монитора Arduino
 }
 

Serial.print() и Serial.println()

 // Serial.print() может печатать множество разных типов
 целое число = 1234;
  Серийный номер  . println("строка"); // нить
  Серийный номер  .println('a'); // один символ
  Серийный номер  .println(номер); // число (база 10, если 16 или 32 бита)
 
  Серийный номер  .println(номер, DEC); // число, основание 10 (по умолчанию)
  Серийный номер  .println(номер, HEX); // число, основание 16/шестнадцатеричное
  Серийный номер  .println(номер, OCT); // число, основание 8/восьмеричное
  Серийный номер  .println(номер, БИН); // число, основание 2/двоичное
  Серийный номер  .println(3.14); // число с плавающей запятой, 2 цифры
 

Серийный.write()

Серийный.

На стандартном Arduino Serial. available() имеет тенденцию сообщать об отдельных байтах, тогда как большие блоки могут быть мгновенно доступны с Teensyduino. Подробности см. в разделе «Буферизация приема» ниже.

Обычно возвращаемое значение из Serial. available() следует проверять как логическое значение либо есть или нет данных. Только байты, доступные из самого последнего полученный USB-пакет виден. Видеть Подробнее о неэффективных однобайтовых USB-пакетах см. ниже.

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

 если ( серийный номер  .доступно()) {
 incomingByte =  Serial  .read(); // не будет -1
 // делаем что-то с incomingByte
 }
 

Серийный.flush()

Arduino 0022 и 0023: flush() отбрасывает любые полученные данные, которые не были прочитаны.

Последовательные USB-удлинители Teensy

Serial.send_now()

Серийный.dtr()

недействительная установка () {
}
недействительный цикл () {
 pinMode(6, ВЫХОД); // Светодиод, показывающий, использует ли программа последовательный порт
 цифровая запись (6, ВЫСОКИЙ); //   (активный низкий уровень сигнала, ВЫСОКИЙ = светодиод не горит)
 в то время как (!  Серийный номер  . dtr()) {
 // ждем, пока пользователь запустит последовательный монитор
 }
 цифровая запись (6, НИЗКИЙ);
 задержка(250);
  Serial  .println("Привет, новый сеанс последовательного монитора");
 в то время как ( серийный номер  .dtr()) {
  Серийный номер  .print('.'); // ждем, пока пользователь покинет последовательный монитор
 задержка(500);
 }
}
 

Серийный.rts()

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

Драйвер Windows USBSER.SYS имеет известная ошибка где изменения, внесенные в RTS, не сообщаются Teensy (или любым другим доскам с использованием протокола CDC-ACM) до тех пор, пока не будет записан DTR. Некоторые программы, такие как CoolTerm, обойти эту ошибку.

Последовательный.бод()

Последовательный.стопбиты()

Serial.paritytype()

Серийный.numbits()

Сведения о буферизации и синхронизации USB

Буферизация передачи

На Teensy Serial.print() записывает непосредственно в буфер USB. Если все ваше сообщение помещается в буферную память, Serial.print() возвращается к вашему эскизу очень быстро.

И Teensyduino, и микросхема USB-Serial содержат частично заполненный буфер. если вы хотите передать больше данных. Обычно после короткого перерыва 3-5 мс в Teensyduino, запланирована передача частично заполненного буфера на USB.

Teensyduino немедленно планирует любой частично заполненный буфер для передачи когда вызывается функция Serial. send_now().

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

Когда хост-контроллер получает данные, операционная система затем планирует выполнение принимающей программы. В Linux открыты последовательные порты с опцией «низкая задержка» пробуждаются быстро, другие обычно ждут до нормальной "галочки" запускать. Windows и MacOS, вероятно, добавят процесс задержки в расписании. Сложные среды выполнения (например, Java) также могут добавить существенную задержку.

Буферизация приема

недействительный цикл () {
 // В Arduino с последовательным интерфейсом байты обычно приходят по одному
 // так что этот цикл while обычно обрабатывает только 1 байт, прежде чем разрешить
 // остальная часть функции цикла выполняет свою работу
 в то время как ( серийный номер  .доступно()) {
 incomingByte =  Serial  .read();
 // делаем что-то с incomingByte
 }
 // делаем другие несвязанные вещи
 время_чувствительная_задача1();
 другая_срочная_вещь();
 все еще_еще_даже_больше_вещей();
}
 

недействительный цикл () {
 // На Teensy большие группы байтов имеют тенденцию поступать одновременно.
 // Этот счетчик байтов позволяет не тратить слишком много времени на их обработку.
 беззнаковое целое число байтов = 0;
 в то время как (  серийный номер  .доступно () && число байтов < 10) {
 incomingByte =  Serial  .read();
 // делаем что-то с incomingByte
 количество байт++;
 }
 // делаем другие несвязанные вещи
 время_чувствительная_задача1();
 другая_срочная_вещь();
 все еще_еще_даже_больше_вещей();
}
 

Неэффективные однобайтовые пакеты USB

Microsoft Windows и Linux, к сожалению, НЕ предоставляют подобную функцию, когда передача данных. Если приложение записывает неэффективно, например, один байт за раз каждый байт отправляется в одном USB-пакете (который мог содержать 64 или 512 байт). Хотя это плохо использует полосу пропускания USB, больше беспокоит то, как это влияет на буферизация, как это видно из Serial.available().

Аппаратное обеспечение USB, присутствующее в Teensy, может буферизовать 2 пакета USB. Серийный.доступный() сообщает количество непрочитанных байтов только из первого пакета. Если пакет содержит только 1 байт, Serial.available() вернет 1, независимо от сколько байтов может присутствовать во 2-м пакете или сколько байтов может быть ожидание большего количества пакетов, все еще буферизованных хост-контроллером USB ПК.

Этот код не будет работать на Teensy, когда ПК передает ожидаемое 11-байтовое сообщение. более чем в 1 USB-пакете.

// Это может не работать на Teensy, если USB-пакеты имеют размер менее 11 байт!
логическое значение getNumbersFromSerial() {
 while (  Serial  . available() < 11) { ;} // ожидание 11-байтового сообщения
 если ( серийный номер  .read() == '@') {
  time_t  pctime = 0;
 для (целое я = 0; я < 10; я ++) {
 char c =  Серийный номер  .read();
 если (с >= '0' && с <= '9') {
 pctime = (10 * pctime) + (c - '0') ; // преобразовать цифры в число
 }
 }
 компьютерное время += 10;
 DateTime.sync (время ПК); // Синхронизируем часы с полученным временем
 вернуть истину; // вернуть true, если получено сообщение о времени
 }
 вернуть ложь; //если нет сообщения, возвращаем false
}
 

Этот код можно переписать так, чтобы он всегда считывал байт, когда Serial. available() возвращает ненулевое значение.

// Это всегда будет работать на Teensy, не зависит от размера буфера
логическое значение getNumbersFromSerial() {
 целое число = 0;
 char buf[11];
 в то время как (количество < 11) {
 if (  Serial  .  available()) { // получаем все 11 байт в "buf"
 buf[count++] =  Серийный номер  .read();
 }
 }
 если (buf[0] == '@') {
  time_t  pctime = 0;
 for(int i=1; i < 11; i++) {
 char c = buf[i];
 если (с >= '0' && с <= '9') {
 pctime = (10 * pctime) + (c - '0') ; // преобразовать цифры в число
 }
 }
 компьютерное время += 10;
 DateTime.sync (время ПК); // Синхронизируем часы с полученным временем
 вернуть истину; // вернуть true, если получено сообщение о времени
 }
 вернуть ложь; //если нет сообщения, возвращаем false
}
 

Конечно, всегда есть много способов написать программу. Версии выше выглядят для символа '@', чтобы начать сообщение, но не обрабатывать случай, когда дополнительный байты (неправильно) появляются перед 10-значным числом. Также не обязательно хранить все сообщение в буфере, так как работа может выполняться по мере того, как байты читать. Вот более надежная и эффективная версия.

// Эта версия более надежная
логическое значение getNumbersFromSerial() {
 количество счетчиков = 0;
  time_t  pctime = 0;
 в то время как (количество < 10) {
 если ( серийный номер  . доступно()) {
 char c =  Серийный номер  .read();
 если (с == '@') {
 ПК-время = 0; // всегда начинать заново при получении '@'
 количество = 0;
 } еще {
 если (с >= '0' && с <= '9') {
 pctime = (10 * pctime) + (c - '0') ; // преобразовать цифры в число
 количество++;
 }
 }
 }
 }
 DateTime.sync (время ПК); // Синхронизируем часы с полученным временем
}