UART: Понимание последовательного интерфейса передачи данных

В сегодняшней статье мы с вами разберемся с последовательным интерфейсом UART, узнаем его плюсы и минусы, а также научимся отлаживать программу с помощью Arduino IDE без применения программаторов. Вас заинтересовало? Тогда читайте дальше!

Серьёзные среды разработки, типа IAR или ATMEL Studio, как правило, содержат в себе либо программный симулятор целевого микроконтроллера, либо имеют программные средства для работы с аппаратными отладчиками.

Среда Arduino IDE не имеет ни того, ни другого, что значительно усложняет поиск ошибок в программе. Компилятор выявляет только синтаксические ошибки, наряду с которыми существуют еще и логические (написано-то правильно, только не то делает), не говоря уж о подсчёте различных коэффициентов… Программы не пишутся без ошибок!

Существует множество методов отладки, но практически для всех необходимо физическое соединение с компьютером. Все платы Arduino (кроме Pro и Pro Mini) имеют «на борту» USB-разъём и специальную микросхему, которая преобразует интерфейс UART в USB. Так не будем же придумывать ничего лишнего и сделаем простейшую отладку с помощью интерфейса, который у нас уже есть!

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

Монитор порта – не единственное средство для работы с ним, в сети можно найти множество программ-мониторов, которые позволяют не только принимать данные, но и стоить графики на их основе, записывать данные в таблицу и многое другое! Это значительно упростит отладку программы.

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

UART в переводе с английского звучит как “Универсальный Асинхронный Приёмопередатчик”. Существует ещё его синхронная версия с дополнительной линией тактового сигнала, но она не интересна нам в рамках статьи.

Каждый бит каждого байта передаётся в равный отведённый промежуток времени (фактически, тайм-слот). Стандартным размером данных в посылке является 8 байт, но помимо данных каждый пакет несёт и служебную информацию, а именно:

стартовый бит (Обязателен)
стоповый бит (Также обязателен, возможно использование 1, 1.5, 2 стоповых битов)
бит чётности (Необязателен. Бывает типов Odd, Even)

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

Скорость измеряется в битах в секунду, или коротко – в бодах. Стандарт RS232 подразумевает скорости от 1200 до 115200 бод, хотя по факту существуют скорости и ниже, и выше, причём до десятков мегабод!

Разумеется, точность везде относительна и скорость никогда не будет равняться 9600 бодам с точностью до единиц. Стандарт предусматривает возможную ошибку в скорости до 5% (не более 3% для уверенного приёма).

Далее сведены основные сведения о сигнале:

в неактивном (IDLE) режиме обе линии данных подтянуты вверх
передачу начинает стартовый бит (логический ноль)
передачу заканчивает стоп-бит (логическая единица)
данные передаются в режиме LSB (младшим битом вперед)
для передачи байта требуется минимум 10 бит

Стандартные скорости:

4800, 9600, 19200, 38400, 57600, 115200 бод.

Скорость передачи (бод)	Время передачи одного бита (мкс)	Время передачи байта (мкс)
4800	208	2083
9600	104	1042
19200	52	521
38400	26	260
57600	17	174
115200	8,7	87

UART может быть запущен как в полудуплексном (только приём или только передача) режиме, так и в полнодуплексном режиме, так как линии приёма и передачи разделены. Линия TXD отвечает за передачу, RXD – за приём, соответственно, линии от приёмника к передатчику перекрещиваются (TX-RX, RX-TX).

Все платы Arduino, построенные на основе оригинальных, имеют минимум один интерфейс UART, продвинутые же платы, типа Arduino Mega 2560 Или Arduino Due, имею сразу 4 аппаратных интерфейса! Они не загружают контроллер, так как они отделены от ядра; всё, что необходимо – это сконфигурировать порт и запихать данные в буфер, после чего операции передачи пойдут независимо от вас.

Конечно, существуют и программные реализации UART, но они нагружают процессор. В любом случае, лучше использовать сначала аппаратные интерфейсы, а потом уже начинать придумывать что-то программное.

Контроллеры Arduino используют логические уровни такие же, каким является питание, то есть для самой популярной платы Arduino UNO уровни будут равны – ноль = 0В, 1 = 5В.

Выводы подключены к преобразователю интерфейсов через резисторы с сопротивлением 1 КОм, а к гребёнкам по бокам платы – напрямую, поэтому сигналы с гребёнок будут иметь больший приоритет. Периодически это мешает прошивать платы с подключенным датчиком по UART, так как для прошивки тоже используется UART.

Микросхема преобразователя интерфейсов не делает из себя ещё один COM-интерфейс для компьютера, она лишь эмулирует его. Несмотря на это, все программы, которые работают с COM-портом посредством Windows API (Win32 API), не отличат порт от физического порта компьютера.

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

