ATmega2560: работа с UART

Добавил(а) microsin

UART (USART) обычно нужен для организации взаимодействия с внешним миром - чтобы передать микроконтроллеру какие-то команды и забрать у него данные. Или как минимум для отладки - чтобы понять, что происходит с Вашей программой.

Примечание: аббревиатура USART переводится как Universal Synchronous and Asynchronous serial Receiver and Transmitter (USART), т. е. последовательный порт может работать как синхронный (по внешнему тактовому сигналу), так и асинхронный (аппаратно формировать посылки бит по интервалам времени).

Запуск USART обычно состоит из следующих простых действий:

1. Создать буферы приема и передачи (типа FIFO, обычно кольцевые).
2. Написать код инициализации USART.
3. Написать обработчик прерывания приема символа из USART.
4. Написать обработчик передачи USART.
5. Перенаправление вывода printf в USART.

Рассмотрим каждую из этих операций. Все, что написано далее, может относиться во многом не только к микроконтроллеру ATmega2560, но и к любому AVR, который имеет на борту аппаратуру USART (или UART).

[1. Буферы приема и передачи USART]

Буферы приема и передачи нужны для того, чтобы упорядочить потоки входных и выходных данных в программе. На приеме обработчик прерывания нужен потому, что символ (байт) может прийти из внешнего мира асинхронно, т. е. в любой момент времени. Аппаратный буфер USART у AVR очень мал - всего лишь 2 байта.

Примечание: в микроконтроллере ATmega2560 буфер приема читается через регистр UDRn, где буква n меняется на номер используемого порта 0, 1, 2 или 3 (у ATmega2560 целых 4 последовательных порта USART: USART0, USART1, USART2 и USART3).

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

Для быстрого считывания поступившего байта обычно используется обработчик прерывания приема USART. Буфер считывается из регистра UDRn и помещается в буфер, откуда он потом может быть выбран основной программой. Возникает вопрос: так зачем все-таки нужен буфер, почему нельзя сразу в обработчике прерывания предпринять какие-то действия, и обойтись без дополнительного буфера? Ответ прост: да, можно так сделать, но только для самых простых случаев, когда обработка байта не займет много времени, и когда не нужно производить дополнительных действий. Например, не получится обойтись без программного буфера, если поток входных данных соответствует какому-то протоколу, нельзя обрабатывать каждый байт по отдельности, нужно отслеживать таймауты в потоке входных байт и т. п. Такие сложные действия иногда нельзя возложить на обработчик прерывания, потому что они займут слишком много времени, и это повлияет на работоспособность всей программы в целом. Таким образом, обработчик приема может просто поместить принятый в буфер байт и быстро завершить свою работу. Опустошать буфер приема может основная программа, которая может быть довольно сложной и медлительной.

Буфер для передачи делают потому, что в одном действии программы обычно надо передать через USART не один байт, а сразу несколько. Например, нужно вывести приветствие printf("Hello World!"), или какое-то диагностическое сообщение, состоящее из нескольких байт. Но USART может передавать только по одному байту, через аппаратный буфер регистра UDRn. Если аппаратный буфер не опустошился, т. е. если USART не успел еще передать только что записанный в UDRn байт, то нельзя в цикле без задержки писать все символы передаваемой строки в UDRn, иначе произойдет потеря данных при передаче (TX overrun). Чтобы не было непроизводительных потерь процессорного времени на циклы ожидания, делается программный буфер достаточного размера, куда программа может без задержки поместить все данные, которые надо передать. Опустошаться буфер передачи будет по одному байту - в основной программе и/или в обработчике прерывания опустошения буфера, по мере того, как аппаратура USART будет готова передать очередной байт.

Вот пример организации буферов передачи и приема USART (подробнее про кольцевые буферы см. [1]):

#define BUFSIZERX 32 //размер буфера приема

#define BUFSIZETX 32 //размер буфера передачи

//Маски для обработки индексов кольцевых буферов:

#define BUFMASKRX (BUFSIZERX-1)

#define BUFMASKTX (BUFSIZETX-1)

//Буфер приема и его индексы:

char bufRX [BUFSIZERX];

unsigned char rxIn, rxOut;

//Буфер передачи и его индексы:

char bufTX [BUFSIZETX];

unsigned char txIn, txOut;

В этом примере размеры буферов приема и передачи выбраны одинаковыми, но это совершенно не обязательно. К размеру буферов передачи и приема есть два простых требования, которые зависят от того, как работает Ваша программа. Во-первых, размер буфера должен быть достаточно велик, чтобы он никогда не переполнялся. Это означает, что на приеме Вы всегда успеваете забрать и обработать поступающие данные до того, как буфер переполнится (т. е. данные поступают всегда медленнее, чем Вы их читаете и обрабатываете). Аналогично на передаче Вы не должны писать в буфер передачи слишком часто, буфер передачи должен успевать опустошаться кодом поддержки аппаратуры передачи USART. Во-вторых, есть требование, которое вытекает из примененного принципа обработки кольцевого буфера [1]: размер буфера должен быть равен степени 2, т. е. 2, 4, 8, 16, 32, 64 и т. д. Это требование не обязательное, если Вы согласны усложнить обработку индексов буфера, но имейте в виду, что усложнение кода обработки индексов замедлит обработку приема и передачи, и иногда такое замедление может оказаться недопустимым.

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

[2. Код инициализации USART]

В этом примере будем настраивать USART0, который используется в плате Arduino Mega 2560 [2] в качестве стандартного канала обмена с компьютером через USB. Параметры для настройки 115200 bps, 8 бит данных, без четности, 1 стоп-бит.

После сброса (перезагрузки) все регистры AVR, в том числе и регистры, которые устанавливаются в исходное состояние. Чтобы USART заработал как нужно, необходимо настроить биты его регистров (подробное описание регистров см. во врезке "Справочная информация по USART ATmega2560"):

UCSR0A.U2Xn бит двойной скорости передачи.
UCSR0A.MPCMn бит включения функции мультипроцессорного обмена.

Обе эти функции не нужны, поэтому в UCSR0A нужно записать 0.

UCSR0A = 0;

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

UCSR0B.RXCIE0 разрешение прерывания приема. Мы будем использовать обработчик прерывания по наличию в буфере приема данных, поэтому этот бит нужно установить в 1.
UCSR0B.RXEN0 разрешение работы приемника, сюда нужно записать 1.
UCSR0B.TXEN0 разрешение работы передатчика, сюда нужно записать 1.
UCSR0B.UCSZ02 это один из 3 бит, который настраивает количество бит данных во фрейме. У нас размер данных фрейма 8 бит, по таблице 22-7 значение этого бита должно быть равно 0.

Остальные биты не нужны, поэтому они будут сброшены.

UCSR0B = (1 << RXCIE0)|(1 << RXEN0)|(1 << TXEN0);

UCSR0C.UMSEL01 и UMSEL00 эти биты определяют режим работы USART. Нас интересует асинхронный режим, по таблице 22-4 значение этих бит должно быть нулевое.
UCSR0C.UPM01 и UPM00 эти биты определяют контроль четности. Нам он не нужен, поэтому по таблице 22-5 значение этих бит будет нулевое.
UCSR0C.USBS0 бит количества стоп-битов фрейма. У нас 1 стоп-бит, поэтому согласно таблице 22-6 значение этого бита нулевое.
UCSR0C.UCSZ00 и UCSZ01 эти биты совместно с битом UCSR0B.UCSZ02 определяют количество бит данных во фрейме. По таблице 22-7 значение бит UCSZ01 и UCSZ00 должно быть 11.
UCSR0C.UCPOL0 этот бит работает только в синхронном режиме, поэтому должен быть сброшен в 0.

Следовательно, в регистре UCSR0C нужно установить только биты UCSZ01 и UCSZ00:

UCSR0C = (1 << UCSZ01)|(1 << UCSZ00);

UBRR0H, UBRR0L. Для этих регистров нужно по формуле рассчитать настройки для скорости (это 12-битный регистр UBRR0, доступ к которому дает пара регистров UBRR0H:UBRR0L). Поскольку у нас асинхронный режим, нет включенной двойной скорости, то наша формула будет следующей (см. таблицу 22-1):

16000000
UBRR0 = ---------------- - 1
16 * 115200

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

UBRR0H = 0;
UBRR0L = 8;

Примечание: можно было бы воспользоваться таблицей 22-12, где есть готовое вычисленное значение UBRR для скорости 115.2K. Как следует из таблицы, для режима двойной скорости настройка получится точнее, в этом случае нужно записать в UBRR0 значение 16, и бит U2X0 в регистре UCSR0A нужно установить в 1:

UCSR0A = (1 << U2X0);

UBRR0H = 0;
UBRR0L = 16;

Несмотря на то, что на двойной скорости настройка получается точнее, все равно не факт, что это будет работать лучше, потому что оцифровка бит RXD будет осуществляться не по 16 выборкам, а по 8 (см. подробное описание работы приемника во врезке "Справочная информация по USART ATmega2560").

void SetupUSART0 (void)
{
   //Режим двойной скорости выключен:
   UCSR0A = 0;
   //Разрешены прерывание приема, работа приемника и передатчика:
   UCSR0B = (1 << RXCIE0)|(1 << RXEN0)|(1 << TXEN0);
   //Настройка размера фрейма данных 8 бит, без четности, 1 стоп-бит:
   UCSR0C = (1 << UCSZ01)|(1 << UCSZ00);
   //Настройка скорости 115200 bps:
   UBRR0H = 0;
   UBRR0L = 8;
}

Примечание: после того, как будет разрешен приемник и передатчик установкой бит RXEN0 и TXEN0 соответственно, функционирование портов ввода/вывода PE0 и PE1 будет автоматически переназначено. Теперь они будут работать как вход приемника и выход передатчика USART.

