Золотовский Д.В. Учебный курс для новичков по микроконтроллерам AVR. Часть 1
Подождите немного. Документ загружается.
мощнейший инструмент для построения быстрых и очень компактных
алгоритмов.
Приведу другой, более сложный пример. Генерацию сигнала сложной
формы.
Пусть у нас есть сигнал:
Цифрами указана задержка, в каких нибудь величинах. Это не суть важно.
Обычно народ не мучается и лепит его обычно, через delay:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
Set_Pin(); // Вывод в 1
Delay(10); // Задержка 10
Clr_Pin(); // Вывод в 0
Delay(100); // Задержка в 100
Set_Pin();
Delay(1);
Clr_Pin();
Delay(5);
Set_Pin();
Delay(2);
Clr_Pin();
Delay(3);
Set_Pin;
Delay(4);
Clr_Pin
();
Это дает минимальный код, но затыкает работу контроллера на весь период
посылки. А если слать надо постоянно? Да еще дофига всего попутно делать?
Экран обновлять, данные обрабатывать, в память писать…
В таком случае у нас рулит RTOS, где на Delay происходит передача
управления диспетчеру. Но если ОС нету? Вот тут то и идет в ход конечный
автомат.
Проще всего тут применить таймер и его прерывание по переполнению.
Таймер сам, в своем прерывании, будет загружать себя новыми значениями
выдержки и щелкать дальше.
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
Timer_Overflow_Interrupt(void)
{
switch(TMR_State) // Обработчик прерывания по
переполнению
{
case 0:
{
Clr_Pin(); // Вывод в 0
TCNT = 255-100; // Задержка в 100 (до переполнения)
TMR_State = 1; // Следующая стадия 1
Break; // Выход
}
case 1:
{
Set_Pin();
TCNT = 255-1;
TMR_State = 2;
Break;
}
case 2:
{
Clr_Pin();
TCNT = 255-5;
TMR_State = 3;
Break;
}
case 3:
{
Set_Pin
();
TCNT = 255-2;
TMR_State = 4;
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
B
reak
;
}
case 4:
{
Clr_Pin();
TCNT = 255-3;
TMR_State = 5;
Break;
}
case 5:
{
Set_Pin();
TCNT = 255-4;
TMR_State = 6;
Break;
}
case 6:
{
Clr_Pin();
Timer_OFF(); // Выключаем таймер. Работа окончена
TMR_State = 0; // Обнуляем состояние
Break;
}
default: break;
}
}
А запускается эта ерунда простым пинком:
1
2
3
4
5
6
Set_Pin();
TCNT=255-10; // Грузим таймер на выдержку 10 тиков
TMR_State = 0; // Устанавливаем начальное положение
Timer_ON(); // Поехали!
... // После чего можно заниматься чем угодно.
Когда автомат отработает - сама себя выключит. Можно еще какоенить
событие сгенерировать, дабы основная программа поняла, что все уже
готово. Хотя основная программа спокойно может палить переменную
состояния автомата и все оттуда узнать сама.
Конечный автомат можно зациклить — скажем, на стадии 6 сделать
перенаправление на стадию 0, то получим генератор сигнала сложной
формы. Причем он будет занимать минимум процессорного времени.
Если мы, например, захотим сделать десяток ШИМ сигналов? То что нам
мешает повесить их на ОДИН таймер, главное отсортировать все скважности
по возростанию, причем сортировать их вместе с ногами которыми нужно
дрыгать. А потом прогнать по прерыванию таймера конечный автомат, да так
чтобы он по стадиям передергивал ножки. Правда при изменении скважности
любого из этих софтверных ШИМ каналов придется делать повторную
сортировку всего массива. Разумеется, больших скоростей мы на этом не
получим. Таймер не может щёлкать так быстро, да и математики там хватит.
Но для многих задач, например, одновременное управление десятком
сервомашинок этого более чем достаточно.
А если в том же прерывании таймера сделать выбор следующей стадии
исходя не из тупой последовательности, а, скажем, на основе
обрабатываемого байта, то мы получим программно-аппаратный генератор, к
примеру, 1-Wire кода. Достаточно анализировать входной буфер и если там 1
- перебрасывать автомат в состояние соответствующее отработки генерации
сигнала 1, а если 0, то в состояние генерящее выдержку нуля.
Более того, на автоматах можно полностью построить логику работы
программы. От и до. Получается весьма торчково, пока не въедешь в это всей
душой мозг сломать можно, но зато работает просто зверски и очень проста в
отладке.
Не буду описывать это, так как есть замечательный цикл статей Владимира
Татарчевского, опубликованный в журнале Компоненты и Технологии.
Настоятельно рекомендую к прочтению. Чтобы вам не шерстить по инету, я
все части этой замечательной статьи выложил в
архив. Качайте и вникайте.
Особенно автоматный метод доставляет тем, что готовые автоматы
вписываются как родные в любую почти архитектуру. У меня они и во
флаговых автоматах работают на ура, и из диспетчера RTOS я их гоняю как
родные. Красота!
AVR. Учебный Курс. Работа на прерываниях
Одним из серьезных достоинств контроллеров AVR является дикое
количество прерываний. Фактически, каждое периферийное устройство
имеет по вектору, а то и не по одному. Так что на прерываних можно
замутить кучу параллельных процессов. Работа на прерываниях является
одним из способов сделать псевдо многозадачную среду.
Идеально для передачи данных и обработки длительных процессов.
Для примера покажу буферизированный вывод данных по USART на
прерываниях.
В прошлых примерах был такой код:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// Отправка строки
void SendStr(char *string)
{
while (*string!='\0')
{
SendByte(*string);
string++;
}
}
// Отправка одного символа
void SendByte(char byte)
{
while(!(UCSRA & (1<<UDRE)));
UDR=byte;
}
Данный метод, очевидно, совершенно неэффективен. Дело в том, что у нас
тут есть тупейшее ожидание события — поднятие флага готовности USART.
А это зависит, в первую очередь, от скорости передачи данных. Например, на
скорости 600 бод передача каких то 600 знаков будет длиться 9 секунд,
блокируя работу всей программы, что ни в какие ворота не лезет.
Как быть?
Ну раз у нас отправка идет по аппаратному устройству, то большую часть
времени мы впустую крутим цикл ожидания флага, хотя от процессора,
собственно, тут ничего и не требуется и можно было бы заняться другими
делами. Напрашивается мысль выбросить весь цикл ожидания в тело
ядра/автомата/суперцикла и обрабатывать флаг на каждой итерации главного
цикла/диспетчера. Но при этом у нас будет плавать время между байтами —
ацтой!
Поэтому прерывания, пожалуй, будет единственным адекватным вариантов.
Итак, если брать в пример USART то у него есть три прерывания:
•
RXT - прием байта. С этим понятно, мы его уже использовали
•
TXC - завершение отправки
•
UDRE - опустошение приемного буфера
Байты TXC и UDRE обычно вызывают путаницу. Поясню разницу.
Дело в том, что регистр передачи данных UDR в AVR на самом деле куда
хитрей, чем кажется, он двухэтажный. На первом ярусе, собственно UDR, а
ниже находится конвейер сдвигового регистра. Первый байт, попавший в
пустой регистр UDR, тут же проваливается на конвейер, а UDR снова
опустошается. После чего конвейер неторопливо, в соответствии с
битрейтом, выплевывает данные в линию, а потом снова зажевывает байт из
UDR. Поэтому, фактически, в UDR за короткое время влезает сразу два байта
- первый тут же проваливается, а второй ждет.
Так вот,
•
Флаг пустого регистра UDRE выставляется тогда, когда мы можем
загнать байт в UDR,
•
Флаг окончания передачи TXC появляется только тогда, когда у нас
конвейер опустел, а новых данных в UDR нет.
Да, можно слать данные и по флагу TXC, но тогда у нас будет лишняя пауза
между двумя разными байтами — время на опустошение буфера.
Некошерно.
Вот как это можно сделать корректней.
Вначале выводим данные в массив, либо берем его из флеша — не важно.
Для простоты запихну массив в ОЗУ. Код возьму из прошлой статьи:
1
2
3
#define buffer_MAX 16 // Длина текстового буффера
char buffer[buffer_MAX] = "0123456789ABCDEF"; // А вот и он сам
u08 buffer_index=0; // Текущий элемент буффера
Инициализация интерфейса выглядит стандартно:
1
2
3
4
5
6
7
8
//InitUSART
UBRRL = LO(bauddivider);
UBRRH = HI(bauddivider);
UCSRA = 0;
UCSRB = 1<<RXEN|1<<TXEN|0<<RXCIE|0<<TXCIE;
UCSRC = 1<<URSEL|1<<UCSZ0|1<<UCSZ1;
sei(); // Разрешаем прерывания.
Обратите внимание, что прерывания UDRE мы не разрешаем. Это делается
потом. Иначе сразу же, на старте, контроллер ускачет на это прерывание, т.к.
при пуске UDR пуст и мы получим черти что.
Отправка выглядит элементарно. Вначале пихаем первый байт нашего
сообщения, не забыв выставить правильно индекс. А дальше разрешаем
прерывание по UDRE оно само улетит куда надо, по прерываниям:
1
2
3
buffer_index=0; // Сбрасываем индекс
UDR = buffer[0]; // Отправляем первый байт
UCSRB|=(1<<UDRIE); // Разрешаем прерывание UDRE
Дальше можно затупить или делать вообще что угодно:
1
2
3
4
while(1)
{
NOP();
}
В течение нескольких тактов выскочит прерывание UDRE
Да, кстати, я один раз словил гадский баг, который отловил только
трассировкой ассемблерного листнига. У меня была такая
последовательность:
1
2
3
UDR = X;
UCSRB|=(1<<UDRIE);
buffer_index = 1;
И вот тут, почему-то первым байтом шел мусор. А дальше все нормально.
Причем если менять уровень оптимизации, то баг то вылезал, то нет.
Причиной такого поведения являлось то, что я надеялся на то, что
прерывание UDRE выскочит гораздо поздней, чем я присвою индексу буфера
нужное значение (buffer_index = 1;) Но индюк тоже думал, а по факту я
пихаю байт в UDR, он в тот момент естественно пуст и уже следующим
тактом, на выполнении команды UCSRB|=(1<<UDRIE) данные
проваливались в сдвиговый регистр, а UDR тотчас пустел и выставлял бит
прерывания.
А дальше, в зависимости от оптимизации, этот бит успевал выставиться к
моменту, когда я выставлял верный номер индекса либо не успевал.
Проблема решилась перестановкой строк:
1
2
3
UDR = X;
buffer_index = 1;
UCSRB|=(1<<UDRIE);
Отсюда правило:
Готовь все необходимые данные ПЕРЕД разрешением прерываний.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
// Прерывание по опустошению буффера УАПП
ISR (USART_UDRE_vect)
{
buffer_index ++; // Увеличиваем индекс
if(buffer_index == buffer_MAX) // Вывели весь буффер?
{
UCSRB &=~(1<<UDRIE); // Запрещаем прерывание по опустошению -
передача закончена
}
else
{
UDR = buffer[buffer_index]; // Берем данные из буффера.
}
}
Все, автоматика! Каждый раз когда UDRE пустеет прерывание срабатывает и
бросает туда новых дров. Когда же буфер пустеет и индекс достигает
максимума, то мы просто запрещаем прерывание UDRE и успокаиваемся.
Осталось только дать понять головной программе, что мы отработали. Для
этого и есть флаг TXC можно разрешить его прерывание и тогда он
сбросится при обработке прерывания USART_TXC_vect, а в самом
обработчике сделать заброс задачи на диспетчер или еще что нибудь умное.
Либо периодически проверять главным циклом наличие флага TXC и
вручную его стереть (записью единицы).
Вот полный код:
1
2
3
4
5
6
#define F_CPU 8000000L
#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <avrlibdefs.h>
#include <avrlibtypes.h>
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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
#define buffer_MAX 16 // Длина текстового буффера
char buffer[buffer_MAX] = "0123456789ABCDEF"; // А вот и он сам
u08 buffer_index=0;
//Прерывание по опустошению буффера УАПП
ISR (USART_UDRE_vect)
{
buffer_index++; // Увеличиваем индекс
if(buffer_index == buffer_MAX) // Вывели весь буффер?
{
UCSRB &=~(1<<UDRIE); // Запрещаем прерывание по опустошению -
передача закончена
}
else
{
UDR = buffer[buffer_index]; // Берем данные из буффера.
}
}
int main(void)
{
#define baudrate 9600L
#define bauddivider (F_CPU/(16*baudrate)-1)
#define HI(x) ((x)>>8)
#define LO(x) ((x)& 0xFF)
//Init UART
UBRRL = LO(bauddivider);
UBRRH = HI(bauddivider);
UCSRA = 0;
UCSRB = 1<<RXEN|1<<TXEN|0<<RXCIE|0<<TXCIE;
UCSRC = 1<<URSEL|1<<UCSZ0|1<<UCSZ1;
//Это так, просто помигать.
#define LED1 4
#define LED_PORT PORTD
#define LED_DDR DDRD
LED_DDR = 1<<LED1;
sei();
buffer_index=0; // Сбрасываем индекс
UDR = buffer[0]; // Отправляем первый байт
UCSRB|=(1<<UDRIE); // Разрешаем прерывание UDRE
while(1)
{
LED_PORT=0<<LED1;