Serial изнутри: буферы, UBRR0 и U2X

Что делает Serial.begin

// ArduinoCore-avr 1.8.8, cores/arduino/HardwareSerial.cpp, lines 117-150
void HardwareSerial::begin(unsigned long baud, byte config)
{
  // Try u2x mode first
  uint16_t baud_setting = (F_CPU / 4 / baud - 1) / 2;
  *_ucsra = 1 << U2X0;

  // hardcoded exception for 57600 for compatibility with the bootloader
  // shipped with the Duemilanove and previous boards and the firmware
  // on the 8U2 on the Uno and Mega 2560. Also, The baud_setting cannot
  // be > 4095, so switch back to non-u2x mode if the baud rate is too
  // low.
  if (((F_CPU == 16000000UL) && (baud == 57600)) || (baud_setting > 4095))
  {
    *_ucsra = 0;
    baud_setting = (F_CPU / 8 / baud - 1) / 2;
  }

  *_ubrrh = baud_setting >> 8;
  *_ubrrl = baud_setting;
  _written = false;
  *_ucsrc = config;

  sbi(*_ucsrb, RXEN0);
  sbi(*_ucsrb, TXEN0);
  sbi(*_ucsrb, RXCIE0);
  cbi(*_ucsrb, UDRIE0);
}

Формула (F_CPU / 4 / baud − 1) / 2 — это UBRR0 = f / (8 · BAUD) − 1 из табл. 20-1 для режима U2X0, записанная в целых числах с округлением к ближайшему. Ядро сначала пробует удвоенную скорость: делитель 8 вместо 16 даёт более мелкий шаг подстройки. Режим без U2X0 включается в двух случаях — если UBRR0 не помещается в 12 бит (медленные скорости) и для одной конкретной скорости, 57 600 бит/с на 16 МГц.

Serial.begin(9600) — это begin(9600, SERIAL_8N1), а SERIAL_8N1 = 0x06: в UCSR0C это UCSZ01:00 = 11 — 8 бит данных, без чётности, 1 стоп-бит. Затем включаются приёмник, передатчик и прерывание по приёму. До begin() выводы 0 и 1 свободны: init() записала UCSR0B = 0, отключив USART0, который оставил включённым загрузчик (строки 384–391 wiring.c).

Что выбирает ядро и чего это стоит

Значения UBRR0 и ошибки скорости — из табл. 20-7 даташита для 16 МГц, выбор ядра — по формулам выше (расчёт наш):

Рекомендуемая ошибка скорости приёмника для 8 бит данных — ±2,0 % без U2X0 и ±1,5 % с ним (табл. 20-2 и 20-3). На 57 600 ядро сознательно выбирает вариант с ошибкой 2,1 % вместо −0,8 % — комментарий в коде объясняет это совместимостью со старым загрузчиком Duemilanove и прошивкой моста 8U2 на Uno и Mega 2560. На 115 200 бит/с 2,1 % тоже выше рекомендации для U2X0 = 1; связь обычно работает, потому что ошибка партнёра — моста USB-UART — мала, но с другим микроконтроллером на том же кварце запаса может не хватить. Скорости 250 000, 500 000 и 1 000 000 бит/с делятся из 16 МГц без ошибки. Любую комбинацию частоты и скорости проверит калькулятор UART.

Буферы и прерывания

HardwareSerial держит два кольцевых буфера — на приём и на передачу. Их размер задаёт HardwareSerial.h (строки 43–55): 64 байта, если RAMEND − RAMSTART не меньше 1023, то есть ОЗУ не меньше 1024 байт, иначе 16. У ATmega328P RAMSTART = 0x100 и RAMEND = 0x8FF, то есть 2 КБ, — буферы по 64 байта.

Приём. Обработчик ISR(USART_RX_vect) вызывает _rx_complete_irq() (HardwareSerial_private.h, строки 101–121): читает UDR0, и если следующая позиция головы не совпадает с хвостом, кладёт байт в буфер. Если совпадает — буфер полон, и байт молча теряется. Байт с ошибкой чётности тоже отбрасывается. Поскольку одна ячейка всегда пуста, в буфере помещается 63 байта. Кадр 8N1 — это 10 бит, и время заполнения буфера при непрерывном потоке (расчёт наш):