[3. Обработчик прерывания приема USART]

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

ISR(USART0_RX_vect)
{
   bufRX [rxIn++] = UDR0;
   rxIn &= BUFMASKRX;
}

Примечание: константу USART0_RX_vect можно подсмотреть в файле avr\include\avr\iomxx0_1.h тулчейна (это может быть WinAVR или тулчейн AVR-GCC, который устанавливается в составе Atmel Studio).

[4. Обработка передачи USART]

Обработка передачи будет простейшая: в главный цикл main будет вставлена процедура handlerTXUSART, проверяющая наличие данных в буфере передачи. Если данные в буфере передачи есть, и передатчик свободен, то из буфера передачи будет выбран байт и записан в регистр UDR0.

static void handlerTXUSART (void)
{
   if((txIn != txOut) && (UCSR0A & (1 << UDRE0)))
   {
      UDR0 = bufTX[txOut++];
      txOut &= BUFMASKTX;
   }
}

int main(void)
{
   ...
   SetupUSART0();
   sei();
   while(1)
   {
      ...
      handlerTXUSART();
   }
}

Минимальная настройка завершена. Все, что будет попадать в буфер передачи bufTX, будет выведено через USART0. Все, что поступит из внешнего мира, попадет в буфер приема bufRX. Само собой основной код должен использовать эту возможность, чтобы осуществлять обмен данными через USART, т. е. при необходимости нужно читать буфер приема и писать данные в буфер передачи. Все остальное будет происходить автоматически.

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

[5. Настройка printf на вывод через USART]

Перенаправление printf в USART нужно в основном чисто для удобства: чтобы проще выводить нужные отладочные (или какие-то другие) текстовые сообщения в какое-то устройство, где их можно отобразить и прочитать. Если для перенаправления используется USART (можно кстати использовать и другие устройства вывода текста, например экран LCD), то выводимые текстовые сообщения можно увидеть на компьютере в окне программы-терминала (например, putty, TerraTerm, HyperTerminal, Serial Monitor у Arduino IDE), подключенной к COM-порту, куда поступают данные от микроконтроллера (обычно это виртуальный COM-порт через соединение USB, как например это сделано у плат Arduino). Короче говоря, задача состоит в том, чтобы текст, который выводится оператором printf, сразу попадал в консоль программы терминала.

Описание решения этой задачи подробно описано в [4], здесь я просто кратко покажу что нужно сделать. Вывод в USART через printf с использованием библиотек avr-libc настраивается за 3 простых шага (последний шаг необязательный):

1. Подключить заголовочный файл stdio.h.

2. Определить функцию, которая будет выводить символ в UART (в этом примере функция uart_putchar).

3. (Необязательно) опциями линкера выбрать вариант обработки преобразований формата printf.

Простой пример:

#include < stdio.h >

static int uart_putchar(char c, FILE *stream);

static FILE mystdout = FDEV_SETUP_STREAM(uart_putchar, NULL, _FDEV_SETUP_WRITE);

static int uart_putchar(char c, FILE *stream)
{
   if (c == '\n')
      uart_putchar('\r', stream);
   loop_until_bit_is_set(UCSRA, UDRE);
   UDR = c;
   return 0;
}

int main(void)
{
   init_uart();
   stdout = &mystdout;
   printf("Hello, world!\n");
   return 0;
}

Здесь настраивается поток mystdout, который привязывается к функции вывода символа и стандартному потоку вывода stdout.

Если пропустить шаг 3, то оператор printf будет работать с ограничениями при обработке формата для чисел с плавающей запятой (подробнее про это и про опции настройки линкера см. [4]).

Справочная информация по USART ATmega2560

Как уже упоминалось, у ATmega2560 имеется 4 последовательных порта USART: USART0, USART1, USART2 и USART3, которые фиксировано привязаны к определенным ножкам корпуса микроконтроллера. Т. е. определенный вывод микроконтроллера может работать либо просто как порт ввода/вывода, либо как аппаратный вход или выход интерфейса USART. Все зависит от программной настройки - данных, которые Вы запишете в управляющие регистры микроконтроллера. В таблице и на картинке показана привязка аппаратуры USART к выводам микроконтроллера.

Имя	Прерывания	Регистры	Порты RXD, TXD, XCK
USART0	UDRE0, TXC0, RXC0	UDR0, UCSR0A, UCSR0B, UCSR0C, UBRR0L, UBRR0H	PE0, PE1, PE2
USART1	UDRE1, TXC1, RXC1	UDR1, UCSR1A, UCSR1B, UCSR1C, UBRR1L, UBRR1H	PD2, PD3, PD5
USART2	UDRE2, TXC2, RXC2	UDR2, UCSR2A, UCSR2B, UCSR2C, UBRR2L, UBRR2H	PH0, PH1, PH2
USART3	UDRE3, TXC3, RXC3	UDR3, UCSR3A, UCSR3B, UCSR3C, UBRR3L, UBRR3H	PJ0, PJ1, PJ2

ATmega2560 USART pins

Порты USART обладают следующими основными возможностями:

• Поддерживают полный дуплекс (имеют независимые аппаратные буферы приема и передачи).
• Могут работать асинхронно и синхронно.
• В синхронном режиме могут либо вырабатывать такты, либо использовать внешнее тактирование (Master or Slave Clocked Synchronous Operation).
• Генератор скорости передачи, настраиваемый с высокой точностью (High Resolution Baud Rate Generator).
• Поддерживает размеры фрейма передачи из 5, 6, 7, 8 или 9 бит данных и 1 или 2 стоповых бита.
• Аппаратная поддержка генерации и проверки на нечетность или четность (Odd or Even Parity).
• Детектирование потери данных на приеме (Data OverRun Detection).
• Детектирование ошибок фрейма (Framing Error Detection).
• Фильтрация помех (Noise Filtering) с помощью цифрового ФНЧ, включающая детектирования ошибочного стартового бита.
• 3 отдельных прерывания по событиям TX Complete, TX Data Register Empty и RX Complete.
• Режим обмена с несколькими процессорами (Multi-processor Communication Mode).
• Асинхронный режим с двойной скоростью (Double Speed Asynchronous Communication Mode).

Для уменьшения общего энергопотребления кристалла ненужные USARTn могут быть полностью выключены с помощью битов управления регистров PRR0 и PRR1.

Порт USART0 используется в платах Arduino Mega 2560 [2] под аппаратный мост USB-UART, чтобы обеспечить работу загрузчика кода и поддержку отладочного вывода через Serial Monitor.

ATmega2560 USART block diagram fig22 1

Рис. 22-1. Блок-диаграмма внутреннего устройства USART.

На диаграмме пунктирными линиями выделены 3 отдельных блока USART (перечисленные далее сверху вниз): Clock Generator (тактовый генератор), Transmitter (передатчик) и Receiver (приемник). Регистры управления общие для всех этих блоков. Логика Clock Generation состоит из логики синхронизации для внешних тактов (SYNC LOGIC, используется в подчиненном режиме для синхронизации передачи бит), и генератора скорости передачи (BAUD RATE GENERATOR). Вывод XCKn (такты передачи) используется только для синхронного режима работы (synchronous transfer mode). Передатчик состоит из одиночного буфера записи (UDR), последовательного регистра сдвига (TRANSMIT SHIFT REGISTER), генератора четности (PARITY GENERATOR) и логики управления (TX CONTROL) для поддержки разных форматов фрейма. Наличие аппаратного буфера фрейма позволяет вести непрерывные передачи без задержек между отдельными фреймами. Приемник наиболее сложный узел USART, потому что он имеет узлы восстановления тактов (CLOCK RECOVERY) и данных (DATA RECOVERY), которые используются для асинхронного приема данных. В дополнение к узлам восстановления приемник содержит блок проверки на четность (PARITY CHECKER), логику управления (RX CONTROL), регистр сдвига и двухуровневый буфер приема (UDR). Приемник поддерживает одинаковый формат фрейма, который использует передатчик, и может детектировать ошибку фрейма (Frame Error), событие потери данных на приеме (Data OverRun) и ошибку четности (Parity Error). Модуль PIN CONTROL управляет поведением порта микроконтроллера - или этот вывод работает как обычный порт ввода/вывода GPIO, или он подключен к аппаратуре USART и выполняет специальную функцию.

[Генерация тактов]

Логика генерации тактов синтезирует базовую частоту синхронизации для передатчика и приемника. The USARTn поддерживает 4 режима тактирования: нормальный асинхронный (Normal asynchronous), асинхронный двойной скорости (Double Speed asynchronous), синхронный главный (Master synchronous) и синхронный подчиненный (Slave synchronous). Бит UMSELn в USART Control and Status Register C (UCSRnC) выбирает между асинхронным и синхронным режимами. Двойная скорость (применимо только к асинхронному режиму) управляется битом U2Xn, находящемся в регистре UCSRnA. Когда используется синхронный режим (UMSELn = 1), регистр направления данных (Data Direction Register, DDR) для вывода XCKn определяет, каким будет тактирование для синхронного режима: внутренним (Master mode) или внешним (Slave mode). Вывод XCKn активен только в при использовании синхронного режима, в асинхронном режиме он работает как простой порт GPIO.

Рис. 22-2. Блок-диаграмма логики генерации тактов USART.

Описание сигналов:

txclk такты передатчика (внутренний сигнал).
rxclk базовые такты передатчика (внутренний сигнал).
xcki ввод от вывода XCK (внутренний сигнал). Используется для работы в синхронном подчиненном режиме (synchronous slave operation).
xcko выходной сигнал тактов для подачи на вывод XCK (внутренний сигнал). Используется для работы в синхронном подчиненном режиме (synchronous master operation).
f_OSC частота вывода XTAL (System Clock, системная частота).
DDR_XCK разряд регистра DDRX, управляющий направлением работы ножки порта (вход или выход).