Всё дело в том, что каждый символ раскладки клавиатуры – это тоже байт. И если просто взять и отправить в порт число 65, он не выведет две цифры 6 и 5, а выведет заглавную латинскую букву А. Почему так? Потому что в таблице кодировки буква А имеет код 65. Класс позволяет выбрать между текстовым и бинарным методом передачи данных, то есть мы сможем отправить число 65 и как букву, и как число.

Serialx.begin(speed)

X – номер Serial порта, начиная с нуля
Speed – скорость обмена в бодах
Начинает сеанс обмена с установленной скоростью.

Serial.begin(38400);       // инициализация порта, скорость 38400 бод

1	Serial.begin(38400); // инициализация порта, скорость 38400 бод

Serilalx.end()

Заканчивает сеанс обмена, освобождает порты ввода-вывода.

Serial.end();      // закрыть порт UART

1	Serial.end(); // закрыть порт UART

Serialx.available()

Так как все UART-Данные буферизируются, то у нас есть возможность узнать, сколько байтов принято. Их количество и возвращает эта функция.

int n; 
n= Serial. available();     // в n число принятых байтов

1 2	int n; n= Serial. available(); // в n число принятых байтов

Serialx.read()

При наличии символа в буфере, возвращает последний символ. При отсутствии – число -1.

receiveByte= Serial.read();   // чтение байта из буфера

1	receiveByte= Serial.read(); // чтение байта из буфера

Serialx.flush()

Притормаживает выполнение программы до завершения передачи данных.

Serial.flush();    // ждем окончания передачи

1	Serial.flush(); // ждем окончания передачи

Serialx.print()

Serial.print() – одна из самых основных функций класса Serial, которая служит для передачи данных от контроллера в компьютер через последовательный COM-порт.

print(char d)

Если аргумент типа char выводит в порт код символа:

char d= 83;
Serial.print(d);  // выводит код 83 (символ S)
Serial.print(‘S’);  // выводит код 83 (символ S)

1

2

3

char d= 83;

Serial.print(d); // выводит код 83 (символ S)

Serial.print(‘S’); // выводит код 83 (символ S)

print(byte d)

Данные типа byte выводятся кодом числа:

byte d= 83;
Serial.print(d);  // выводит код 83 (символ S)
Serial.print(byte(83));  // выводит код 83 (символ S)

1

2

3

byte d= 83;

Serial.print(d); // выводит код 83 (символ S)

Serial.print(byte(83)); // выводит код 83 (символ S)

print(int d)

Если аргумент – целый тип, то выводит строку с десятичным представлением числа:

int d= 83;
Serial.print(d);  // выводит строку “83”
Serial.print(83);  // выводит строку “83”

1

2

3

int d= 83;

Serial.print(d); // выводит строку “83”

Serial.print(83); // выводит строку “83”

print(float)

Вещественные типы выводятся символами ASCII, два знака после запятой:

float d= 7.65432;
Serial.print(d);  // выводит строку “7.65”
Serial.print(7.65432);  // выводит строку “7.65”

1

2

3

float d= 7.65432;

Serial.print(d); // выводит строку “7.65”

Serial.print(7.65432); // выводит строку “7.65”

**print(* str)**

Если аргумент указатель на массив или строка, то массив или строка побайтно передается в порт.

char letters[3]= {65, 66, 67};
Serial.print(“Буквы”);   // выводит строку “Буквы”
Serial.print(letters);   // выводит строку из 3 символов с кодами 65, 66, 67

1

2

3

char letters[3]= {65, 66, 67};

Serial.print(“Буквы”); // выводит строку “Буквы”

Serial.print(letters); // выводит строку из 3 символов с кодами 65, 66, 67

print(int d, DEC)

Выводит строку ASCII – десятичное представление числа:

int d= 83;
Serial.print(d, DEC);   // вывод строки “83”

1 2	int d= 83; Serial.print(d, DEC); // вывод строки “83”

print(int d, HEX)

Выводит строку ASCII – шестнадцатиричное представление числа:

int d= 83;
Serial.print(d, HEX);   // вывод строки “53”

1 2	int d= 83; Serial.print(d, HEX); // вывод строки “53”

print(int d, OCT)

Выводит строку ASCII – восьмеричное представление числа:

int d= 83;
Serial.print(d, OCT);   // вывод строки “123”

1 2	int d= 83; Serial.print(d, OCT); // вывод строки “123”

print(int d, BIN)

Выводит строку ASCII – двоичное представление числа:

int d= 83;
Serial.print(d, BIN);  // вывод строки “01010011”

1 2	int d= 83; Serial.print(d, BIN); // вывод строки “01010011”

print(int d, BYTE)

Выводит код младшего байта числа:

int d= 0x0283;
Serial.print(d, BYTE);  // вывод числа 83 (код символа S)

1 2	int d= 0x0283; Serial.print(d, BYTE); // вывод числа 83 (код символа S)

print(float d, N)

Для вещественных чисел параметр N задает количество цифр после запятой.

