Золотовский Д.В. Учебный курс для новичков по микроконтроллерам AVR. Часть 1
Подождите немного. Документ загружается.
Бит U2X - это бит удвоения скорости при работе в ассинхронном режиме.
Его надо учитывать при расчете значения в UBBRH:UBBRL
Регистр UCSRB
Тут в первую очередь это биты RXEN и TXEN — разрешение приема и
передачи. Стоит их сбросить, как выводы UART тут же становятся
обычными ножками I/O.
Биты RXCIE, TXCIE, UDRIE разрешают прерывания по завершению
приема, передачи и опустошении буфера передачи UDR.
Регистр UCSRC
Самый прикол тут — это бит селектора URSEL дело в том, что по
неизвестной причине создаетели решили сэкономить байт адреса и
разместили регистры UCSRC и UBRRH в одной адресном пространстве. А
как же определять куда записать? А по старшему биту! Поясню на примере.
Если мы записываем число у которого седьмой бит равен 1, то оно попадет в
UCSRC, а если 0 то UBRRH. Причем этот бит есть не во всех AVR в новых
моделях его нет, а регистры имеют разные адреса. Так что надо смотреть в
даташите этот момент — есть там бит URSEL или нет.
Остальные биты задают число стопов, наличие и тип контроля четности.
Если оставить все по дефолту то будет стандартный режим. Надо только
выставить формат посылки. Делается это битами UCSZ0, UCSZ1 и UCSZ2
(этот бит находится в регистре UCSRB). Для стандартной 8ми битной
посылки туда надо записать две единички.
Скорость обмена.
Тут все зависит от пары UBBRx
Вычисляется требуемое значение по формуле:
UBBR=XTAL/(16*baudrate)-1 для U2X=0
UBBR=XTAL/(8*baudrate)-1 для U2X=1
Где:
XTAL - рабочая тактовая частота контроллера.
baudrate - требуемая скорость (я люблю 9600 :) — чем медленней тем
надежней. 9600 в большинстве случаев хватает)
Ошибки передачи
К сожалению мир наш не идеален, поэтому возможны ошибки при приеме.
За них отвечают флаги в регистре UCSRA
FE - ошибка кадрирования. Т.е. мы ждали стоп бит, а пришел 0.
OR - переполнение буфера. То есть данные лезут и лезут, а из UDR мы их
забирать не успеваем.
PE - не совпал контроль четности.
Примеры кода
Простая приемка и отправка байт. Без использования прерываний.
Для начала инициализация UART в ATMega16 (А таже в Mega8535/8/32 и
многих других).
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
; Internal Hardware Init ======================================
.equ XTAL = 8000000
.equ baudrate = 9600
.equ bauddivider = XTAL/(16*baudrate)-1
uart_init: LDI R16, low(bauddivider)
OUT UBRRL,R16
LDI R16, high(bauddivider)
OUT UBRRH,R16
LDI R16,0
OUT UCSRA, R16
; Прерывания запрещены, прием-передача разрешен.
LDI R16,
18
19
20
21
22
(
1<<RXEN
)
|
(
1<<TXEN
)
|
(
0<<RXCIE
)
|
(
0<<TXCIE
)
|
(
0<<UDRIE
)
OUT UCSRB, R16
; Формат кадра - 8 бит, пишем в регистр UCSRC, за это отвечает бит селектор
LDI R16, (1<<URSEL)|(1<<UCSZ0)|(1<<UCSZ1)
OUT UCSRC, R16
1
2
3
4
5
6
; Процедура отправки байта
uart_snt: SBIS UCSRA,UDRE ; Пропуск
если нет флага готовности
RJMP uart_snt ; ждем
готовности - флага UDRE
OUT UDR, R16 ;
шлем байт
RET ;
Возврат
1
2
3
4
5
6
7
8
9
;Посылка байта:
RCALL uart_init ; вызываем нашу процедуру
инициализации.
Main: LDI R16,'E' ; загоняем в регистр код буквы «E»
RCALL uart_snt ; Вызываем процедуру отправки байта.
NOP ; Любой дальнейший код
NOP
NOP
1
2
3
4
5
6
;Ожидание байта
uart_rcv: SBIS UCSRA,RXC ; Ждем флага прихода байта
RJMP uart_rcv ; вращаясь в цикле
IN R16,UDR ; байт пришел - забираем.
RET ; Выходим. Результат в R16
В главном цикле это выглядит так (я выбросил из главного цикла все что там
было для краткости, чтобы в глазах не рябило. Оставил только работу с
USART):
1
2
3
4
5
6
7
8
; Main =========================================================
Main: RCALL uart_rcv ; Ждем байта
INC R16 ; Делаем с ним что-то
RCALL uart_snt ; Отправляем обратно.
JMP Main
Если зальешь эту программку в Pinboard и подключишься терминалкой, то на
каждый байт контроллер тебе вернет байт следующий по величине.
Например на 1 (код 0×31) возвращается 2 (код 0×32). И так далее.
Данный метод прост и работает в лоб. Но имеет одну большую проблему —
цикл ожидания прихода байта. В этот момент ничего работать не может.
Конечно, можно не зацикливаться наглухо, а просто проверять флаг RxC и
крутиться в основном цикле. Но тогда, если передача идет на большой
скорости, можно запросто прозевать байт.
Работа на прерываниях
Решение тут одно — использование прерываний хотя бы на прием. А в
идеале и на передачу тоже. Сейчас покажу тебе пример буферизированной
работы с приемопередатчиком на прерываниях.
Во первых инициализация, она теперь другая — мы разрешаем прерывания:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
; Internal Hardware Init ======================================
.equ XTAL = 8000000
.equ baudrate = 9600
.equ bauddivider = XTAL/(16*baudrate)-1
uart_init: LDI R16, low(bauddivider)
OUT UBRRL,R16
LDI R16, high(bauddivider)
OUT UBRRH,R16
LDI R16,0
OUT UCSRA, R16
; Прерывания разрешены, прием-передача разрешен.
LDI R16,
(1<<RXEN)|(1<<TXEN)|(1<<RXCIE)|(1<<TXCIE)|(0<<UDRIE)
OUT UCSRB, R16
; Формат кадра - 8 бит, пишем в регистр UCSRC, за это отвечает бит селектор
LDI R16, (1<<URSEL)|(1<<UCSZ0)|(1<<UCSZ1)
OUT UCSRC, R16
Используем все три прерывания. По приему, по опустошению буфера и по
окончании передачи. Но пока разрешаем только два - по приему и по
передаче. Иначе при старте мы сразу же ускачем на обработчик UDRIE -
буфер то пуст!
В таблицу векторов впишем наши переходы:
1
.
ORG
$016
2
3
4
5
6
RJMP
RX_OK ; (USART,RXC) USART, Rx Complete
.ORG $018
RJMP UD_OK ; (USART,UDRE) USART Data Register Empty
.ORG $01A
RJMP TX_OK ; (USART,TXC) USART, Tx Complete
А в секцию обработчиков прерываний добавим нашу процедуру приема:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
RX_OK: PUSHF ; Макрос, пихающий в стек SREG и R16
IN R16,UDR ; Тут главное забрать байт из
UDR иначе
; флаг прерывания не снимется
; Дальше, если время позволяет, можно и
обработать
CPI R16,Value ; Например, разобрать по байтам и
выполнить действие
BRNE NXT ; Обычным CASE оператором.
Action1 ; Делаем что нибудь ценное. Главное не
забыть в стеке
; Регистры попрятать. А то будет тебе
упячка.
NXT: CPI R16,Value2
BRNE RX_Exit
Action2 ; Делаем что нибудь ценное2
Rx_Exit: POPF ; Достаем SREG и R16
RETI
Передача делается побайтно, на вызовах прерываний. Например, надо нам
отрыгнуть текстовую строку из флеша:
1
String: .
db
"Hello Interrupt Request",0
Заводим указатель на эту строку, обычная двубайтная переменная в памяти.
1
2
.
DSEG
StrPtr: .data 2
Далее, в главной программе, в любом нужном нам месте, загружаем адрес
текстовой строки в этот указатель, не забыв умножить его на два. Т.к.
компилятор флеш адресует в словах, а контроллер оперирует только
байтами:
1
Main:
NOP
; Любой произвольный код главной
2
3
4
5
6
7
8
9
программы
NOP
NOP
LDI R17,low(2*String) ; Берем младший байт
LDI R18,High(2*String) ; Берем старший байт
STS StrPtr,R17 ; Сохраняем Младший байт
STS StrPtr+1,R18 ; Сохраняем Сташрий байт
И сразу же запускаем передачу, путем разрешения прерываний по UDRE. Так
как UDR у нас пуст, то прерывание стартует мгновенно.
1
2
3
4
5
6
7
LDI
R16,
(1<<RXEN)|(1<<TXEN)|(1<<RXCIE)|(1<<TXCIE)|(1<<UDRIE)
OUT UCSRB, R16
;После чего спокойно выполняем любой другой код.
NOP
NOP
NOP
А дальше все сделает наш обработчик прерывания события UDR Empty. На
который ссылается вектор прерывания по опустошению регистра UDR:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
UD_OK: PUSHF ; Макрос, сохраняющий SREG и R16
PUSH ZL ; Сохраняем в стеке Z
PUSH ZH
LDS ZL,StrPtr ; Грузим указатели в индексные регистры
LDS ZH,StrPtr+1
LPM R16,Z+ ; Хватаем байт из флеша. Из нашей
строки
CPI R16,0 ; Если он не ноль, значит читаем дальше
BREQ STOP_RX ; Иначе останавливаем передачу
OUT UDR,R16 ; Выдача данных в усарт.
STS StrPtr,ZL ; Сохраняем указатель
STS StrPtr+1,ZH ; обратно, в память
Exit_RX: POP ZH ; Все достаем из стека, выходим.
POP ZL
POPF
RETI
24
25
26
; глушим прерывание по опустошению, выходим из обработчика
STOP_RX: LDI R16,
(1<<RXEN)|(1<<TXEN)|(1<<RXCIE)|(1<<TXCIE)|(0<<UDRIE)
OUT UCSRB, R16
RJMP Exit_RX
Все, по прерыванию обработчик сам выгребет данные из флеша и сам
автоматом себя забанит когда дойдет до нуля в строке.
А зачем нужно прерывание TX_OK? Ну мало ли зачем. Еще какое-нибудь
событие повесить. Оно сработает когда произойдет две вещи - UDR кончится
и в сдвиговом регистре USART все биты улетят в провод. В принципе,
многие юзают его вместо UDRE, но тогда между двумя уходящими байтами
будет промежуток периодом в 1 байт. Что не очень кошерно.
Буферизация
Но далеко не всегда можно успеть обработать данные с большой скоростью.
В этом случае их приходится куда-то складывать. А передавать/обрабатывать
попозже. Особенно это касается отправки. Отправка медленная, а нам бы все
сразу в буфер свалить и уйти по своим делам. А USART пускай там
постепенно со всем этим разбирается.
Поэтому мы заведем два кольцевых буфера. На прием и на передачу (можно
и только на передачу, это чаще требуется). А также ряд служебных
переменных:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
; RAM
=======================================================
=
.DSEG
.equ MAXBUFF_IN = 10 ; Размер в байтах
.equ MAXBUFF_OUT = 10
IN_buff: .byte MAXBUFF_IN ; Буфер приема
IN_PTR_S: .byte 1 ; Указатель начала
IN_PTR_E: .byte 1 ; Указатель конца
IN_FULL
: .byte 1 ; Флаг переполнения
OUT_buff: .byte MAXBUFF_OUT ; Буфер передачи
15
OUT_PTR_S: .
byte
1 ; Указатель начала
OUT_PTR_E: .byte 1 ; Указатель конца
OUT_FULL: .byte 1 ; Флаг переполнения.
Указатели начала показывают, откуда мы будем буфер читать, указатель
конца нацелен на точку записи. В результате конец убегает, а начало его
догоняет. Когда они сравняются - буфер пуст. При достижении
максимальных границ буфера (10 байт) указатель переносится в начало, т.к. у
нас буфер закольцован.
При этом может быть перехлест указателей между собой. Это даст ошибку
переполнения и некорректную работу. Поэтому введены флаги
переполнения, возникающие если конец пошел по второму кругу и догнал
начало.
Сами указатели я сделал не классическими адресами, а смещениями
относительно начала каждого буфера, Так получается оптимальней, не
приходится сравнивать двубайтные числа. Но при этом длина буфера
ограничена 255 байтами.
Прерывание по приему данных пишет в буфер IN_buff
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
RX_OK: PUSHF ; Макрос, пихающий в стек SREG
и R16
PUSH R17
PUSH R18
PUSH XL
PUSH XH
LDI XL,low(IN_buff) ; Берем адрес начала буффера
LDI XH,high(IN_buff)
LDS R16,IN_PTR_E ; Берем смещение точки записи
LDS R18,IN_PTR_S ; Берем смещение точки чтения
ADD XL,R16 ; Сложением адреса со
смещением
CLR R17 ; получаем адрес точки записи
ADC XH,R17
IN R17,UDR ; Забираем данные
ST X,R17 ; сохраняем их в кольцо
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
INC R16 ; Увеличиваем смещение
CPI R16,MAXBUFF_IN ; Если достигли конца
BRNE NoEnd
CLR R16 ; переставляем на начало
NoEnd: CP R16,R18 ; Дошли до непрочитанных
данных?
BRNE RX_OUT ; Если нет, то просто
выходим
RX_FULL: LDI R18,1 ; Если да, то буффер переполнен.
STS IN_FULL,R18 ; Записываем флаг наполненности
RX_OUT: STS IN_PTR_E,R16 ; Сохраняем смещение.
Выходим
POP XH
POP XL
POP R18
POP R17
POPF ; Достаем SREG и R16
RETI
Если возникнет переполнение, то данные начнут затирать предыдущие,
произойдет перехлест указателей, но перед этим поднимется флаг IN_FULL и
диспетчер, или кто у нас там будет следить за всякими исключениями, может
спешно среагировать и выгрузить буфер.
IN_FULL занимает целый байт, но можно было бы в один бит сделать. Я
просто не стал усложнять. При чтении и записи в буфер в фоновой
программе надо соблюдать атомарность, т.е. запрещать возможность записи
в буфер из прерывания. А то будет трудно уловимый косяк.
Чтение из буфера приема делается тоже просто:
1
2
3
4
5
6
7
; Read from loop Buffer
; IN: NONE
; OUT: R17 - Data,
; R19 - ERROR CODE
Buff_Pop
: CLI ; Запрещаем прерыания.
; Но лучше запретить
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
прерывания конкретно от
; UART, чем запрещать вообще
все.
LDI XL,low(IN_buff) ; Берем адрес начала буффера
LDI XH,high(IN_buff)
LDS R16,IN_PTR_E ; Берем смещение точки записи
LDS R18,IN_PTR_S ; Берем смещение точки чтения
LDS R19,IN_FULL ; Берм флаг переполнения
CPI R19,1 ; Если буффер переполнен, то
указатель начала
BREQ NeedPop ; Равен указателю конца. Это
надо учесть.
CP R18,R16 ; Указатель чтения достиг
указателя записи?
BRNE NeedPop ; Нет! Буффер не пуст.
Работаем дальше
LDI R19,1 ; Код ошибки - пустой буффер!
RJMP _TX_OUT ; Выходим
NeedPop: CLR R17 ; Получаем ноль
STS IN_FULL,R17 ; Сбрасываем флаг переполнения
ADD XL,R18 ; Сложением адреса со
смещением
ADC XH,R17 ; получаем адрес точки чтения
LD R17,X ; Берем байт из буффера
CLR R19 ; Сброс кода ошибки
INC R18 ; Увеличиваем смещение
указателя чтения
CPI R18,MAXBUFF_OUT ; Достигли конца
кольца?
BRNE _TX_OUT ; Нет?
CLR R18 ; Да? Сбрасываем, переставляя
на 0
_TX_OUT: STS IN_PTR_S,R18 ; Сохраняем указатель
SEI ; Разрешаем прерывания
RET
Тут только один момент хитрый. Если у нас буфер переполнился, но не
перехлестнулся, то его начало и конец совпадают, что как бы сигнализирует
о том, что буфер пуст. Но на самом деле он полон непрочитанных данных и