Baud Rate Generator, внутренняя генерация тактов. Генерация тактов внутри чипа используется для асинхронного и синхронного режимов работы. USART Baud Rate Register (UBRRn) и считающий вниз счетчик (Prescaling Down-Counter) подключены к программируемому прескалеру, или другими словами к генератору скорости передачи (Baud Rate Generator). Обратно-считающий счетчик (down-counter), работающей на системной частоте (f_OSC), каждый раз загружается значением из UBRRn, когда счетчик достигает нуля, или когда записан регистр UBRRLn. В этот момент генерируется тактовый импульс для USART, появляющийся на выходе Baud Rate Generator (= f_OSC/(UBRRn+1)). Передатчик делит выходную тактовую частоты Baud Rate Generator на 2, 8 или 16 в зависимости от режима. Выход Baud Rate Generator напрямую используется для тактирования приемника и узлов восстановления данных. Однако узлы восстановления используют машину состояний из 2, 8 или 16 состояний в зависимости от режима, установленного битами UMSELn, U2Xn и DDR_XCKn.

Таблица 22-1 содержит выражения для вычисления скорости baud rate (в битах на секунду) и для вычисления значения UBRRn для каждого режима работы, когда используется генерируемый внутри источник тактов.

Табл. 22-1. Формулы для расчета скорости и настроек в зависимости от режима.

Режим	Скорость⁽¹⁾	UBRR
Асинхронный нормальный (U2XN = 0)	f_OSC BAUD = ----------------------- 16 * (UBRRn+1)	f_OSC UBRRn = ---------------- - 1 16 * BAUD
Асинхронный двойной скорости (U2XN = 1)	f_OSC BAUD = ----------------------- 8 * (UBRRn+1)	f_OSC UBRRn = --------------- - 1 8 * BAUD
Синхронный главный	f_OSC BAUD = ----------------------- 2 * (UBRRn+1)	f_OSC UBRRn = --------------- - 1 2 * BAUD

Примечание (1). Скорость передачи определена как скорость следования бит в секунду (baud rate, bit per second, bps).

BAUD Baud rate (в битах/сек, bps).
f_OSC системная тактовая частота (System Oscillator clock frequency).
UBRRn содержимое регистров UBRRHn и UBRRLn (0-4095).

Некоторые примеры значений UBRRn для разных тактовых частот микроконтроллера можно найти в таблице 22-9.

Double Speed Operation (U2Xn). Скорость передачи может быть удвоена (это пошло еще от микроконтроллеров серии MCS51) путем установки бита U2Xn в регистре UCSRnA. Установка этого бита дает эффект только для асинхронной работы USART, сбросьте этот бит в 0 для синхронного функционирования.

Установка бита U2Xn уменьшит коэффициент деления синтезатора скорости с 16 до 8, что соответствует удвоению скорости передачи и приема для асинхронного режима. Имейте в виду, что приемник в этом случае будет делать в 2 раза меньше выборок при восстановлении данных и тактов (количество выборок также уменьшиться с 16 до 8), так что для удвоения скорости с сохранением точной установки скорости понадобится более точно выдерживать системную частоту. Это важно для приемника, а для передатчика нет никаких проблем.

Внешнее тактирование. Используются в подчиненном синхронном режиме работы. Внешние такты поступают от вывода XCKn (см. рис. 22-2), и их значения выбираются регистром синхронизации, чтобы уменьшить шансы нестабильности. Выход регистра синхронизации затем должен поступить сначала на детектор перепада, перед тем как сигнал тактов можно было использовать в передатчике и приемнике. Этот процесс занимает два цикла системной тактовой частоты CPU, так что эта задержка ограничивает максимально возможную тактовую частоту XCKn:

f_OSC
fXCK < ------
4

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

Синхронный режим работы. Когда используется синхронный режим (UMSELn = 1), вывод XCKn будет аппаратно использоваться либо как вход тактов (подчиненное устройство), либо как выход тактов (главное устройство). Зависимость между перепадами тактов и выборкой данных остается той же самой. Базовый принцип состоит в том, что вход данных (on RxDn) оцифровывается по противоположному перепаду XCKn, когда меняется сигнал на выходе данных (TxDn).

ATmega2560 USART Synchronous Mode XCKn Timing fig22 3

Рис. 22-3. Временные диаграммы XCKn синхронного режима.

Бит UCRSC регистра UCPOLn выберет, какой из перепадов XCKn будет использоваться для выборки данных, а какой для изменения выходных данных. Как видно из рис. 22-3, когда UCPOLn == 0 данные изменяются по нарастанию XCKn и выборка делается по спаду XCKn. И наоборот, если UCPOLn == 1, то данные изменяются по спаду XCKn, и их выборка делается по фронту XCKn.

Форматы фрейма. Под фреймом подразумевается элементарная, неделимая посылка из нескольких бит. Во фрейм входят последовательно передаваемый код символа определенной разрядности, биты синхронизации (биты start и stop), и опционально бит четности для проверки на ошибку. USART позволяет настроить все 30 комбинаций следующих допустимых форматов фрейма:

• 1 start-бит
• 5, 6, 7, 8 или 9 бит данных
• no, even или odd parity bit (бит четности отсутствует, есть бит четности или есть бит нечетности)
• 1 или 2 stop-бита

Фрейм начинается start-битом, за которым идет наименее значащий бит данных (least significant bit, LSB). Далее идут биты данных (всего бит данных может быть от 5 до 9), завершающий бит самый старший (most significant bit, MSB). Если контроль четности разрешен, то за битами данных, перед stop-битами вставляется бит четности. Когда весь фрейм передан, то за ним может без задержки следовать следующий фрейм, или обмен может перейти в состояние ожидания idle, когда на линии данных уровень лог. 1. На рис. 22-4 показаны возможные комбинации форматов фрейма. Биты внутри квадратных скобок опциональны.

ATmega2560 USART frame formats fig22 4

Рис. 22-4. Форматы фрейма.

St start-бит, всегда лог. 0.
(n) биты данных (от 0 до 8).
P Parity bit, бит четности. Может быть битом нечетности, или битом четности (odd или even, в зависимости от настройки).
Sp stop-бит, всегда лог. 1.
IDLE нет активности на линии передачи (RxDn или TxDn). В состоянии IDLE на линии всегда должен быть уровень лог. 1.

Используемый формат фрейма USART устанавливается битами UCSZn2:0, UPMn1:0 и USBSn в регистрах UCSRnB и UCSRnC. Приемник и передатчик использует одну и ту же настройку. Имейте в виду, что изменение настроек этих бит во время осуществления активного обмена повредит данные передатчика и приемника.

Биты размера символа USART (UCSZn2:0) выбирают количество бит данных во фрейме. Биты режима четности USART Parity mode (UPMn1:0) разрешают и устанавливают тип контроля четности. Выбор между одним или двумя stop-битами устанавливается битом USART Stop Bit Select (USBSn). Приемник игнорирует второй stop-бит. Таким образом FE (Frame Error, ошибка фрейма) будет детектироваться в тех случаях, когда первый stop-бит равен 0.

Вычисление Parity Bit. Бит четности (parity bit) вычисляется функцией исключающее ИЛИ от всех бит данных. Если используется контроль по нечетности (odd parity), то берется результат инвертированного исключающего ИЛИ. Бит четности размещается между последним битом данных и первым (или единственным) stop-битом фрейма. Зависимость между битом четности и битами данных следующая:

ATmega2560 USART Parity Bit Calculation

P_even бит четности, когда для контроля используется четность (even).
P_odd бит четности, когда для контроля используется нечетность (odd).
d_n биты данных (в количестве n) передаваемого символа.

[Инициализация USART]

Чтобы можно было начать какой-либо обмен через USART, его надо инициализировать. Процесс инициализации обычно состоит из настройки скорости baud rate, установки формата фрейма и разрешения передатчика и/или приемника в зависимости от использования. Для работы с USART через систему прерываний (самый эффективный способ работы с USART) перед настройкой должен быть сброшен глобальный флаг разрешения прерываний (Global Interrupt Flag, I-флаг в регистре SREG), что означает запрет всех прерываний.

Перед тем, как делать повторную инициализацию с целью поменять baud rate или формат фрейма нужно убедиться, что сейчас активной передачи в момент изменения регистров. Для проверки, что передача завершена может использоваться флаг TXCn, и флаг RXCn может использоваться для того, чтобы узнать, есть ли не прочитанные данные в буфере приема. Имейте в виду, что флаг TXCn должен быть очищен перед каждой передачей (перед тем, как записывается регистр UDRn), если он используется с такой целью.

В следующем простом примере кода инициализации USART показан один и тот же функционал на языке ассемблера и в функции на языке C. Примеры подразумевают асинхронный режим работы с использованием опроса (без разрешенных прерываний) и фиксированного формата фрейма. Скорость (baud rate) предоставляется в виде параметра функции. Для кода на ассемблере подразумевается, что параметр baud rate сохранен в регистровую пару r17:r16.

USART_Init:

; установка baud rate
   sts UBRRnH, r17
   sts UBRRnL, r16
   ldi r16, (1 << U2Xn)
   sts UCRnA, r16

; разрешить приемник и передатчик
   ldi r16, (1 << RXENn)|(1 << TXENn)
   sts UCSRnB,r16

; установка формата фрейма: 8data, 1stop bit
   ldi r16, (2 << UMSELn)|(3 << UCSZn0)
   sts UCSRnC,r16
   ret

#define FOSC 1843200  // тактовая частота системы

#define BAUD 9600

#define (MYUBRR FOSC/16/BAUD-1)

void main( void )
{
   ...
   USART_Init ( MYUBRR );
   ...
}