Serial.print(7.65432, 0);  // выводит строку “1”
Serial.print(7.65432, 2);  // выводит строку “7.65”
Serial.print(7.65432, 4);  // выводит строку “7.6543”

1

2

3

Serial.print(7.65432, 0); // выводит строку “1”

Serial.print(7.65432, 2); // выводит строку “7.65”

Serial.print(7.65432, 4); // выводит строку “7.6543”

Serialx.println()

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

int d= 83; 
Serial.print(d, DEC);   // вывод строки “83” 
Serial.println(d, DEC);   // вывод строки “83 r n”

1

2

3

int d= 83;

Serial.print(d, DEC); // вывод строки “83”

Serial.println(d, DEC); // вывод строки “83 r n”

Serialx.write()

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

int write(val)

Передает байт:

Serial.write(83);  // передает байт 83

1	Serial.write(83); // передает байт 83

int write(str)

Передает строку, как последовательность байтов:

int bytesNumber;  // число байтов
 bytesNumber= Serial.write(”Строка”);  // передает строку ”Строка”, возвращает длину строки

1 2	int bytesNumber; // число байтов bytesNumber= Serial.write(”Строка”); // передает строку ”Строка”, возвращает длину строки

**int write(* buf, len)**

Передает байты из массива, число байтов – len:

char buf= “Строка”; 
Serial.write(buf, 3);  // выводит строку “Стр”

1 2	char buf= “Строка”; Serial.write(buf, 3); // выводит строку “Стр”

Serialx.peek()

Работает так же, как функция read, но не удаляет при этом символ из буфера:

Serialx.readBytes()

Читает в определенный массив определенное количество байт. Заканчивает по достижении количества или по таймауту, который задаётся функцией Serialx.setTimeout, инитиативное значение – 1 секунда.

serialEvent()

Обработчик прерывания по приходу данных. Перед использованием необходимо включить прерывания функцией _enable_interrupts ();

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

Разобьём нашу работу на три этапа:

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

Давайте попробуем отладить простейшую программу взаимодействия контроллера Arduino с кнопками.

В простой скетч добавим пару блоков, которые будут выводить состояние кнопок в последовательный порт:

// отладка кнопок с помощью порта UART

#include 
#include 

#define BUTTON_1_PIN 12 // кнопка 1 подключена к выводу 12
#define BUTTON_2_PIN 11 // кнопка 2 подключена к выводу 11

Button button1(BUTTON_1_PIN, 20); // создание объекта кнопка 1
Button button2(BUTTON_2_PIN, 20); // создание объекта кнопка 2

void setup() {
  Serial.begin(9600); // инициализируем порт, скорость 9600
  MsTimer2::set(2, timerInterupt); // задаем прерывания по таймеру с периодом 2 мс 
  MsTimer2::start();              // разрешаем прерывание
}

void loop() {

    // проверка кнопки 1
    if ( button1.flagClick == true ) {
      button1.flagClick= false;
      Serial.println("Button 1 was pressed");  // сообщение для монитора
    }    

    // проверка кнопки 2
    if ( button2.flagClick == true ) {
      button2.flagClick= false;
      Serial.println("Button 2 was pressed");  // сообщение для монитора
    }      
}

// обработка прерывания
void  timerInterupt() {
  button1.scanState();  // вызов метода обработки сигнала кнопки 1
  button2.scanState();  // вызов метода обработки сигнала кнопки 2    
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

// отладка кнопок с помощью порта UART

#include

#define BUTTON_1_PIN 12 // кнопка 1 подключена к выводу 12

#define BUTTON_2_PIN 11 // кнопка 2 подключена к выводу 11

Button button1(BUTTON_1_PIN, 20); // создание объекта кнопка 1

Button button2(BUTTON_2_PIN, 20); // создание объекта кнопка 2

void setup() {

Serial.begin(9600); // инициализируем порт, скорость 9600

MsTimer2::set(2, timerInterupt); // задаем прерывания по таймеру с периодом 2 мс

MsTimer2::start(); // разрешаем прерывание

}

void loop() {

// проверка кнопки 1

if ( button1.flagClick == true ) {

button1.flagClick= false;

Serial.println("Button 1 was pressed"); // сообщение для монитора

}

// проверка кнопки 2

if ( button2.flagClick == true ) {

button2.flagClick= false;

Serial.println("Button 2 was pressed"); // сообщение для монитора

}

// обработка прерывания

void timerInterupt() {

button1.scanState(); // вызов метода обработки сигнала кнопки 1

button2.scanState(); // вызов метода обработки сигнала кнопки 2

}

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

Загрузите программу в микроконтроллер – вы увидите, как по нажатию кнопки в последовательный порт отправляется строка с данными!

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

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

Удачи вам в применении отладочного вывода с помощью UART!

UART – Последовательный интерфейс передачи данных

UART интерфейс — описание

Реализация UART в Arduino

Класс Serial – RS232 в лучших традициях Arduino

Функции класса Serial