Золотовский Д.В. Учебный курс для новичков по микроконтроллерам AVR. Часть 1
Подождите немного. Документ загружается.
местами, удалить. Изменяются только соседние элементы меню, без
тотальной перенумерации. Мне этот плюс перевесил все остальные минусы.
Опять же бонус — можно организовать несколько не связанных друг с
другом деревьев меню. Главное не потерять точку входа.
Дальше. Как ходить по меню. Автор предлагает несколько дефайнов. Я их
сохранил, хотя можно и без них обойтись.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#define PREVIOUS ((menuItem*)pgm_read_word(&selectedMenuItem->Previous))
#define NEXT ((menuItem*)pgm_read_word(&selectedMenuItem->Next))
#define PARENT ((menuItem*)pgm_read_word(&selectedMenuItem->Parent))
#define CHILD ((menuItem*)pgm_read_word(&selectedMenuItem->Child))
#define SELECT (pgm_read_byte(&selectedMenuItem->Select))
menuItem* selectedMenuItem; // текущий пункт меню
void menuChange(menuItem* NewMenu)
{
if ((void*)NewMenu == (void*)&NULL_ENTRY)
return;
selectedMenuItem = NewMenu;
}
Вроде должно быть понятно. Выполняется проверка, если есть куда
переходить, то переходим. Иначе - не переходим. Вызывается эта процедура
таким образом:
1
menuChange(PREVIOUS);
Далее, процедура реакции на нажатие клавиш (в качестве параметра
передается код нажатой клавиши):
1
2
3
4
5
6
7
8
9
uint8_t keyMenu(msg_par par) {
switch (par) {
case 0: {
return 1;
}
case KEY_UP: {
menuChange
(PREVIOUS);
break;
}
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
case KEY_DOWN: {
menuChange(NEXT);
break;
}
case KEY_RIGHT:
;
case KEY_OK:
{ // выбор пункта
uint8_t sel;
sel = SELECT;
if (sel != 0) {
sendMessage(MSG_MENU_SELECT, sel);
killHandler(MSG_KEY_PRESS, &keyMenu);
killHandler(MSG_DISP_REFRESH, &dispMenu);
return (1);
} else {
menuChange(CHILD);
}
break;
}
case KEY_LEFT: { // отмена выбора (возврат)
menuChange(PARENT);
}
}
dispMenu(0);
return (1);
}
Процедура отрисовки меню. Зависит от выбраного экранчика, а также от
используемой анимации при выборе. Например, у меня экранчик 128х64
точки, текущий пункт меню всегда посередине экрана, сверху и снизу
выводятся два предыдущих и два последующих элемента (если есть).
Отрисовка вызывается после каждого нажатися на кнопку и по таймеру, два
раза в секунду. Мало ли, может изменится что.
В шапке можно выводить текст родителя, чтобы знать, где находимся.
Можно двигать курсор по пунктам, а не пункты прокручивать. На вкус и цвет
все фломастеры разные.
1
2
3
4
5
char* menuText(int8_t menuShift)
{
int8_t i;
menuItem
* tempMenu;
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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
if ((void*)selectedMenuItem == (void*)&NULL_ENTRY)
return strNULL;
i = menuShift;
tempMenu = selectedMenuItem;
if (i>0) {
while( i!=0 ) {
if ((void*)tempMenu != (void*)&NULL_ENTRY) {
tempMenu =
(menuItem*)pgm_read_word(&tempMenu->Next);
}
i--;
}
} else {
while( i!=0 ) {
if ((void*)tempMenu != (void*)&NULL_ENTRY) {
tempMenu =
(menuItem*)pgm_read_word(&tempMenu->Previous);
}
i++;
}
}
if ((void*)tempMenu == (void*)&NULL_ENTRY) {
return strNULL;
} else {
return ((char *)tempMenu->Text);
}
}
unsigned char dispMenu(msg_par par) {
char buf[25];
LCD_clear();
sprintf_P(buf, PSTR(">%-20S"), menuText(0));
LCD_putsXY(2, 28, buf);
sprintf_P(buf, PSTR("%-20S"), menuText(-2));
LCD_putsXY(2, 8, buf);
sprintf_P(buf, PSTR("%-20S"), menuText(-1));
LCD_putsXY(5, 17, buf);
sprintf_P(buf, PSTR("%-20S"), menuText(1));
LCD_putsXY(5, 39, buf);
sprintf_P(buf, PSTR("%-20S"), menuText(2));
LCD_putsXY
(2, 48, buf);
LCD_drawLine(0, 26, 127, 26, 1);
58
59
LCD_drawLine(0, 34, 127, 34, 1);
return (1);
}
И последний штрих — инициализация меню:
1
2
3
4
5
6
7
void startMenu(void) {
selectedMenuItem = (menuItem*)&m_l1i1;
dispMenu(0);
setHandler(MSG_KEY_PRESS, &keyMenu);
setHandler(MSG_DISP_REFRESH, &dispMenu);
}
Для начала хватит. В продолжении — сделать несколько меню, сделать
процедуру работы с меню реентерабельной, забабахать модель в протеусе.
Краткое описание того, что делает процедура setHandler - она привязывает
обработчик к событию. В данном случае, при возникновении события
MSG_KEY_PRESS вызовется функция keyMenu для обработки этого
события.
Для демонстрации системы меню, описанной в предыдущем посте, собрал
модель в протеусе. На базе двухстрочного LCD-индикатора,
контроллераatmega32 и пяти кнопок (влево-вправо-вверх-вниз и выбор). В
своих схемах использую джойстики от мобилок, они тоже пятипозиционные.
Также воткнул три светодиода, чтобы хоть как-то реагировать на выбор
пунктов меню.
Поскольку на экране у нас всего две строчки, решил отображение меню
сделать горизонтальным. В верхней строчке отображается родительский
пункт меню (или просто “Меню:”, если мы на верхнем уровне), во второй
строчке - текущий пункт меню. Клавишами влево-вправо выбираем
предыдущий-следующий. Клавишей вверх - возвращаемся в родительское
меню, клавиша вниз (или ОК) - заходим в выбранный пункт.
Обработка меню:
•
при выборе пунктов Start/Mode 1, Start/Mode 2, Start/Mode 3 загорается
соответствующий светодиод
•
при выборе пункта Reset - все светодиоды гаснут
•
после выбора любого конечного пункта, возвращаемся обратно в
корень меню.
Некоторые модификации, связанные с моделированием:
•
заменил весь текст на английский, потому что в оригинале модель
экранчика не поддерживает русский язык. Да, я знаю, про замену dll,
но не у всех она есть, а для просмотра - пойдет.
•
моя боевая библиотека работы с LCD почему-то отказалась работать с
моделью. Поэтому взял какую-то первую попавшуюся из древнего
проекта.
•
отключил автоповтор кнопок (на модели неудобно работать), но он
есть
Ну и, надеюсь, мне простят подключение светодиодов без балластного
резистора? ;)
Файлы к статье
•
Исходники
•
Файлы для Proteus
Работа с портами ввода-вывода микроконтроллеров на Си++
При разработке программ для микроконтроллеров (МК) работа с внутренний
и внешней периферией является очень важной частью (а иногда и
единственной) программы. Это своего рода фундамент, на котором
основывается более высокоуровневая логика программы. От эффективности
взаимодействия с периферией напрямую зависит эффективность программы
в целом. Под эффективностью здесь следует понимать не только скорость
выполнения и минимальный размер кода, но и эффективность написания и
сопровождения кода.
Многие внешние устройства подключаются к МК через порты ввода-вывода
общего назначения (GPIO). Эффективность взаимодействия с этими
устройствами во многом зависит от способа работы с портами ввода-вывода.
Тут возникают два, на первый взгляд, противоречивых требования:
•
1)Драйвера внешней периферии хочется писать максимально
абстрагировавшись от конкретного способа подключения к
микроконтроллеру, а ещё лучше независимо от типа
микроконтроллера. Переписывать «библиотечный» код для каждого
проекта не очень хорошо.
•
2)Скорость и размер кода в большинстве случаев имеют большое
значение.
Ситуация осложняется огромным количеством способов подключения
одного внешнего устройства к одному контроллеру и в большинстве случаев
определяется удобством изготовления печатной платы наличием свободных
линий в порту, необходимостью использовать некоторые линии портов для
их специальных возможностей и т.д. Устройство может быть подключено как
к одному порту, так и к нескольким, линии порта могут быть как
упорядочены по их логическому весу в подключенном устройстве, так и нет.
Оно вообще может быть подключено через какой-нибудь расширитель ввода-
вывода, например, сдвиговый регистр. При таком разнообразии очень
сложно, чтобы драйвер устройства не был заточен под конкретный способ
подключения этого устройства, или-же не был слишком громоздким и
медленным в случае более универсального решения.
Кажется, что найти универсальное и эффективное решение здесь
невозможно. Очень часто в пользу скорости и компактности кода жертвуют и
универсальностью и логической структурой программы и как следствие
читаемостью кода, просто не отделяя способ подключения устройства от
логики его работы. При этом код драйвера модифицируется и подгоняется
вручную под каждый проект, под каждый способ подключения.
Давайте разберемся, какие методы работы с портами ввода-вывода
традиционно применяются при программировании на чистом Си.
Можно выделить следующие подходы (вариант с жестко заданными в коде
именами портов и номерами ножек не рассматриваем):
•
1) Определение портов и линий ввода-вывода с помощью
препроцессора.
•
2) Передача порта в код, который его использует, посредствам
указателя.
•
3) Виртуальные порты.
Примеры приведены для МК семейства AVR. Компилятор avr-gcc, но
описываемые подходы могут быть применены к любым другим МК, для
которых имеется стандартный Си/Си++ компилятор.
1. Препроцессор
Способов использования препроцессора для работы с портами в МК
существует великое множество. В самом простом и самом распространенном
случае просто объявляем порт и номера ножек, к которым подключено наше
устройство с помощью директивы #define, не забыв, конечно, про DDR и PIN
регистры, если они нужны.
Нет ничего проще, чем помигать светодиодом, подключенным к одному из
выводов МК:
1 #include <avr/io.h>
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <util/delay.h>
#define LED_PORT PORTA
#define LED_PIN 5
int main()
{
while(1)
{
LED_PORT |= 1 << LED_PIN; //зажечь
_delay_ms(100);
LED_PORT &= ~(1 << LED_PIN);
_delay_ms(100);
}
}
Строчка
1
LED_PORT |= 1 << LED_PIN;
после компиляции превращается в одну команду процессора:
1
sbi
PORTA, 5
также как и
1
LED_PORT &= ~(1 << LED_PIN);
компилируется в:
1
cbi
PORTA, 5
Выглядит всё очень просто и эффективно. А что, если нам надо управлять
несколькими линиями сразу?
Вот пример из хорошо известной библиотеки для работы с дисплеем
HD44780 Scienceprog.com Lcd Lib:
1
2
3
4
5
6
7
8
9
10
11
#define LCD_RS 0 //define MCU pin connected to LCD RS
#define LCD_RW 1 //define MCU pin connected to LCD R/W
#define LCD_E 2 //define MCU pin connected to LCD E
#define LCD_D4 4 //define MCU pin connected to LCD D3
#define LCD_D5 5 //define MCU pin connected to LCD D4
#define LCD_D6 6 //define MCU pin connected to LCD D5
#define LCD_D7 7 //define MCU pin connected to LCD D6
#define LDP PORTD //define MCU port connected to LCD data pins
#define LCP PORTD //define MCU port connected to LCD control pins
#define LDDR DDRD //define MCU direction register for port connected to LCD data
pins
#define LCDR DDRD //define MCU direction register for port connected to LCD
control pins
А вот так там выглядит функция инициализации дисплея:
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
void LCDinit(void)//Initializes LCD
{
_delay_ms(15);
LDP=0x00;
LCP=0x00;
LDDR|=1<<LCD_D7|1<<LCD_D6|1<<LCD_D5|1<<LCD_D4;
LCDR|=1<<LCD_E|1<<LCD_RW|1<<LCD_RS;
//---------one------
LDP=0<<LCD_D7|0<<LCD_D6|1<<LCD_D5|1<<LCD_D4; //4 bit mode
LCP|=1<<LCD_E|0<<LCD_RW|0<<LCD_RS;
_delay_ms(1);
LCP&=~(1<<LCD_E);
_delay_ms(1);
//-----------two-----------
LDP=0<<LCD_D7|0<<LCD_D6|1<<LCD_D5|1<<LCD_D4; //4 bit mode
LCP|=1<<LCD_E|0<<LCD_RW|0<<LCD_RS;
_delay_ms(1);
LCP&=~(1<<LCD_E);
_delay_ms(1);
//-------three-------------
LDP=0<<LCD_D7|0<<LCD_D6|1<<LCD_D5|0<<LCD_D4; //4 bit mode
LCP|=1<<LCD_E|0<<LCD_RW|0<<LCD_RS;
_delay_ms(1);
LCP&=~(1<<LCD_E);
_delay_ms(1);
//--------4 bit--dual line---------------
LCDsendCommand(0b00101000);
//-----increment address, cursor shift------
LCDsendCommand(0b00001110);
}
Здесь автор ещё пытается записывать биты в порт согласно тому, как они
заданы define-ами.
А в функции посылки команды в дисплей автор уже забыл про свои дефайны
и молчаливо полагает, что шина данных дисплея подключена строго к
старшим четырём разрядам порта:
1 void LCDsendCommand(uint8_t cmd) //Sends Command to LCD
2
3
4
5
6
7
8
9
10
11
12
13
{
LDP=(cmd&0b11110000);
LCP|=1<<LCD_E;
_delay_ms(1);
LCP&=~(1<<LCD_E);
_delay_ms(1);
LDP=((cmd&0b00001111)<<4);
LCP|=1<<LCD_E;
_delay_ms(1);
LCP&=~(1<<LCD_E);
_delay_ms(1);
}
В этом случае правильнее было-бы применить побитовый вывод в порт:
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
void LCDwrite4(uint8_t cmd)
{
LDP &= ~(1<<LCD_D7|1<<LCD_D6|1<<LCD_D5|1<<LCD_D4); //clear data bus
if(cmd & (1 << 0))
LDP |= LCD_D4;
if(cmd & (1 << 1))
LDP |= LCD_D5;
if(cmd & (1 << 2))
LDP |= LCD_D6;
if(cmd & (1 << 3))
LDP |= LCD_D7;
}
void LCDsendCommand(uint8_t cmd) //Sends Command to LCD
{
LCDwrite4(cmd);
LCP|=1<<LCD_E;
_delay_ms(1);
LCP&=~(1<<LCD_E);
_delay_ms(1);
LCDwrite4(cmd);
LCP|=1<<LCD_E;
_delay_ms(1);
LCP&=~(1<<LCD_E);
_delay_ms(1);
}
Так уже будет работать при любом распределении линий шины данных в
порту МК, однако размер кода несколько увеличится. С этим уже можно как-
то жить. А если для каждой линии завести свой дефайн для имени порта, то
таким образом уже можно будет распределить их по разным портам. Размер
кода при этом ещё больше раздуется, ведь совмещать записи, даже констант,