void USART_Init( unsigned int ubrr)
{
   /* Установка baud rate */
   UBRRH = (unsigned char)(ubrr >> 8);
   UBRRL = (unsigned char)ubrr;
   /* Разрешить приемник и передатчик */
   UCSRB = (1 << RXEN)|(1 << TXEN);
   /* Установка формата фрейма: 8data, 2stop bit */
   UCSRC = (1 << USBS)|(3 << UCSZ0);
}

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

[Передача данных – USART Transmitter]

Передатчик USART разрешается путем установки бита Transmit Enable (TXEN) в регистре UCSRnB. Когда передатчик разрешен, нормальное функционирование порта GPIO для вывода TxDn переназначается на аппаратную функцию последовательного выхода данных USART. Параметры baud rate, режим работы и формат фрейма должны быть настроены перед осуществлением любых передач. Если используется синхронный режим работы, то такты вывода XCKn принудительно будут использоваться для тактирования передачи.

Передача фреймов размером от 5 до 8 бит данных. Передача начинается с загрузки буфера передачи данными, которые должны быть переданы. CPU может загрузить данные в буфер передачи путем записи регистра UDRn по его адресу размещения в пространстве I/O. Данные, находящиеся в буфере передачи, переместятся в регистр сдвига, и будут готовы к отправке в новом фрейме. Регистр сдвига загружается новыми данными если USART находится в состоянии ожидания idle (нет активной передачи) или сразу после завершения последнего stop-бита предыдущего переданного фрейма. Когда регистр сдвига загружен новыми данными, они будут передаваться в полном фрейме со скоростью, заданной регистром Baud Register и битом U2Xn, или в зависимости от режима работы скорость будет определятся тактами на XCKn.

Следующие примеры кода показывают простую функцию передачи USART, основанную на опросе флага Data Register Empty (UDREn). Когда используются фреймы меньше 8 бит, самый старший бит, записанный в UDRn, будет игнорироваться. USART должен быть инициализирован перед тем, как можно будет использовать функцию передачи. Для кода на ассемблере подразумевается, что передаваемые данных сохранены в регистре R16.

USART_Transmit:

; Ожидание опустошения буфера передачи
   lds r17, UCSRnA
   sbrs r17, UDREn
   rjmp USART_Transmit

; Поместить данные (r16) в буфер, отправка данных
   sts UDRn,r16
   ret

void USART_Transmit( unsigned char data )
{
   /* Ожидание опустошения буфера передачи */
   while ( !( UCSRnA & (1 << UDREn)) )
   {
   }
   /* Поместить данные в буфер, отправка данных */
   UDRn = data;
}

Функция просто ждет, пока буфер передачи не опустошится, путем постоянного опроса флага UDREn, перед тем как загрузить новые данные для передачи. Если бы было задействовано прерывание по опустошению буфера Data Register Empty, то обработчик этого прерывания записал бы данные в буфер передачи (и было бы сэкономлено время процессора, затраченное на пустые циклы ожидания опустошения буфера).

Передача фреймов размером 9 бит данных. Если используются 9-разрядные символы (UCSZn = 7), то старший девятый бит должен быть записан в бит TXB8 регистра UCSRnB перед тем, как младшие 8 бит символа должны быть записаны в регистр UDRn. Следующие примеры кода показывают функцию передачи, которая поддерживает передачу символов из 9-бит. Для кода ассемблера подразумевается, что данные для отправки сохранены в регистровой паре R17:R16.

USART_Transmit:

; Ожидание опустошения буфера передачи
   sbis UCSRnA,UDREn
   rjmp USART_Transmit

; Копирование 9-го бита из r17 в TXB8
   cbi UCSRnB,TXB8
   sbrc r17,0
   sbi UCSRnB,TXB8

; Поместить LSB данные (r16) в буфер, отправка данных
   sts UDRn,r16
   ret

void USART_Transmit( unsigned int data )
{
   /* Ожидание опустошения буфера */
   while ( !( UCSRnA & (1 << UDREn))) )
   {
   }
   /* Копирование 9-го бита в TXB8 */
   UCSRnB &= ~(1 << TXB8);
   if ( data & 0x0100 )
   UCSRnB |= (1 << TXB8);
   /* Поместить данные в буфер, отправка данных */
   UDRn = data;
}

Примечание: эти функции передачи написаны только для примера. Они могут быть оптимизированы, если содержимое UCSRnB статическое. Например, после инициализации в регистре UCSRnB используется только бит TXB8.

9-й бит может использоваться для того, чтобы показать адрес фрейма в режиме обмена с несколькими процессорами (multi processor communication mode) или для другого протокола, например для синхронизации.

Флаги передатчика и прерывания. У передатчика USART есть 2 флага, которые показывают его состояние: USART Data Register Empty (UDREn) и Transmit Complete (TXCn). Оба флага можно использовать для генерации прерываний.

Флаг Data Register Empty (UDREn) показывает, готов или нет буфер передачи к записи туда новых данных. Этот бит устанавливается, когда буфер передачи опустошается, и очищается, когда буфер передачи содержит данные для отправки, которые еще пока не перемещены в регистр сдвига. Для совместимости с микроконтроллерами, которые возможно появятся в будущем, всегда записывайте этот бит в 0, когда записываете регистр UCSRnA.

Когда в бит Data Register Empty Interrupt Enable (UDRIEn) регистра UCSRnB записана 1, будет возможен запуск прерывания USART Data Register Empty, если установлен бит UDREn (подразумевается, что глобально прерывания разрешены).

UDREn очищается путем записи UDRn. Когда используется передача данных с управлением по прерываниям, подпрограмма прерывания Data Register Empty должна либо записать новые данные в UDRn, чтобы очистить UDREn, либо запретить прерывание Data Register Empty, иначе новое прерывание запустится после завершения обработчика прерывания.

Бит флага Transmit Complete (TXCn) устанавливается в 1, когда весь фрейм в регистре сдвига передачи будет выдвинут наружу, и в буфере передачи нет новых данных. Бит флага TXCn Flag автоматически очищается, когда запускается прерывание transmit complete, или этот флаг может быть очищен записью в него лог. 1. Флаг TXCn полезен при полудуплексном обмене (наподобие стандарта RS-485), где передающее приложение должно войти в режим приема и немедленно освободить шину обмена после завершения передачи.

Если бит Transmit Compete Interrupt Enable (TXCIEn) в регистре UCSRnB установлен, запустится прерывание USART Transmit Complete, когда установится флаг TXCn (подразумевается, что глобально прерывания разрешены). Когда используется прерывание transmit complete, обработчику прерывания не нужно очищать флаг TXCn, это автоматически произойдет, когда сработает прерывание.

Parity Generator. Генератор четности (Parity Generator) вычисляет бит четности для последовательного фрейма данных. Когда разрешен бит четности (UPMn1 = 1), логика управления передатчиком вставляет бит четности между последним битом данных и первым stop-битом отправляемого фрейма.

Запрет передатчика. Запрет передатчика (сброс TXEN в 0) не вступит в силу, пока происходит активная передача, т. е. пока регистр сдвига и регистр буфера передачи еще содержат данные для передачи. После того, как передатчик запрещен, но больше не будет переназначать вывод порта TxDn.

[Прием данных – USART Receiver]

Приемник USART разрешатся путем записи бита Receive Enable (RXENn) регистра UCSRnB в 1. Когда приемник разрешен, нормальная работа порта RxDn переназначается аппаратурой USART, и этот порт становится входом приемника для последовательных данных. Параметры baud rate, режима работы и формат фрейма должны быть установлены до того, как можно будет осуществлять любой прием. Если используется синхронный режим, то вывод XCKn будет использоваться как такты приема.

Прием фреймов длиной от 5 до 8 бит данных. Приемник начнет прием данных, когда детектирует допустимый start-бит. Каждый бит, который следует за стартовым, будет оцифровывается на скорости baud rate, или с тактами XCKn, и вдвигаться регистр сдвига, пока не будет принят первый stop-бит фрейма. Второй stop-бит будет приемником игнорироваться. Когда будет принят первый stop-бит, т. е. когда полный фрейм присутствует в регистре сдвига, то содержимое регистра сдвига будет перемещено в буфер приема. Буфер приема может быть прочитан через UDRn.

Следующий пример кода показывает простую функцию приема USART на базе опроса флага Receive Complete (RXCn). Когда используются фреймы размером меньше 8 бит, самый старший бит байта данных, прочитанного из UDRn, будет маскирован нулем. USART должен быть инициализирован перед использованием этой функции.

USART_Receive:

; Ожидание поступления данных
   lds r17, UCSRnA
   sbrs r17, RXCn
   rjmp USART_Receive

; Получить и возвратить данные из буфера
   lds r16, UDRn
   ret

unsigned char USART_Receive( void )
{
   /* Ожидание поступления данных */
   while ( !(UCSRnA & (1 << RXCn)) )
   {
   }
   /* Получить и возвратить данные из буфера */
   return UDRn;
}

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

Прием фреймов длиной 9 бит данных. Если используются 9-битные символы (UCSZn=7), то 9-й бит должен быть прочитан из бита RXB8n регистра UCSRnB до чтения младших 8 бит из UDRn. То же самое правило действует и для флагов состояния FEn, DORn и UPEn. Сначала прочитайте состояние из UCSRnA, затем данные из UDRn. Чтение UDRn по его адресу I/O поменяет состояние приемного буфера FIFO и следовательно поменяется состояние битов TXB8n, FEn, DORn и UPEn, которые все сохраняются в FIFO.

Следующий пример кода покажет простую функцию приема USART, которая обрабатывает как 9-й бит, так и биты статуса.

USART_Receive:

; Ожидание поступления данных
   lds r17, UCSRnA
   sbrs r17, RXCn
   rjmp USART_Receive

; Получить состояние и 9-й бит, и затем данные из буфера
   lds r18, UCSRnA
   lds r17, UCSRnB
   lds r16, UDRn

