Золотовский Д.В. Учебный курс для новичков по микроконтроллерам AVR. Часть 1
Подождите немного. Документ загружается.
кода по размеру. Такты затраченные на выполнение определялись на
симуляторах AvrStudio и IAR EWAVR соответственно.
Результаты для этой функции:
•
gcc – 112 байт кода, время выполнения примерно 57-62 тактов.
•
IAR – 116 байт кода, 62-66 тактов.
Первым указано количество тактов если состояние энкодера не изменилось,
вторым — если изменилось. Количество тактов может несколько меняться в
зависимости от того, по какой ветке оператора switch пошла программа, но
диапазон этого изменения примерно такой.
Примерно треть времени тратится на сохранение восстановление регистров.
Вполне неплохо если нам нужен только один энкодер, но нам их надо много.
При масштабировании этого подхода размер и время обработки растут
практически пропорционально числу энкодеров. И если с рост размера
можно ограничить написав функцию EncoderScan так, чтобы она принимала
состояние и указатель на счетчик в качестве параметров, то скорость
обработки от этого только упадёт. Контроллер, ведь, не только энкодеры
обрабатывать должен, у него еще работа есть. Большую часть времени у нас
занимает непосредственно определение направления движения, к тому-же
оно выполняется для каждого энкодера последовательно.
Немного логики
Посмотрим на задачу определения направления вращения энкодера
формально:
Есть две логические функции «Вперёд» и «Назад». Они принимают 4
логических параметра и возвращают 1 в случае движения вперёд или назад
соответственно. Заданны эти функции таблицей истинности. А по таблице
истинности можно уже синтезировать логическое выражение. В нашем
контексте задачи это означает, что мы можем упаковать все значения x1, x2,
y1, y2 всех энкодеров в отдельные целочисленные переменные, и
обрабатывать разом данные со стольких энкодеров, сколько бит в этих
переменных. Неплохо так параллельно определить направление вращения
сразу до 8/16/32 энкодеров. Изменять значения счётчиков, конечно придётся
в цикле, параллельно это сделать уже не удастся.
Теперь только остаётся синтезировать это самое логическое выражение.
Возьмёмся для начала за функцию «Вперёд». Найдём в нашей таблице все
единичные значения этой функции:
Таблица 2.
№ y2 y1 x2 x1 Вперёд Назад Состояние
------------------------------------------------------------------
2 0 0 1 0 1 0 Вперёд
4 0 1 0 0 1 0 Вперед
B 1 0 1 1 1 0 Вперёд
D 1 1 0 1 1 0 Вперёд
Запишем для нашей функции логическое выражение, сразу на языке Си, чтоб
не мучатся с математической нотацией:
Fwd = ~x1 & x2 & ~y1 & ~y2 |
~x1 & ~x2 & y1 & ~y2 |
x1 & x2 & ~y1 & y2 |
x1 & ~x2 & y1 & y2;
Каждая строчка этого выражения соответствует одной строке в таблице. Если
в таблице аргумент имеет значение «0», то в нашем выражении записываем
его с отрицанием «~» (инверсия всех бит). Если он равен «1», то без
отрицания. Например, для первой строчки, только x2 имеет единичное
значение, x2 берём непосредственно, остальные аргументы с отрицанием:
~x1 & x2 & ~y1 & ~y2. Это выражение вернёт 1 только если x2 равен 1, а
остальные параметры 0. Склеивая выражения для каждой строчки с
помощью операции ИЛИ мы получим искомую функцию.
Но эта функция не оптимальна, её можно и нужно оптимизировать. Для этого
воспользуемся законами логики.
В первых двух строчках вынесем за скобки ~x1 & ~y2, а в последних двух —
вынесем x1 & y2:
~x1 & ~y2 & (x2 & ~y1 | ~x2 & y1)|
x1 & y2 & (x2 & ~y1 | ~x2 & y1) ;
Выражение в скобках (x2 & ~y1 | ~x2 & y1) это ни что иное, как
исключающее ИЛИ - x2 ^ y1.
Выражение ещё упростилось:
~x1 & ~y2 & (x2 ^ y1 )|
x1 & y2 & (x2 ^ y1 ) ;
Теперь вынесем за скобки x2 ^ y1 и получим:
(x2 ^ y1 ) & (~x1 & ~y2 | x1 & y2 );
Во вторых скобках если заменить «x» на «~x», то у нас снова получается
исключающее ИЛИ:
(x2 ^ y1 ) & (~x1 ^ y2 );
Инверсия одного из аргументов исключающего ИЛИ приводит к инверсии
всего выражения, значит, инверсию можно вынести за скобки:
(x2 ^ y1 ) & ~(x1 ^ y2 );
В результате получилось достаточно простое выражение (всего 4 операции)
для определения вращения энкодера вперёд. Это выражение симметрично
относительно индексов 1 и 2, и поменяв их местами получим выражение
определяющее движение назад:
(x1 ^ y2 ) & ~(x2 ^ y1 );
Теперь осталось только реализовать обработку нескольких энкодеров на
языке Си.
Ограничимся для начала максимум 8 энкодерами, чтобы значения умещались
в тип uint8_t.
1
2
3
4
5
6
7
// Тип переменных-счетчиков
typedef unsigned EncValueType;
//количество обрабатываемых энкодеров
enum{EncoderChannels = 8};
// Массив переменных-счетчиков
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
59
static volatile EncValueType EncoderValues[EncoderChannels];
// предыдущие состояния энкодеров
static uint8_t _x1, _x2;
// Определение вращения вперёд/назад
static inline uint8_t Detect(uint8_t x1, uint8_t x2, uint8_t y1, uint8_t y2)
{
//вот оно наше волшебное выражение
return (x2 ^ y1) & ~(x1 ^ y2);
}
//функции чтения текущего состояния энкодеров. Первый в второй датчики
соответственно.
// определим их позже
inline uint8_t EncRead1();
inline uint8_t EncRead2();
static inline void EncoderCapture()
{
// читаем текущее состояние сразу всех энкодеров
uint8_t y1 = EncRead1();
uint8_t y2 = EncRead2();
// определяем наличие движения вперёд
uint8_t fwd = Detect(_x1, _x2, y1, y2);
// меняем индексы 1 и2 местами и определяем наличие движения
назад
uint8_t back = Detect(_x2, _x1, y2, y1);
// сохраняем текущее состояние
_x1 = y1;
_x2 = y2;
// в цикле проходим по массиву счётчиков энкодеров
volatile EncValueType * ptr = EncoderValues;
for(uint8_t i = EncoderChannels; i; --i)
{
if(fwd & 1)
(*ptr) ++;
else
if(back & 1)
(*ptr) --;
ptr++;
fwd >>= 1;
back >>= 1;
}
}
// функции чтения текущего состояния энкодеров.
// реализуем их как душе угодно, то есть как энкодеры подключены.
//Нулевой бит в обоих значениях соответствует нулевому энкодеру, первый —
первому и т.д.
60
61
62
63
64
65
inline
uint8_t EncRead1()
{
return PINC;
}
inline uint8_t EncRead2()
{
return PIND;
}
Итак, посмотрим на результаты:
avr-gcc:
•
1 энкодер 108 байт - 63-70 такта
•
2 энкодера 162 байт - 77-84 тактов
•
8 энкодеров 138 байт - 216-276 тактов
IAR:
•
1 энкодер 128 байт - 86-94 такта
•
2 энкодера 128 байт - 100-116 тактов
•
8 энкодеров 128 байт - 186-248 тактов
При использовании только одного энкодера, результат примерно
сопоставимый с вариантом на базе оператора switch, даже чуть похуже.
Однако, уже при обсчете двух энкодеров преимущество становится
очевидным. Для восьми — оно ещё более значимо. Здесь основное время уже
занимает обход массива со счетчиками и изменение их значения.
•
Файл проекта для AVRGCC и IAR
Заключение
Применение таких логических функций позволяет распараллелить
вычисления для нескольких автоматов на битовом уровне. Это позволяет
сократить время выполнения кода и его размер в некоторых случаях в разы.
Подобный подход целесообразно применять в случае, если имеется
несколько однотипных устройств, управление которыми осуществляется с
помощью простого автомата состояний, например, шаговыми и BLDC
двигателями.
Организация древовидного меню
Почти для всех проектов на микроконтроллере с экранчиком требуется
система меню. Для каких-то проектов одноуровневое, для других —
многоуровневое древовидное. Памяти, как обычно, мало, поэтому хочется
запихнуть все во флэш.
Попутно, из проекта в проект, развивалась своя псевдоОС — таймеры,
события, диспетчеры. Я её полностью писал на си, оптимизацией и
вылизыванием еще не занимался. Перебирая разные системы, наткнулся на
MicroMenu:
Попробуем разобрать ее на части и прикрутить к системе.
Структура данных:
Меню организовано в виде четырехсвязного списка. Каждый элемент меню
(пункт меню) ссылается на предыдущего и последующего элемента, также
ссылается на своего родителя (пункт меню предыдущего уровня) и потомка
(пункт подменю). Если это первый пункт, то предыдущего элемента у него
нет, соответствующая ссылка пустая. Изобразим это на рисунке:
Для чего такая избыточность? По сути, с текущим пунктом меню можно
сделать четыре вещи:
•
Перейти вверх или вниз (предыдущий или следующий пункт)
•
Вернуться в родительское меню (если есть)
•
Выбрать текущий пункт. При этом мы или переходим в подменю (ели
оно есть), или выполняется команда, прикрепленная к этому пункту
меню.
При наличии джойстика (или четырех кнопок «крестом») эти действия как
раз вешаются на свою кнопку.
Соответственно, все эти действия отражают четыре указателя. В
оригинальной системе указатель на потомка обозван SIBLING, но я считаю
это идеологически неверным. Sibling – это родственник того же уровня. Брат
или сестра. Но никак не потомок. Поэтому мы будем использовать
идеологически выверенное CHILD.
Итак, описание структуры пункта меню:
1
2
3
4
5
6
7
8
typedef struct PROGMEM{
void *Next;
void *Previous;
void *Parent;
void *Child;
uint8_t Select;
const char Text[];
} menuItem;
Добавлен байт Select – это код команды, привязанный к текущему пункту.
Если у данного пункта есть подменю, код нулевой. Также есть поле Text.
Капитан Очевидность подсказывает, что это, собственно, текст пункта меню.
По расходам памяти — на каждый пункт меню расходуется 9 байт плюс
длина текстовой части. И это все — кладется во флеш.
Самое полезное, почерпнутое у MicroMenu – набор дефайнов для быстрого и
удобного определения меню.
1
2
3
4
5
6
#define MAKE_MENU(Name, Next, Previous, Parent, Child, Select, Text) \
extern menuItem Next; \
extern menuItem Previous; \
extern menuItem Parent; \
extern menuItem Child; \
menuItem Name = {(void*)&Next, (void*)&Previous, (void*)&Parent,
(void*)&Child, (uint8_t)Select, { Text }}
В чем пафос такой конструкции? Для того, чтобы определить текущий
элемент, нам надо указать ссылку на следующий, еще не известный
компилятору. Поэтому этот дефайн создает заведомо избыточное количество
описаний extern. Это означает, что такой идентификатор будет где-то описан,
не обязательно в этом же файле. В качестве бонуса это позволит растащить
меню по нескольким файлам, если вдруг возникнет такое неудовлетворенное
желание.
Теперь самое интересное: описание структуры меню, как на рисунке.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// для начала — пустой элемент. Который NULL на рисунке
#define NULL_ENTRY Null_Menu
menuItem Null_Menu = {(void*)0, (void*)0, (void*)0, (void*)0, 0, {0x00}};
enum {
MENU_CANCEL=1,
MENU_RESET,
MENU_MODE1,
MENU_MODE2,
MENU_MODE3,
MENU_SENS1,
MENU_SENS2,
};
// NEXT, PREVIOUS PARENT, CHILD
MAKE_MENU(m_s1i1, m_s1i2, NULL_ENTRY, NULL_ENTRY, m_s2i1, 0,
"Запуск");
MAKE_MENU(m_s1i2, m_s1i3, m_s1i1, NULL_ENTRY, m_s3i1, 0,
"Настройка");
MAKE_MENU(m_s1i3, NULL_ENTRY,m_s1i2, NULL_ENTRY, NULL_ENTRY,
MENU_RESET
, "Сброс");
// подменю Запуск
24
25
26
27
28
29
30
31
32
33
34
35
MAKE_MENU(m_s2i1, m_s2i2, NULL_ENTRY, m_s1i1, NULL_ENTRY,
MENU_MODE1, "Режим 1");
MAKE_MENU(m_s2i2, m_s2i3, m_s2i1, m_s1i1, NULL_ENTRY,
MENU_MODE2, "Режим 2");
MAKE_MENU(m_s2i3, NULL_ENTRY,m_s2i2, m_s1i1, NULL_ENTRY,
MENU_MODE3, "Режим 3");
// подменю Настройка
MAKE_MENU(m_s3i1, m_s3i2, NULL_ENTRY, m_s1i2, m_s4i1, 0,
"Давление");
MAKE_MENU(m_s3i2, NULL_ENTRY,m_s3i1, m_s1i2, m_s5i1, 0, "Время");
// подменю Давление
MAKE_MENU(m_s4i1, m_s4i2, NULL_ENTRY, m_s3i1, NULL_ENTRY,
MENU_SENS1, "Датчик 1");
MAKE_MENU(m_s4i2, NULL_ENTRY,m_s4i1, m_s3i1, NULL_ENTRY,
MENU_SENS2, "Датчик 2");
// подменю Время
MAKE_MENU(m_s5i1, m_s5i2, NULL_ENTRY, m_s3i2, NULL_ENTRY,
MENU_WARM, "Разогрев");
MAKE_MENU(m_s5i2, NULL_ENTRY,m_s5i1, m_s3i2, NULL_ENTRY,
MENU_PROCESS, "Процесс");
Готово!
Естественно, пункты меню можно описывать и вперемешку, в порядке
обхода дерева. Типа такого:
1
2
3
4
5
6
MAKE_MENU(m_s1i1, m_s1i2, NULL_ENTRY, NULL_ENTRY, m_s2i1, 0,
"Запуск");
// подменю Запуск
MAKE_MENU(m_s2i1, m_s2i2, NULL_ENTRY, m_s1i1, NULL_ENTRY,
MENU_MODE1, "Режим 1");
MAKE_MENU(m_s2i2, m_s2i3, m_s2i1, m_s1i1, NULL_ENTRY,
MENU_MODE2, "Режим 2");
MAKE_MENU(m_s2i3, NULL_ENTRY,m_s2i2, m_s1i1, NULL_ENTRY,
MENU_MODE3, "Режим 3");
MAKE_MENU(m_s1i2, m_s1i3, m_s1i1, NULL_ENTRY, m_s3i1, 0, "Настройка");
Можно даже пойти дальше — строить меню в какой-нибудь визуальной
среде, а потом автоматически генерировать такой список. Но это на потом.
Плюсы и минусы такой организации. Минус — явная избыточность. Плюс —
возможность быстро редактировать меню — вставить новый пункт, поменять