Золотовский Д.В. Учебный курс для новичков по микроконтроллерам AVR. Часть 1
Подождите немного. Документ загружается.
уже не получится.
Развивая тему с препроцессором можно задавать номер ножки и ее порт в
одном определении, ведь Си-шный препроцессор работает не с
идентификаторами и не какими-то ни-было языковыми конструкциями, а
просто со строковыми литералами.
1
2
3
#define LCD_RS PORTA, 0 //define MCU pin connected to LCD RS
#define LCD_RW PORTB, 1 //define MCU pin connected to LCD R/W
#define LCD_E PORTB, 2 //define MCU pin connected to LCD E
Добавим к этому средства для манипуляции линией и получим так
называемые макросы Аскольда Волкова:
1
2
3
4
5
6
7
#define _setL(port,bit) do { port &= ~(1 << bit); } while(0)
#define _setH(port,bit) do { port |= (1 << bit); } while(0)
#define _clrL(port,bit) do { port |= (1 << bit); } while(0)
#define _clrH(port,bit) do { port &= ~(1 << bit); } while(0)
#define _bitL(port,bit) (!(port & (1 << bit)))
#define _bitH(port,bit) (port & (1 << bit))
#define _cpl(port,bit,val) do {port ^= (1 << bit); } while(0)
Этот подход, в отличии от предыдущих, уже можно сделать переносимым на
разные аппаратные платформы. Достаточно только определить эти макросы
для целевой платформы соответствующим образом. Однако, у нас по-
прежнему остались нерешенными некоторые проблемы. Во-первых, большой
размер и низкое быстродействие кода, ведь мы используем побитовый вывод
в порты. Даже если часть линий находятся в одном порту и идут подряд,
определить эту ситуацию с помощью макросов невозможно. И если,
например, размер кода окажется слишком большим, то уже написанную и
отлаженную библиотеку придется подгонять под конкретный проект, плодя
многочисленные ее версии и, возможно, внося ошибки.
Во-вторых, подключение нескольких однотипных устройств возможно
только путём дублирования кода. Опять-же результирующий размер
программы неоправданно увеличивается. А потом в две версии одного и
того-же кода вносятся изменения независимо друг от друга и каждая из них
начинает жить своей жизнью. Спасает здесь только относительно малый
размер программ для встроенных систем, ведь если что не так, то можно всё
быстренько переписать заново.
Многие компиляторы для AVR поддерживают побитовый доступ к портам на
уровне специальных расширений компилятора (CVAVR, MicroC AVR) или
встроенных библиотек (IAR C/C++ Compiler for AVR). Такой побитовый
доступ несложно реализовать и в avr-gcc с помощью битовых полей
(собственно в IAR примерно так и это и реализовано):
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
typedef struct Bits_t
{
uint8_t Bit0 :1;
uint8_t Bit1 :1;
uint8_t Bit2 :1;
uint8_t Bit3 :1;
uint8_t Bit4 :1;
uint8_t Bit5 :1;
uint8_t Bit6 :1;
uint8_t Bit7 :1;
}Bits;
#define PortaBits (*((volatile Bits*)&PORTA))
#define LedPin PortaBits.Bit5
int main()
{
DDRA = 1 << 5;
while(1)
{
LedPin = 1;//зажечь
_delay_ms(100);
LedPin = 0;//выключить
_delay_ms(100);
}
}
Получается немного чище и удобнее, чем в случае использования макросов,
но принципиальных отличий нет. Те-же достоинства и недостатки.
В итоге при использовании препроцессора для манипуляций с портами
ввода-вывода мы получаем:
•
Простоту и ясность для простых вещей – очень просто написать пару
макросов, чтоб поморгать светодиодом.
•
Высокую скорость и компактность кода при отказе от универсальности
(все ножки в одном порту и желательно по порядку).
•
Не расходуется дополнительная память.
•
Содержащий большое количество битовых операций код достаточно
сложно читать.
•
Можно сделать универсально и относительно переносимо пожертвовав
размером и скоростью кода (побитовый вывод).
•
Для управления несколькими однотипными устройствами придется
дублировать код.
2. Передача порта через указатель.
Как уже выяснили один из основных недостатков пи работе с портами ввода-
вывода с помощью препроцессора это сложность использования однотипных
устройств. Такой сложности не возникает, если передавать порт в код,
который его использует через указатель.
Порты ввода-вывода в большинстве МК есть не что иное как просто ячейка
памяти или регистр в пространстве ввода-вывода и естественно к нему
можно обратиться по адресу через указатель.
Удобно запаковать указатель на порт и битовые маски нужных ножек в одну
структуру, чтоб потом ее передавать в функцию, которая что-то с ними будет
делать. Здесь лучше использовать именно битовые маски, а не битовые
позиции, иначе сдвиги вида (1 << some_bit_position) не могут быть
вычислены на этапе компиляции (потому, что some_bit_position не константа,
а переменная) и будут честно выполнится в каждом месте где встретятся.
Возьмём сдвиговый регистр-защёлку, например 74HC595, который часто
используется для экономии выводов МК при подключении многовыводной
периферии.
1
//ShiftReg.h
2
3
4
5
6
7
8
typedef struct ShiftReg_t
{
volatile uint8_t *port;
uint8_t data_pin_bm;
uint8_t clk_pin_bm;
uint8_t latch_pin_bm;
}ShiftReg;
…
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//ShiftReg.c
void WriteShiftReg(ShiftReg *reg, uint8_t value)
{
for(uint8_t i=0; i<8; i++)
{
if(value & 1) //выводим данные
*reg->port |= reg->data_pin_bm;
else
*reg->port &= ~reg->data_pin_bm;
//тактовый импульс
*reg->port |= reg->clk_pin_bm;
value >>= 1;
*reg->port &= ~reg->clk_pin_bm;
}
//защёлкиваем данные в регистр
*reg->port |= reg->latch_pin_bm;
*reg->port &= ~reg->latch_pin_bm;
}
…
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//main.c
#include <avr/io.h>
//вывода data и clk могут быть общие.
ShiftReg reg1 = {&PORTA, 1<<1, 1<<2, 1<<3};
ShiftReg reg2 = {&PORTA, 1<<1, 1<<2, 1<<4};
int main()
{
DDRA = 0xff;
DDRB = 0xff;
WriteShiftReg(®1, 0xff);
WriteShiftReg(®2, 0x55);
while(1)
{
}
}
От дублирования кода мы избавились, одна функция WriteShiftReg
используется для записи во много сдвиговых регистров. Читаемость кода не
пострадала. К тому-же появилась возможность менять порт и ножки к
которым подключен регистр во время выполнения программы. Полезность
такой возможности, правда, сомнительна особенно для маленьких МК. Таким
способом удобно работать с перифирией требующей немного линий ввода-
вывода и подключенноу к МК во множественном числе, в том числе
подключенные с использованием каких-либо последовательных протоколов
USART, SPI (если не хватает аппаратных) 1-Wire и т.д.
Подключение таким образом устройств требующих много линий ввода-
вывода непрактично. Код получится слишком громоздким, медленным и
требующим много памяти. В данном примере каждый такой сдвиговый
регистр занимает 5 байт памяти. Да и побитовый доступ к порту через
указатель не самая дешёвая операция:
1
*reg->port |= reg->latch_pin_bm;
Фрагмент ассемблерного листинга WriteShiftReg
1
2
3
4
5
6
7
8
9
LD
r30, X+
LD r31, X
SBIW r26, 0x01 ; 1
LD r24, Z
ADIW r26, 0x04 ; 4
LD r25, X
SBIW r26, 0x04 ; 4
OR r24, r25
ST Z, r24
Как видно, компилятор не может теперь сопримизировать обращение к порту
и установка бита теперь занимает 9 инструкций вместо одной.
Чтобы несколько оптимизировать код можно ввести дополнительные
ограничения, например, задать номера ножек константами, и выкинуть
соответствующие им битовые маски. В примере со сдвиговым регистром
можно заменить константами data_pin_bm и clk_pin_bm и исключить их из
структуры, а latch_pin_bm оставить как есть для универсальности:
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
typedef struct ShiftReg_t
{
volatile uint8_t *port;
uint8_t latch_pin_bm;
}ShiftReg;
enum {clk_pin_bm = 1 << 0, data_pin_bm = 1 << 1};
...
//ShiftReg.c
void WriteShiftReg(ShiftReg *reg, uint8_t value)
{
for(uint8_t i=0; i<8; i++)
{
if(value & 1) //выводим данные
*reg->port |= data_pin_bm;
else
*reg->port &= ~>data_pin_bm;
//тактовый импульс
*reg->port |= clk_pin_bm;
value >>= 1;
*reg->port &= clk_pin_bm;
}
//защёлкиваем данные в регистр
*reg->port |= reg->latch_pin_bm;
*reg->port &= ~reg->latch_pin_bm;
}
Такая оптимизация сократит код WriteShiftReg примерно на 25 % с
незначительной потерей в удобстве.
Итого:
•
Удобно использовать для подключения многих однотипных устройств,
требующих не много линий ввода-вывода.
•
Нет необходимости в дублировании кода.
•
Можно менять порт и линии подключения устройства во время
выполнения программы.
•
Низкая скорость доступа к портам.
•
Большой размер кода.
•
Требуется дополнительная память для хранения указателя на порт и
битовых масок.
•
Неудобно и неэффективно работать с большим количеством линий
ввода-вывода.
3. Виртуальные порты
Нужно подключить к МК несколько устройств требующих достаточно много
линий ввода-вывода, драйвер которых обладает достаточно сложной и
объёмной логикой, например, тот-же дисплей HD44780 (при использовании
4х битного интерфейса требует 7 линий). К тому-же устройства могут быть
подключены различными способами – к разным линиям портов, или через
сдвиговый регистр. Дублировать код драйвера и подгонять его под каждый
способ подключения устройства – нет уж, спасибо. Да и размер
скомпилированного кода рискует не поместится в целевой МК. Передавать
порты драйверу в через указатели? Слишком большие накладные расходы
при работе с портами через указатели, много памяти, медленно и громоздко.
Здесь лучше применить, так называемые виртуальные порты. На языке Си
они могут быть реализованы как группа функций, принимающих входное
значение и выполняющих соответствующие операции ввода-вывода:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
void VPort1Write(uint8_t value)
{
PORTA = (PORTA & 0xf0) | (value & 0x0f);
PORTB = (PORTB & 0x0f) | (value & 0xf0) >> 4;
}
void VPort1DirWrite(uint8_t value)
{
DDRA = (DDRA & 0xf0) | (value & 0x0f);
DDRB = (DDRB & 0x0f) | (value & 0xf0) >> 4;
}
uint8_t VPort1Read()
{
return (PORTA & 0xf0) | (PORTB & 0x0f) << 4;
}
uint8_t VPort1PinRead
()
19
20
21
{
return (PINA & 0xf0) | (PINB & 0x0f) << 4;
}
В этом примере входное значение из 8-ми бит распределено между 4-мя
младшими битами портов PORTA и PORTB.
Реализация функции для вывода команды в дисплей HD44780 с
использованием такого виртуального порта будет выглядеть так:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//объявляем тип указателя на функцию
typedef void (*WriteFunc)(uint8_t);
void LCDwrite4(uint8_t value, WriteFunc write)
{
enum{LCD_E=4, LCD_RS=5, LCD_RW=6};
uint8_t tmp;
tmp = (value & 0x0f) | (1 << LCD_E);//совмещаем вывод тетрады
write(tmp); //и установку LCD_E
_delay_ms(1);
tmp &= ~(1 << LCD_E);
write(tmp);
_delay_ms(1);
}
void LCDsendCommand(uint8_t cmd, WriteFunc write) //Sends Command to LCD
{
LCDwrite4(cmd >> 4, write); //старшая тетрада
LCDwrite4(cmd, write); //младшая тетрада
}
…
1
2
3
4
5
6
7
void DoSomthing()
{
...
VPort1DirWrite(0xff);
LCDsendCommand(0x30, VPort1Write);
...
}
Теперь становится не важно как именно подключен дисплей к МК. Всё
тяжёлая работа по манипуляции портами возложена на функцию
VPort1Write. Для каждого способа подключения дисплея нам нужно только
написать соответствующую реализацию виртуального порта, тут уже
насколько фантазии хватит. Используя, например, уже написанную функцию
WriteShiftReg, легко подключить дисплей через сдвиговый регистр:
1
2
3
4
5
6
ShiftReg reg1 = {&PORTA, 1};
void VPort2Write(uint8_t value)
{
WriteShiftReg(®1, value);
}
Такой подход достаточно эффективен для вывода многобитного значения. Из
накладных расходов только вызов функции по указателю, но за один вызов
выводится сразу много бит. Это эффективнее побитового вывода в порт, но
менее эффективно вывода в обычный порт (когда все линии устройства
подключены по логическому порядку к одному порту). Тут всё уже зависит
от того как реализована функция виртуального порта. Однако если нужно
изменить только один бит, то придется запомнить предыдущее значение (или
прочитать его из порта), наложить на него соответствующую битовую маску
и записать в виртуальный порт. То есть изменения одного бита в этом порту
будет дороже записи всех бит порта. Поэтому, например, в функции
LCDwrite4 запись тетрады совмещена с установкой бита LCD_E.
Если необходимо не только писать в виртуальный порт, но и читать из него и
управлять направлением, подтяжкой или ещё что-то, то функций
реализующих виртуальный порт будет много и все их надо писать .
Чего-же мы добились с помощью виртуальных портов:
•
Логика работы с устройством полностью отделена от способа
подключения устройства.
•
Нет необходимости в дублировании кода.
•
Сравнительно небольшие накладные расходы на вывод в порт.
•
Чистота и понятность кода.
•
Необходимо вручную писать реализацию виртуального порта – много
однотипных функций (совсем зажрались, подумают некоторые
товарищи).
•
Манипуляции с отдельными битами неэффективны.
Подход Си++ к работе с портами.
Что может нам предложить язык Си++ при работе с портами ввода-вывода по
сравнению чистым Си? Давайте сначала сформулируем, что мы хотим
получить в результате наших изысканий:
•
1. Логика работы с устройством должна быть отделена от способа его
подключения.
•
2. Не должно быть дублирования кода при подключении многих
однотипных устройств.
•
3. Эффективно работать с отдельными битами.
•
4. Эффективно работать с многобитовыми значениями.
•
5. Решение должно быть переносимо на разные аппаратные
платформы.
•
6. Не должно использоваться дополнительная память.
•
7. Легкость написания и сопровождения кода.
•
8. Реализация полностью на стандартном Си++.
От динамической конфигурации линий ввода-вывода сразу отказываемся из-
за необходимости доступа к портам через указатель со всеми вытекающими
последствиями.
Удобно было бы описать линию ввода-вывода в виде отдельной сущности,
т.е. класса. В Си++ даже если в классе не объявлено ни одного поля,
переменная этого класса всё равно будет иметь размер как минимум один
байт, потому, что переменная должна иметь адрес. Значит, нам не надо
создавать объекты этого класса, а все функции в нем сделать статическими.
А как тогда различать разные линии? Можно сделать этот класс шаблоном, а