; Если ошибка, вернуть -1
   andi r18,(1 << FEn)|(1 << DORn)|(1 << UPEn)
   breq USART_ReceiveNoError
   ldi r17, HIGH(-1)
   ldi r16, LOW(-1)USART_ReceiveNoError:

; фильтр 9-го бита, вернуть символ
   lsr r17
   andi r17, 0x01
   ret

unsigned int USART_Receive( void )
{
   unsigned char status, resh, resl;
   /* Ожидание поступления данных */
   while ( !(UCSRnA & (1 << RXCn)) )
   {
   }
   /* Получить состояние и 9-й бит, затем данные из буфера */
   status = UCSRnA;
   resh = UCSRnB;
   resl = UDRn;
   /* Если ошибка, вернуть -1 */
   if ( status & (1 << FEn)|(1 << DORn)|(1 << UPEn) )
      return -1;
   /* Фильтр 9-го бита, и возврат символа */
   resh = (resh >> 1) & 0x01;
   return ((resh << 8) | resl);
}

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

Флаг и прерывание Receive Compete. У приемника USART есть 1 флаг, который показывает состояние приемника. Флаг Receive Complete (RXCn) показывает, что в буфере приема есть не прочитанные данные. Этот флаг равен 1, когда не прочитанные данные есть в буфере приема, и 0, когда буфер приема пуст (т. е. в нем не содержится никаких не прочитанных данных). Если приемник запрещен (RXENn = 0), буфер приема сбрасывается, и следовательно флаг RXCn обнуляется.

Когда установлен бит Receive Complete Interrupt Enable (RXCIEn) в регистре UCSRnB, выполнится прерывание USART Receive Complete, когда флаг RXCn установится (подразумевается, что глобально прерывания разрешены). Когда работает прием данных по прерываниям, то подпрограмма обработчика прерывания Receive Complete должна прочитать принятые данные UDRn, чтобы очистить флаг RXCn, иначе после завершения работы обработчика прерывания снова запуститься тот же обработчик прерывания.

Флаги ошибок приемника. У приемника USART есть 3 флага ошибки: Frame Error (FEn), Data OverRun (DORn) и Parity Error (UPEn). Все биты ошибок доступны через чтение UCSRnA. Общим для флагов ошибок является то, тчо они размещены в буфере приема вместе с данными фрейма, для которого флаги ошибок показывают состояние (т. е. буферизация данных фрейма привязана к буферизации флагов ошибки). По этой причине сначала нужно прочитать UCSRnA, и только потом буфер данных приема (UDRn), поскольку чтение UDRn по его месту размещения I/O освободит буфер под новые данные. Еще флаги ошибок объединяет то, что их нельзя сбросить программно записью. Однако для обеспечения совместимости с изменениями в USART, которые возможно появятся в будущем, все флаги должны быть сброшены в 0, когда осуществляется запись UCSRnA. Флаги ошибки не могут генерировать прерывание.

Флаг Frame Error (FEn) показывает состояние первого stop-бита принятого фрейма, находящегося в буфере приема. Флаг FEn равен 0, если stop-бит был прочитан правильно (как 1), и флаг FEn будет в 1, когда stop-бит ошибочен (равен 0). Этот флаг может использоваться для детектирования событий выхода из синхронизации, событий остановки потока (break conditions) и поддержки обработки протокола. На флаг FEn не влияет настройка бита USBSn в регистре UCSRnC, поскольку приемник игнорирует все stop-биты, кроме первого. Для обеспечения совместимости с микроконтроллерами, который возможно появятся в будущем, всегда сбрасывайте этот бит в 0, когда записываете UCSRnA.

Флаг Data OverRun (DORn) показывает потерю данных, из-за того, что у буфере приемника были не прочитанные данные. Data OverRun произойдет, когда буфер приема заполнен (в нем находится 2 символа), ожидается прием следующего символа, и детектирован новый start-бит. Если флаг DORn установлен, то была потеря одного или большего количества фреймов между последним чтением и следующим чтением фрейма из UDRn. Для обеспечения совместимости с микроконтроллерами, который возможно появятся в будущем, всегда записывайте этот бит в 0, когда записываете UCSRnA. Флаг DORn очищается, когда принятый фрейм успешно перемещен из регистра сдвига в буфер приема.

Флаг ошибки четности Parity Error (UPEn) показывает, что следующий фрейм, находящийся в буфере приема, имеет ошибку четности на приеме. Если контроль четности не разрешен, то бит UPEn будет всегда читаться как 0. Для обеспечения совместимости с микроконтроллерами, который возможно появятся в будущем, всегда сбрасывайте этот бит в 0, когда пишете в UCSRnA.

Узел проверки бита четности (Parity Checker) активен, когда установлен в 1 бит USART Parity mode (UPMn1). Тип выполняемой проверки на четность (нечетность odd или четность even) выбирается битом UPMn0. Когда проверка четности разрешена, Parity Checker вычисляет четность от бит данных приходящих фреймов, и сравнивает результат с битом четности из последовательного фрейма. Результат проверки сохраняется в буфере приема вместе с принятыми данными и stop-битами. Флаг Parity Error (UPEn) может быть прочитан программно, чтобы проверить, была ли во фрейме ошибка четности.

Бит UPEn установится, если в следующем символе, который можно прочитать из буфера приема, была ошибка четности на приеме, и проверка четности в этот момент была разрешена (UPMn1 = 1). Этот бит действителен, пока не произойдет чтение буфера приема (регистра UDRn).

Запрет приемника. В отличие от передатчика, запрет приемника срабатывает немедленно. Таким образом, принимаемый в настоящий момент фрейм данных (и конечно последующие после запрета) будут потеряны. Когда приемник запрещен (т. е. RXENn сброшен в 0), то он больше не переназначает нормальную работу порта RxDn как ножки GPIO. При запрете приемника буфер FIFO приемника будет сброшен, все оставшиеся в нем непрочитанные данные будут потеряны.

Сброс буфера приема. Буфер FIFO приемника будет сброшен, когда приемник запрещен, т. е. запомненные в буфере данные уничтожаются, непрочитанные данные будут потеряны. Если нужно сбросить буфер во время нормальной работы, например по причине события ошибки, просто делайте чтение UDRn, пока флаг RXCn не очистится. В следующем примере кода показана очистка буфера приема.

USART_Flush:
   sbis UCSRnA, RXCn
   ret
   in r16, UDRn
   rjmp USART_Flush

void USART_Flush( void )
{
   unsigned char dummy;
   while ( UCSRnA & (1 << RXCn) )
      dummy = UDRn;
}

[Асинхронный прием данных]

В состав USART включены блоки восстановления тактов (Asynchronous Clock Recovery) и данных (Asynchronous Data Recovery), чтобы поддержать асинхронный прием данных. Логика восстановления используется для синхронизации генерируемых внутри тактов скорости (baud rate) для входящих асинхронных последовательных фреймов на выводе RxDn. Логика восстановления данных оцифровывает и пропускает через ФНЧ каждый бит приходящих данных, чтобы улучшить стойкость приемника к помехам. Диапазон работоспособности асинхронного приема зависит от точности внутренних тактов скорости, скорости входящих фреймов, размера фрейма в количестве бит.

Asynchronous Clock Recovery. Логика восстановления тактов синхронизирует внутренние такты по входящим последовательным фреймам. На рис. 22-5 показан процесс оцифровки стартового бита входящего фрейма. Частота оцифровки в 16 раз больше частоты бит (baud rate) для нормального режима (Normal mode), и в 8 раз больше частоты бит для режима двойной скорости (Double Speed mode). Горизонтальные стрелки показывают интервалы подстройки синхронизации в процессе оцифровки. Обратите внимание на увеличенные интервалы для режима двойной скорости (Double Speed mode, U2Xn = 1). Выборки, помеченные нулями, означают выборки, когда сигнал RxDn в состоянии ожидания idle (т. е. нет активной передачи).

ATmega2560 USART Start bit Sampling fig22 5

Рис. 22-5. Выборка (оцифровка) start-бита.

Когда логика восстановления тактов детектировала переход от лог. 1 (idle) к лог. 0 (start) на линии RxDn, инициируется последовательность детектирования start-бита. Выборка 1 на рисунке показывает первую нулевую выборку. Затем логика восстановления тактов использует выборки 8, 9 и 10 для нормального режима, и выборки 4, 5 и 6 для режима двойной скорости (эти цифры выделены прямоугольной рамкой на рисунке), чтобы определить, что действительно принят допустимый start-бит. Если 2 или большее количество этих выборок имеют лог. 1 (принцип большинства), то start-бит отбрасывается как шумовая помеха, и приемник снова начинает детектирование следующего перехода от 1 к 0. Однако если детектирован допустимый start-бит ("большинство" указывает на 0), то в логика восстановления тактов синхронизируется, и может начаться процесс восстановления данных. Процесс синхронизации повторяется для каждого start-бита.

Asynchronous Data Recovery. Когда произошла синхронизация тактов приемника по start-биту, может начать работу восстановление данных. Блок восстановления данных использует машину из 16 состояний для каждого бита в нормальном режиме и машину 8 состояний для режима двойной скорости. На рис. 22-6 показана оцифровка битов данных и бита четности (BITn). Каждая выборка помечена цифрой, которая равна состоянию блока восстановления.

ATmega2560 USART Sampling Data and Parity bit fig22 6

Рис. 22-6. Выборка данных и бита четности.

Принятие решения о лог. уровне принятого бита выполняется по тому же самому "принципу большинства" на 3 выборках посередине принимаемого бита. Номера этих выборок помечены на рисунке рамочками. Если 2 или большее количество из этих 3 выборок прочитаны как 1, то принятый бит регистрируется как лог. 1. И аналогично если 2 или большее количество из этих 3 выборок прочитаны как 0, то принятый бит регистрируется как лог. 0. Этот принцип работает как простейший цифровой ФНЧ для входящего сигнала на выводе RxDn. Процесс восстановления данных повторяется для каждого бита, пока не завершится прием всего фрейма, включая первый stop-бит. Имейте в виду, что приемник использует только первый stop-бит фрейма.