Если loop() с delay(100) читает порт реже, часть данных пропадёт без всякого сообщения. serialEvent() здесь не помогает: main() вызывает её после каждого прохода loop(), а не по прерыванию.

Передача. Serial.write() (строки 225–279) сначала пробует короткий путь: если буфер пуст и регистр UDR0 свободен, байт пишется сразу в UDR0. Иначе байт ложится в буфер и включается прерывание «регистр данных пуст» (UDRIE0), обработчик которого отправляет байты по одному. Когда буфер полон, write() ждёт освобождения места — поэтому длинный Serial.print() на 9600 бит/с тормозит программу примерно на 1 мс за каждый символ сверх буфера; подробнее — в ответе «Почему Serial.print замедляет программу».

Цена такой схемы — по прерыванию на каждый байт в каждую сторону: на 115 200 бит/с это до 11 520 прерываний в секунду на приём и столько же на передачу (расчёт наш).

USART0 без HardwareSerial

Если в скетче нет ни одного обращения к Serial, файл HardwareSerial0.cpp с обработчиками USART0 в программу не попадает — его комментарий так и объясняет, зачем каждый порт вынесен в отдельный файл. Тогда USART0 можно взять себе целиком, например, чтобы на 57 600 бит/с получить ошибку −0,8 %:

// USART0 at 57600 baud, U2X0 = 1: UBRR0 = 34, error -0.8 % (table 20-7)
void uartInit(void)
{
  UCSR0A = _BV(U2X0);
  UBRR0 = 34;
  UCSR0C = _BV(UCSZ01) | _BV(UCSZ00);   // 8N1
  UCSR0B = _BV(RXEN0) | _BV(TXEN0);     // no interrupts: polling
}

void uartPut(uint8_t c)
{
  while (!(UCSR0A & _BV(UDRE0))) {}     // wait until UDR0 is free
  UDR0 = c;
}

void setup() {
  uartInit();
  for (const char *p = "hello\r\n"; *p; p++) uartPut(*p);
}

void loop() {}

Такой вывод занимает процессор, пока байт не уйдёт в регистр, зато в нём нет буферов и прерываний. Свой приём с кольцевым буфером любого размера в обработчике ISR(USART_RX_vect) разобран в статье «Кольцевой буфер для UART». Смешивать такой код с Serial нельзя: Serial.begin() перепишет UCSR0A, UBRR0, UCSR0C и UCSR0B своими значениями и включит прерывания USART0, а Serial.write() будет писать в тот же UDR0.

Уровни на выводах 0 и 1

Выводы RX и TX Uno подключены к мосту USB-UART платы. Внешний модуль с UART подключают к ним только с общим проводом GND и только с логическими уровнями 0–5 В, не выше VCC + 0,5 В (раздел 29.1). У интерфейса RS-232 другие уровни, и он подключается только через преобразователь. Пока к выводам 0 и 1 подключено внешнее устройство, загрузка скетча через USB может не работать — загрузчик использует тот же USART0.

Задание

1. Какие значения запишет Serial.begin(38400) в UCSR0A и UBRR0 на 16 МГц и какая будет ошибка скорости?
2. Датчик шлёт поток данных на 9600 бит/с без пауз, а loop() читает порт раз в 200 мс. Сколько байтов теряется за каждый проход?
3. На плате с кварцем 8 МГц скетч вызывает Serial.begin(57600). Сработает ли исключение для 57 600? Какие UCSR0A и UBRR0 получатся?

Что дальше

В уроке 8 сравним библиотеки Wire и SPI с регистрами TWI и SPI: где библиотека почти бесплатна, а где добавляет буферы и ожидание. Все регистры USART0 с битами — на странице регистров USART0 ATmega328P. Принять и отправить данные с компьютера можно в терминале UART прямо в браузере, а что такое скорость в бодах — в термине «Скорость передачи (бод)».