На рис. 22-7 показана оцифровка stop-бита как можно раньше относительно начала start-бита следующего фрейма.

ATmega2560 USART Sampling Stop bit and Next Start bit fig22 7

Рис. 22-7. Выборка стоп-бита и следующего стартового бита.

Для оцифровки (получения значения) stop-бита применяется тот же самый мажоритарный принцип голосования, как и для других бит фрейма. Если определено, что stop-бит равен лог. 0, то регистрируется ошибка фрейма, и будет установлен флаг Frame Error (FEn).

Новый переход 1 -> 0 покажет начало start-бита нового фрейма, и он может появиться сразу после последнего бита, в котором использовалось детектирование уровня по мажоритарному принципу. Для режима Normal Speed, первая выборка с низким уровнем может быть в точке, промаркированной как (A) на рис. 22-7. Для Double Speed mode первый низкий уровень должен быть задержан до (B). (C) помечает stop-бит полной длины. Раннее детектирование start-бита влияет на рабочий диапазон приемника (Asynchronous Operational Range).

Asynchronous Operational Range. Рабочий диапазон приемника зависит от несоответствия скорости принимаемых бит и генерируемой внутри скорости. И передатчик, и приемник должны быть настроены на одну и ту же скорость, но из-за погрешности частоты системного тактового генератора реальные частоты могут отличаться. Если передатчик посылает фреймы со слишком большой частотой бит или слишком малой частотой бит, или если генерируемая частота бит приемника имеет отличающуюся базовую частоту (см. таблицу 22-2), то приемник не сможет синхронизировать фреймы по start-биту.

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

(D + 1) * S
R_slow = ----------------------
S - 1 + D*S + S_F

(D + 2) * S
R_fast = ----------------------
(D + 1) * S + S_M

D сумма числа бит символа и бита четности (D = 5 .. 10 бит).
S количество выборок на бит, S = 16 для Normal Speed mode и S = 8 для Double Speed mode.
S_F номер первой выборки, используемой для детектирования уровня по мажоритарному принципу. SF = 8 для Normal Speed mode и SF = 4 для Double Speed mode.
S_M номер средней выборки, используемой для детектирования уровня по мажоритарному принципу. SM = 9 для Normal Speed mode и SM = 5 для Double Speed mode.
R_slow соотношение между самой низкой входной скоростью и собственной скоростью приемника, при котором приемник все еще может принимать данные.
R_fast соотношение между самой высокой входной скоростью и собственной скоростью приемника, при котором приемник все еще может принимать данные.

Таблицы 22-2 и 22-3 дают список максимально допустимой ошибки baud rate приемника. Обратите внимание, что для Normal Speed mode допуск больше.

Табл. 22-2. Рекомендуемые максимальные скорости передачи и погрешность приемника для нормального режима скорости (U2Xn = 0).

D (Data + Parity Bit)	R_slow (%)	R_fast (%)	MAX общая ошибка, %	Рекомендуемая MAX ошибка приемника, %
5	93.20	106.67	+6.67 / -6.8	±3.0
6	94.12	105.79	+5.79 / -5.88	±2.5
7	94.81	105.11	+5.11 / -5.19	±2.0
8	95.36	104.58	+4.58 / -4.54	±2.0
9	95.81	104.14	+4.14 / -4.19	±1.5
10	96.17	103.78	+3.78 / -3.83	±1.5

Табл. 22-3. Рекомендуемые максимальные скорости передачи и погрешность приемника для двойной скорости (U2Xn = 1).

D (Data + Parity Bit)	R_slow (%)	R_fast (%)	MAX общая ошибка, %	Рекомендуемая MAX ошибка приемника, %
5	94.12	105.66	+5.66 / -5.88	±2.5
6	94.92	104.92	+4.92 / -5.08	±2.0
7	95.52	104.35	+4.35 / -4.48	±1.5
8	96.00	103.90	+3.90 / -4.00	±1.5
9	96.39	103.53	+3.53 / -3.61	±1.5
10	96.70	103.23	+3.23 / -3.30	±1.0

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

Есть 2 возможных источника ошибок baud rate приемника. Системная тактовая частота приемника (XTAL) всегда будет незначительно зависеть от напряжения питания и температуры окружающей среды. Когда для генерации системной частоты используется кварц, то в этом случае проблем чаще всего не будет. Однако если применить некачественный резонатор с допуском более 2%, то это может послужить причиной ошибок. Второй источник ошибки более управляемый. Генератор baud rate не всегда делает точное деление системной частоты, чтобы получить желаемое значение baud rate. В этом случае желательно использовать то значение для UBRR, которое дает ошибку как можно меньше.

[Multi-processor Communication Mode]

Установка бита Multi-processor Communication mode (MPCMn) в регистре UCSRnA разрешает функцию фильтрации входящих фреймов, полученных приемником USART. Фреймы, которые не содержат информацию адреса, будут игнорироваться и не попадут в буфер приема. Это эффективно уменьшит количество входящих фреймов, которые должны быть программно обработаны CPU в системе, где несколько процессоров (MCU) обмениваются данными по одной и той же последовательной шине данных. На передатчик не влияет установка бита MPCMn, но передатчик должен использоваться по-другому, когда он работает как часть системы, использующей Multi-processor Communication mode.

Если приемник настроен для приема фреймов, содержащих от 5 до 8 бит данных, то первый stop-бит показывает, есть ли во фрейме информация адреса. Если приемник настроен на фреймы с 9 битами данных, то 9-й бит (RXB8n) используется для идентификации фреймов адреса и данных. Когда бит типа фрейма (это первый stop-бит или 9-й бит) равен 1, то фрейм содержит адрес. Когда бит типа фрейма равен 0, то это будет фрейм данных.

Multi-processor Communication mode разрешает нескольким подчиненным MCU принимать данные от главного MCU. Это осуществляется путем декодирования фрейма адреса, чтобы определить, какой именно MCU адресован на шине. Если адресован конкретный подчиненный MCU, то он примет следующие фреймы данных как обычно, в то время другие подчиненные MCUs будут игнорировать принятые фреймы, пока не будет принят другой адресный фрейм.

Использование MPCMn. Для MCU, который работает как главный на общей шине, можно использовать 9-битный формат фрейма (UCSZn = 7). Девятый бит (TXB8n) должен быть установлен, когда передается фрейм адреса (TXB8n = 1), или очищен, когда передается фрейм данных (TXB = 0). Подчиненные MCU в этом случае должны быть настроены для использования 9-битного формата фрейма.

Для обмена данными в Multi-processor Communication mode должна использоваться следующая процедура:

1. Все подчиненные MCU настроены в Multi-processor Communication mode (установлен бит MPCMn в регистре UCSRnA).

2. Главный MCU посылает фрейм адреса, и все подчиненные устройства принимают и читают этот фрейм. В подчиненных MCU флаг RXCn в регистре UCSRnA будет установлен как обычно.

3. Каждый подчиненный MCU читает регистр UDRn, чтобы определить, что для приема выбран именно он (проверяет совпадение адреса). Если так, то он очищает бит MPCMn в регистре UCSRnA, в противном случае просто ждет следующего адресного фрейма, сохраняя установленным бит MPCMn.

4. Адресованный MCU будет принимать все фреймы данных, пока не поступит новый фрейм адреса. Другие подчиненные MCUs, у которых установлен бит MPCMn, будут (аппаратно) игнорировать фреймы данных.

5. Когда адресованный MCU примет последний фрейм данных, то он устанавливает бит MPCMn и ждет новый фрейм адреса от главного MCU. Затем процедура повторяется начиная с шага 2.

Можно использовать любой формат фрейма от 5 до 8 бит, но это непрактично, потому что приемник нужно перепрограммировать между использованием n и n+1 форматом бит фрейма. Это делает полнодуплексный обмен сложным, потому что передатчик и приемник используют настройку для одного и того же размера символа. Если используется формат символа от 5 до 8 бит, то передатчик должен быть установлен на использование двух stop-битов (USBSn = 1), поскольку первый stop-бит используется для указания типа фрейма (адрес или данные).

Не используйте инструкции ассемблера Read-Modify-Write (SBI и CBI) для установки или очистки бита MPCMn. Бит MPCMn использует то же самое место в пространстве I/O, как и флаг TXCn, и это может случайно очистить его при использовании инструкций SBI или CBI.

USART ATmega2560 может также работать в режиме SPI, но здесь этот вариант настройки USART не рассматривается.

Регистры USART ATmega2560

UDRn – USART I/O Data Register n

№ разрядов	7	6	5	4	3	2	1	0
Регистры	RXB[7:0] (UDRn при чтении)
Регистры	TXB[7:0] (UDRn при записи)
Чтение/запись	rw	rw	rw	rw	rw	rw	rw	rw
Нач. значение	0	0	0	0	0	0	0	0

Регистры USART Transmit Data Buffer (TXB) и Receive Data Buffer (RXB) разделяют одну и ту же ячейку пространства адресов I/O, которая носит мнемоническое название USART Data Register, или UDRn. TXB будет точкой назначения для записываемых в UDRn данных. Чтение UDRn вернет данные из RXB.

Для 5, 6 или 7-разрядных символов верхние неиспользуемые биты будут игнорироваться при передаче и автоматически обнуляться при приеме.

Буфер передачи можно записать только тогда, когда установлен флаг UDREn в регистре UCSRnA. Данные, записанные в UDRn, когда флаг UDREn не установлен, будут игнорироваться передатчиком USART. Если данные записаны в буфер передачи, и передатчик разрешен, то передатчик загрузит данные в регистр сдвига передачи, когда регистр сдвига пуст. Тогда данные будут последовательно передаваться через вывод TxDn.

Буфер приема состоит из 2-уровневого FIFO. FIFO поменяет свое состояние независимо от того, был ли к нему доступ, или нет. Из-за этого поведения буфера приема не используйте для него инструкции ассемблера Read-Modify-Write (SBI и CBI). Будьте осторожны, когда используете инструкции проверки бит (SBIC и SBIS), поскольку они также изменят состояние FIFO.

UCSRnA – USART Control and Status Register A

№ разрядов	7	6	5	4	3	2	1	0
Имена бит	RXCn	TXCn	UDREn	FEn	DORn	UPEn	U2Xn	MPCMn
Чтение/запись	r	rw	r	r	r	r	rw	rw
Нач. значение	0	0	1	0	0	0	0	0

• 7 – RXCn: USART Receive Complete

Этот флаг установится, когда в буфере приема есть непрочитанные данные, и очищается, когда буфер приема пуст (т. е. в нем не содержатся какие-либо непрочитанные данные). Если приемник запрещен, то буфер приема сбрасывается, следовательно бит RXCn становится нулем. Флаг RXCn может использоваться для генерации прерывания Receive Complete (см. описание бита RXCIEn).

• 6 – TXCn: USART Transmit Complete

Этот бит установится, когда весь фрейм в регистре сдвига передачи выдвинут на выход, так что в настоящий момент нет новых данных в буфере передачи (UDRn). Флаг TXCn автоматически очищается, когда запускается прерывание Transmit Complete, или этот бит может быть очищен программно записью туда 1. Флаг TXCn может генерировать прерывание Transmit Complete (см. описание бита TXCIEn).

• 5 – UDREn: USART Data Register Empty

Флаг UDREn показывает, что буфер передачи (UDRn) пуст и готов к записи туда новых данных. Если бит UDREn в состоянии 1, то буфер пуст, и туда можно записать новый символ для передачи. Флаг UDREn может генерировать прерывание Data Register Empty (см. описание бита UDRIEn).

UDREn устанавливается после сброса, показывая этим, что передатчик готов к работе.

• 4 – FEn: Frame Error

Этот бит установится, если следующий символ в буфере приема получил ошибку фрейма, т. е. когда первый stop-бит оказался нулевым. Этот бит действителен, пока не будет прочитан буфер приема (UDRn), т. е. этот флаг привязан с принятому символу. FEn равен 0, когда stop-бит принятого фрейма равен 1 (нормальная ситуация, ошибки нет). Всегда сбрасывайте этот бит, когда записываете регистр UCSRnA.

• 3 – DORn: Data OverRun

Этот бит установится, если детектировано событие Data OverRun. Оно произойдет, когда буфер приема заполнен (в нем находится 2 принятых символа), ожидается прием нового символа, и был детектирован новый start-бит. Этот бит действителен, пока не будет прочитан буфер приема (UDRn), т. е. этот флаг привязан с принятому символу. Всегда сбрасывайте этот бит, когда записываете регистр UCSRnA.

• 2 – UPEn: USART Parity Error

Этот бит установится, если следующий символ в буфере приема имеет ошибку четности на приеме, и в момент его приема была разрешена проверка четности (UPMn1 = 1). Этот бит действителен, пока не будет прочитан буфер приема (UDRn), т. е. этот флаг привязан с принятому символу. Всегда сбрасывайте этот бит, когда записываете регистр UCSRnA.

• 1 – U2Xn: Double the USART Transmission Speed

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

Запись в этот бит лог. 1 уменьшит в 2 раза коэффициент деления генератора скорости (с 16 до 8), так что в асинхронном режиме скорость увеличится в 2 раза.

• 0 – MPCMn: Multi-processor Communication Mode

Этот бит разрешит работу Multi-processor Communication mode. Когда этот бит в 1, все входящие фреймы, принятые приемником USART, не содержащие информации адреса, будут игнорированы. Этот бит не влияет на передатчик. Подробнее см. описание "Multi-processor Communication Mode".

UCSRnB – USART Control and Status Register B

№ разрядов	7	6	5	4	3	2	1	0
Имена бит	RXCIEn	TXCIEn	UDRIEn	FERXENn n	TXENn	UCSZn2	RXB8n	TXB8n
Чтение/запись	rw	rw	rw	rw	rw	rw	r	rw
Нач. значение	0	0	0	0	0	0	0	0

• 7 – RXCIEn: RX Complete Interrupt Enable n

Запись в этот бит 1 разрешает работу прерывания по флагу RXCn. Прерывание USART Receive Complete будет сгенерировано, если бит RXCIEn записан в 1, разрешены глобально прерывания (установлен в 1 Global Interrupt Flag в SREG), и установился в 1 бит RXCn регистра UCSRnA.

• 6 – TXCIEn: TX Complete Interrupt Enable n

Запись этого бита в 1 разрешает работу прерывания по флагу TXCn. Прерывание USART Transmit Complete будет сгенерировано, если бит RXCIEn записан в 1, разрешены глобально прерывания (установлен в 1 Global Interrupt Flag в SREG), и установился в 1 бит TXCn в регистре UCSRnA.

• 5 – UDRIEn: USART Data Register Empty Interrupt Enable n

Запись в этот бит 1 разрешает работу прерывания по флагу UDREn. Прерывание Data Register Empty будет сгенерировано, если бит RXCIEn записан в 1, разрешены глобально прерывания (установлен в 1 Global Interrupt Flag в SREG), и установился в 1 бит UDREn в регистре UCSRnA.

• 4 – RXENn: Receiver Enable n

Запись этого бита в 1 разрешает работу приемника USART. Приемник переназначит нормальную работу ножки порта как GPIO, и она станет входом приемника RxDn. Запрет приемника очистит буфер приема и сделает недействительными флаги FEn, DORn и UPEn.

• 3 – TXENn: Transmitter Enable n

Запись этого бита в 1 разрешает работу передатчика USART. Передатчик переназначит нормальную работу ножки порта как GPIO, и она станет выходом передатчика TxDn. Запрет передатчика (запись в TXENn нуля) не вступит в силу, пока не завершится текущие передачи, т. е. пока не опустошаться регистр сдвига передачи и буфер передачи. Когда передатчик запрещен, то он не занимает порт TxDn под выход передатчика (порт может работать как обычный GPIO).

• 2 – UCSZn2: Character Size n

Бит UCSZn2 комбинируется с битами UCSZn1:0 регистра UCSRnC, и вместе с ними задает количество бит данных (Character SiZe) в фрейме передатчика и приемника.

• 1 – RXB8n: Receive Data Bit 8 n

RXB8n содержит 9-й бит данных принятого символа, когда осуществляется работа с последовательными фреймами из 9 бит данных. Бит RXB8n должен быть прочитан перед чтением младших бит из UDRn.

• 0 – TXB8n: Transmit Data Bit 8 n

TXB8n содержит 9-й бит данных передаваемого символа, когда осуществляется работа с последовательными фреймами из 9 бит данных. Бит TXB8n должен быть записан перед записью младших бит в UDRn.

UCSRnC – USART Control and Status Register C

№ разрядов	7	6	5	4	3	2	1	0
Имена бит	UMSELn1	UMSELn0	UPMn1	UPMn0	USBSn	UCSZn1	UCSZn0	UCPOLn
Чтение/запись	rw	rw	rw	rw	rw	rw	rw	rw
Нач. значение	0	0	0	0	0	1	1	0

• 7:6 – UMSELn1:0 USART Mode Select

Эти биты выбирают режим работы USARTn, как это показано в таблице 22-4.

Табл. 22-4. Настройки бит UMSELn.

UMSELn1	UMSELn1	Режим
0	0	Асинхронный USART
0	1	Синхронный USART
1	0	зарезервировано
1	1	Master SPI (MSPIM)⁽¹⁾

Примечание (1): см. в даташите раздел "USART in SPI Mode".

• 5:4 – UPMn1:0: Parity Mode

Эти биты разрешают проверку на четность и задают её тип. Если проверка на четность разрешена, то передатчик автоматически будет генерировать и передавать четность данных в каждом фрейме. Приемник будет генерировать значение четности для приходящих данных и сравнивать их с установкой UPMn. Если обнаружится несоответствие, то флаг UPEn в регистре UCSRnA будет установлен.

UPMn1	UPMn0	Режим проверки четности
0	0	Отключено
0	1	зарезервировано
1	0	Разрешено, проверка по четности (Even Parity)
1	1	Разрешено, проверка по нечетности (Odd Parity)

• 3 – USBSn: Stop Bit Select

Этот бит выбирает количество stop-битов, которые вставляет передатчик. Приемник эту настройку игнорирует.

USBSn	Количество стоп-битов
0	1
1	2

• 2:1 – UCSZn1:0: Character Size

Биты UCSZn1:0 в комбинации с битом UCSZn2 регистра UCSRnB устанавливают количество бит данных (Character SiZe) в фрейме передатчика и приемника.

UCSZn2	UCSZn1	UCSZn0	Размер символа, бит
0	0	0	5
0	0	1	6
0	1	0	7
0	1	1	8
1	0	0	зарезервировано
1	0	1
1	1	0
1	1	1	9

• Bit 0 – UCPOLn: Clock Polarity

Этот бит используется только в синхронном режиме. Запишите в этот бит 0, когда используется асинхронный режим работы. Бит UCPOLn устанавливает взаимосвязь между изменениями данных на выходе, выборкой данных на входе и тактами синхронизации (XCKn).

UCPOLn	Когда изменяются передаваемые данные (на выводе TxDn)	Когда считываются данные на входе (на выводе RxDn)
0	По нарастанию уровня на XCKn	По спаду уровня на XCKn
1	По спаду уровня на XCKn	По нарастанию уровня на XCKn

UBRRnL и UBRRnH – регистры USART Baud Rate

№ разрядов	15	14	13	12	11	10	9	8
UBRRHn	-	-	-	-	UBRR[11:8]
UBRRLn	UBRR[7:0]
№ разрядов	7	6	5	4	3	2	1	0
Чтение/запись	r	r	r	r	rw	rw	rw	rw
Чтение/запись	rw	rw	rw	rw	rw	rw	rw	rw
Нач. значение	0	0	0	0	0	0	0	0
Нач. значение	0	0	0	0	0	0	0	0

• 15:12 – резерв

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

• 11:0 – UBRR11:0: USART Baud Rate Register

Это 12-разрядный регистр, который содержит настройку скорости для USART (baud rate). UBRRH содержит 4 старших бита, UBRRL 8 младших USART baud rate. Текущая активная передача передатчика или активный прием приемника будут испорчены, если на лету была изменена скорость. Запись UBRRL приведет к немедленному обновлению прескалера в генераторе baud rate.

Примеры настройки Baud Rate

Для стандартных частот кварцев и резонаторов наиболее часто используемые скорости для асинхронного режима работы могут быть сгенерированы настройкой UBRR по таблицам от 22-9 до 22-12. Рекомендуется использовать настройки с погрешностью скорости 0.5% от целевой или менее. Более высокие погрешности допустимы, но в этом случае приемник будет меньше защищен от шумов, и вероятность возникновения ошибки будет больше, особенно на фреймах большого размера (см. раздел "Asynchronous Operational Range"). Значение ошибки установки скорости вычисляется по следующей формуле:

BaudRate_{ближайшая}
Error[%] = (------------------------ - 1) * 100%
BaudRate

Табл. 22-9. Примеры настройки UBRRn для наиболее часто используемых частот системного генератора.

Baud Rate [bps]	f_osc = 1.0000 МГц				f_osc = 1.8432 МГц				f_osc = 2.0000 МГц
	U2Xn = 0		U2Xn = 1		U2Xn = 0		U2Xn = 1		U2Xn = 0		U2Xn = 1
	UBRR	Error	UBRR	Error	UBRR	Error	UBRR	Error	UBRR	Error	UBRR	Error
2400	25	0.2%	51	0.2%	47	0	95	0	51	0.2%	103	0.2%
4800	12	0.2%	25	0.2%	23	0	47	0	25	0.2%	51	0.2%
9600	6	-7.0%	12	0.2%	11	0	23	0	12	0.2%	25	0.2%
14.4K	3	8.5%	8	-3.5%	7	0	15	0	8	-3.5%	16	2.1%
19.2K	2	8.5%	6	-7.0%	5	0	11	0	6	-7.0%	12	0.2%
28.8K	1	8.5%	3	8.5%	3	0	7	0	3	8.5%	8	-3.5%
38.4K	1	-18.6%	2	8.5%	2	0	5	0	2	8.5%	6	-7.0%
57.6K	0	8.5%	1	8.5%	1	0	3	0	1	8.5%	3	8.5%
78.8K	-	-	1	-18.6%	1	-25.0%	2	0	1	-18.6%	2	8.5%
115.2K	-	-	0	8.5%	0	0	1	0	0	8.5%	1	8.5%
230.4	-	-	-	-	-	-	0	0	-	-	-	-
250K	-	-	-	-	-	-	-	-	-	-	0	0
MAX⁽¹⁾	62.5K		125K		115.2K		230.4K		125K		250K

Примечание (1): UBRR = 0, Error = 0%.

Табл. 22-10. Примеры настройки UBRRn для наиболее часто используемых частот системного генератора.

Baud Rate [bps]	f_osc = 3.6864 МГц				f_osc = 4.0000 МГц				f_osc = 7.3728 МГц
	U2Xn = 0		U2Xn = 1		U2Xn = 0		U2Xn = 1		U2Xn = 0		U2Xn = 1
	UBRR	Error	UBRR	Error	UBRR	Error	UBRR	Error	UBRR	Error	UBRR	Error
2400	95	0	191	0	103	0.2%	207	0.2%	191	0	383	0
4800	47	0	95	0	51	0.2%	103	0.2%	95	0	191	0
9600	23	0	47	0	25	0.2%	51	0.2%	47	0	95	0
14.4K	15	0	31	0	16	2.1%	34	-0.8%	31	0	63	0
19.2K	11	0	23	0	12	0.2%	25	0.2%	23	0	47	0
28.8K	7	0	15	0	8	-3.5%	16	2.1%	15	0	31	0
38.4K	5	0	11	0	6	-7.0%	12	0.2%	11	0	23	0
57.6K	3	0	7	0	3	8.5%	8	-3.5%	7	0	15	0
78.8K	2	0	5	0	2	8.5%	6	-7.0%	5	0	11	0
115.2K	1	0	3	0	1	8.5%	3	8.5%	3	0	7	0
230.4	0	0	1	0	0	8.5%	1	8.5%	1	0	3	0
250K	0	-7.8%	1	-7.8%	0	0	1	0	1	-7.8%	3	-7.8%
0.5M	-	-	0	-7.8%	-	-	0	0	0	-7.8%	1	-7.8%
1M	-	-	-	-	-	-	-	-	-	-	0	-7.8%
MAX⁽¹⁾	230.4K		480.8K		250K		0.5M		460.8K		921.6K

Примечание (1): UBRR = 0, Error = 0%.

Табл. 22-11. Примеры настройки UBRRn для наиболее часто используемых частот системного генератора.

Baud Rate [bps]	f_osc = 8.0000 МГц				f_osc = 11.0592 МГц				f_osc = 14.7456 МГц
	U2Xn = 0		U2Xn = 1		U2Xn = 0		U2Xn = 1		U2Xn = 0		U2Xn = 1
	UBRR	Error	UBRR	Error	UBRR	Error	UBRR	Error	UBRR	Error	UBRR	Error
2400	207	0.2%	416	-0.1%	287	0	575	0	383	0	767	0
4800	103	0.2%	207	0.2%	143	0	287	0	191	0	383	0
9600	51	0.2%	103	0.2%	71	0	143	0	95	0	191	0
14.4K	34	-0.8%	68	0.6%	47	0	95	0	63	0	127	0
19.2K	25	0.2%	51	0.2%	35	0	71	0	47	0	95	0
28.8K	16	2.1%	34	-0.8%	23	0	47	0	31	0	63	0
38.4K	12	0.2%	25	0.2%	17	0	35	0	23	0	47	0
57.6K	8	-3.5%	16	2.1%	11	0	23	0	15	0	31	0
78.8K	6	-7.0%	12	0.2%	8	0	17	0	11	0	23	0
115.2K	3	8.5%	8	-3.5%	5	0	11	0	7	0	15	0
230.4	1	8.5%	3	8.5%	2	0	5	0	3	0	7	0
250K	1	0	3	0	2	-7.8%	5	-7.8%	3	-7.8%	6	5.3%
0.5M	0	0	1	0	-	-	2	-7.8%	1	-7.8%	3	-7.8%
1M	-	-	0	0	-	-	-	-	0	-7.8%	1	-7.8%
MAX⁽¹⁾	0.5M		1M		691.2K		1.3824M		921.6K		1.8432M

Примечание (1): UBRR = 0, Error = 0%.

Табл. 22-12. Примеры настройки UBRRn для наиболее часто используемых частот системного генератора.

Baud Rate [bps]	f_osc = 16.0000 МГц				f_osc = 18.4320 МГц				f_osc = 20.0000 МГц
	U2Xn = 0		U2Xn = 1		U2Xn = 0		U2Xn = 1		U2Xn = 0		U2Xn = 1
	UBRR	Error	UBRR	Error	UBRR	Error	UBRR	Error	UBRR	Error	UBRR	Error
2400	416	-0.1%	832	0	479	0	959	0	520	0	1041	0
4800	207	0.2%	416	-0.1%	239	0	479	0	259	0.2%	520	0
9600⁽²⁾	103	0.2%	207	0.2%	119	0	239	0	129	0.2%	259	0.2%
14.4K	68	0.6%	138	-0.1%	79	0	159	0	86	-0.2%	173	-0.2%
19.2K	51	0.2%	103	0.2%	59	0	119	0	64	0.2%	129	0.2%
28.8K	34	-0.8%	68	0.6%	39	0	79	0	42	0.9%	86	-0.2%
38.4K	25	0.2%	51	0.2%	29	0	59	0	32	-1.4%	64	0.2%
57.6K	16	2.1%	34	-0.8%	19	0	39	0	21	-1.4%	42	0.9%
78.8K	12	0.2%	25	0.2%	14	0	29	0	15	1.7%	32	-1.4%
115.2K⁽³⁾	8	-3.5%	16	2.1%	9	0	19	0	10	-1.4%	21	-1.4%
230.4	3	8.5%	8	-3.5%	4	0	9	0	4	8.5%	10	-1.4%
250K	3	0	7	0	4	-7.8%	8	2.4%	4	0	9	0
0.5M	1	0	3	0	-	-	4	-7.8%	-	-	4	0
1M	0	0	1	0	-	-	-	-	-	-	-	-
MAX⁽¹⁾	1M		2M		1.152M		2.304M		1.25M		2.5M

Примечания:
(1): UBRR = 0, Error = 0%.
(2) скорость по умолчанию, которая используется в консоли Serial Monitor и скетчах Arduino.
(3) на этой скорости работает UART-загрузчик платы Arduino Mega 2560 [2].

[Ссылки]

1. Работа с кольцевым буфером.
2. Arduino MEGA 2560.
3. AVR: отладочный вывод через UART (RS232 debug).
4. stdio.h: стандартные возможности ввода/вывода.

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

JComments

Поделиться

Нашли опечатку?

Комментарии

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