Золотовский Д.В. Учебный курс для новичков по микроконтроллерам AVR. Часть 1
Подождите немного. Документ загружается.
Простой пример его использования:
1
2
3
4
5
6
7
8
9
10
11
12
13
typedef ThreePinLatch<Pa0, Pb3, Pc2> Reg1;
int main()
{
Pa0::SetDirWrite();
Pb3::SetDirWrite();
Pc2::SetDirWrite();
while(1)
{
Reg1::Write(PORTD);
}
}
Вызов Reg1::Write компилируется в следующий ассемблерный листинг:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
Reg1::Write:
ldi r25, 0x00
sbrs r24, 0
rjmp .+4
sbi 0x18, 3
rjmp .+2
cbi 0x18, 3
sbi 0x1b, 0
cbi 0x1b, 0
subi r25, 0xFF
cpi r25, 0x08
breq .+4
lsr r24
rjmp .-24
sbi 0x15, 2
cbi 0x15, 2
ret
Сгенерированный листинг не уступает написанному вручную на ассемблере.
И кто говорит, что Си++ избыточен при программировании для МК?
Попробуйте переписать этот пример на чистом Си, сохранив чистоту и
понятность кода, разделение логики работы устройства от конкретной
реализации портов В/В и такую-же эффективность.
Списки линий ввода-вывода
Это только начало. Теперь нам предстоит самое интересное - реализовать
эффективный вывод многобитных значений. Для этого нам нужна сущность
объединяющая группу линий В/В – своеобразный список линий В/В.
Поскольку и порты и отдельные линии у нас представлены различными
классами, то логично реализовывать список линий с помощью шаблонов. Но
здесь есть одна проблема: список линий может содержать различное число
линий, а шаблоны в Си++ имеют фиксированное число параметров (а
стандарте Cxx03, в следующей версии появятся Variadic templates). Нам
поможет библиотека Loki, написанная Андреем Александреску. В ней
реализовано множество шаблонных алгоритмов для манипуляций со
списками типов произвольной длинны. Это нам подойдёт – списки типов
превращаются в списки линий ввода-вывода. Что, собственно, такое списки
типов лучше всего почитать у их автора Андрея Александреску в книге
Современное проектирование на С++. Очень рекомендую прочитать, хотя-бы
мельком, главу «Списки типов» в этой книге. Без этого будет мало понятно,
что происходит дальше.
Не во всех МК предусмотрены команду для манипуляций с отдельными
битами в портах В/В. В семействе MegaAVR тоже есть порты для которых
недоступны битовые операции. Поэтому чтобы сделать операции с портами
максимально эффективными нам нужно отказаться от побитового вывода –
одно чтение, модификация значения и запись.
То есть нужно записать N битов из входного значения в N битов произвольно
расположенных в нескольких портах В/В. Или по другому говоря,
сгруппировать записываемые биты по портам и вывести их за раз.
В упрощенном виде алгоритм записи значения в произвольный список линий
В/В будет выглядеть так:
1. Определить список портов к которых подключены линии из списка.
2. Для каждого порта:
•
Определить список линий к нему подключенный.
•
По этому списку сгенерировать битовую маску для битов, которые не
нужно менять.
•
Спроецировать биты из входного значения на соответствующие им
места в регистре порта во временный буфер.
•
Наложить битовую маску на регистр порта (т.е. очистить в нем те биту,
куда будем записывать новое значение)
•
Записать значение из временного буфера в регистр порта.
Выглядит всё это очень сложно. Когда мы пишем реализацию виртуальных
портов на Си, то все эти операции проделываем вручную, а сейчас наша
задача заставить компилятор выполнять эту работу. Для этого в нашем
распоряжении есть списки типов и техника шаблонного
метапрограммирования. Пусть компилятор сам тасует биты и считает
битовые маски! Приступим.
У каждой линии в списке есть два номера:
•
1. Номер бита во входном значении
•
2. Номер бита в порту, куда он отображается
Оба они понадобятся для того, чтобы спроецировать биты из входного
значения в порт.
Второй номер класс TPin помнит сам, оно хранится в enum-е:
1
enum
{Number = PIN};
Чтобы запомнить первый номер понадобится дополнительный шаблон:
1
2
3
4
5
6
template<class TPIN, uint8_t POSITION>
struct PW //Pin wrapper
{
typedef TPIN Pin;
enum{Position = POSITION};
};
Хотя можно было этого и не делать, а вычислять битовыю позицию потом с
помощью алгоритма IndexOf.
Этот шаблон хранит тип линии В/В и ее битовую позицию в списке. Теперь
приступим к генерации собственно списка линий. Для определённости
ограничим длину списка 16-ю линиями, ели надо можно добавить и больше,
потом. Для этого возьмём шаблон MakeTypelist из библиотеки Loki и
модифицируем его под свои нужды:
1
2
3
4
5
6
7
8
9
10
11
12
template
<
int Position, // стартовая битовая позиция, сначала это 0
typename T1 = NullType, typename T2 = NullType, typename T3 = NullType,
typename T4 = NullType, typename T5 = NullType, typename T6 = NullType,
typename T7 = NullType, typename T8 = NullType, typename T9 = NullType,
typename T10 = NullType, typename T11 = NullType, typename T12 = NullType,
typename T13 = NullType, typename T14 = NullType, typename T15 = NullType,
typename T16 = NullType, typename T17 = NullType
>
struct MakePinList
{
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
private:
// рекурсивно проходим все параметры
// на следующей итерации Position увеличится на 1,
// а T2 превратится в T1 и так далее
typedef typename MakePinList
<
Position + 1,
T2 , T3 , T4 ,
T5 , T6 , T7 ,
T8 , T9 , T10,
T11, T12, T13,
T14, T15, T16,
T17
>::Result TailResult;
enum{PositionInList = Position};
public:
// Result это и есть требуемый список линий
typedef Typelist< PW<T1, PositionInList>, TailResult> Result;
};
//конец списка
//конец рекурсии, когда список пуст
template<int Position>
struct MakePinList<Position>
{
typedef NullType Result;
};
В результате на выходе имеем «голый» список типов наших линий ввода
вывода. Мы уже можем объявить список из нескольких линий, сделать с ним
пока ничего нельзя – для него не определены никакие операции:
1
typedef MakePinList<Pa1, Pa2, Pa3, Pb2, Pb3>::Result MyList;
Зато его можно передать в другой шаблон как один параметр. Воспользуемся
этим и напишем класс, реализующий операции с этим списком:
1
2
3
4
5
template<class PINS>
struct PinSet
{
...
};
Далее напишем алгоритм для преобразования списка линий в список
соответствующих им портам:
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
//шаблон принимает список линий в качестве параметра
template <class TList> struct GetPorts;
// для пустого списка результат – пустой тип
template <> struct GetPorts<NullType>
{
typedef NullType Result;
};
// для непустого списка
// конкретизируем, что это должен быть список типов
// содержащий голову Head и хвост Tail
template <class Head, class Tail>
struct GetPorts< Typelist<Head, Tail> >
{
private:
// класс TPin помнит свой порт
// запоминаем этот тип порта
typedef typename Head::Pin::Port Port;
//рекурсивно генерируем хвост
typedef typename GetPorts<Tail>::Result L1;
public:
// определяем список портов из текущего порта (Port) и хвоста (L1)
typedef Typelist<Port, L1> Result;
};
Теперь мы можем конвертировать список линий в соответствующий список
портов, однако один и тот-же порт может содержаться в нем несколько раз.
Нам нужны не повторяющиеся порты, по этому воспользуемся алгоритмом
NoDuplicates из библиотеки Loki:
1
2
3
4
// конвертируем список линий в соответствующий список портов
typedef typename GetPorts<PINS>::Result PinsToPorts;
// генерируем список портов без дудликатов
typedef typename NoDuplicates<PinsToPorts>::Result Ports;
Чтобы организовать рекурсивный проход по списку портов понадобится еще
один шаблон класса. Назовём его PortWriteIterator. В качестве шаблонных
параметров он принимает список портов и исходный список линий:
1
template <class PortList, class PinList> struct PortWriteIterator;
В этом классе и будет находиться реализация операций с отдельными
портами. Определим специализацию этого класса для пустого списка линий.
1
2
3
4
5
6
7
template <class PinList> struct PortWriteIterator<NullType, PinList>
{
// DataType может быть uint8_t или uint16_t (а может и uint32_t в
дальнейшем)
template<class DataType>
static void Write(DataType value)
{ /*ничего не делаем тут*/ }
};
Далее необходимо выбрать из списка линий, те которые принадлежат
определённому порту.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// шаблон принимает два параметра:
// TList - список линий
// T – тип порта дл якоторого
template <class TList, class T> struct GetPinsWithPort;
// для пустого списка результат – пустой тип (т.е. тоже пустой список)
template <class T>
struct GetPinsWithPort<NullType, T>
{
typedef NullType Result;
};
// если TList это список типов, голова в котором это PW<TP
in<T, N>, M>, т.е. линия в
заданном порту T с битовыми позициями N и M в порту и во входном значении
соответственно, то вставляем её в голову нового списка. Рекурсивно обрабатываем
хвост.
template <class T, class Tail, uint8_t N, uint8_t M>
struct GetPinsWithPort<Typelist<PW<TPin<T, N>, M>, Tail>, T>
{
typedef Typelist<PW<TPin<T, N>, M>,
typename GetPinsWithPort<Tail, T>::Result> Result;
};
// если голова списка - любой другой тип, то вставляем на её место рекурсивно
обработанный хвост.
template <class Head, class Tail, class T>
struct GetPinsWithPort<Typelist<Head, Tail>, T>
{
typedef typename GetPinsWithPort<Tail, T>::Result Result;
};
Теперь вычислим битовую маску для порта.
1
2
3
4
5
6
7
//Параметр TList должен быть список линий
template <class TList> struct GetPortMask;
// Для пустого списка возвращаем 0.
template <> struct GetPortMask<NullType>
{
enum{value = 0};
};
8
9
10
11
12
13
template <class Head, class Tail>
struct GetPortMask< Typelist<Head, Tail> >
{ //value = битовая маска для головы | битовая маска оставшейся части
списка
enum{value = (1 << Head::Pin::Number) | GetPortMask<Tail>::value};
};
Теперь напишем реализацию для функции записи в порт:
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
// Head – голова списка портов – текущий порт
// Tail – оставшийся список
// PinList – исходный список линий.
template <class Head, class Tail, class PinList>
struct PortWriteIterator< Typelist<Head, Tail>, PinList>
{
//Определим линии принадлежащие текущему порту.
typedef typename GetPinsWithPort<PinList, Head>::Result Pins;
// Посчитаем битовую маску для порта
enum{Mask = GetPortMask<Pins>::value};
typedef Head Port;
template<class DataType>
static void Write(DataType value)
{
// проецируем биты из входного значения в соответствующие биты порта
// как это реализованно увидим дальше
uint8_t result = PinWriteIterator<Pins>::UppendValue(value);
// если кол-во бит в записываемом значении совпадает с шириной
порта,
// то записываем порт целиком.
// это условие вычислится во время компиляции
if((int)Length<Pins>::value == (int)Port::Width)
Port::Write(result);
else
{
// PORT = PORT & Mask | result;
Port::ClearAndSet(Mask, result);
}
// рекурсивно обрабатываем остальные порты в списке
PortWriteIterator<Tail, PinList>::Write(value);
}
}
Функция PinWriteIterator::UppendValue отображает биты во входном
значении в соответствующие им биты в порту. Эффективность списков
линий в целом зависит в первую очередь именно от реализации этого
отображения, поскольку оно, в общем случае, должно выполняться
динамически и не всегда может быть вычислено во время компиляции. В
зависимости от распределения записываемых бит в результирующем порту
применим несколько стратегий отображения бит:
•
если записываемые биты в порту расположены последовательно,
спроецируем их все сразу с помощью сдвига на нужное число бит и
соответствующей битовой маски
•
если одиночный бит в исходном значении и в порту имеют одну
позицию, спроецируем его с помощью побитного ИЛИ.
•
в остальных случаях, если бит во входном значении равен 1, то
устанавливаем в 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
28
29
30
31
32
// Tlist – список линий принадлежащих одному порту
template <class TList> struct PinWriteIterator;
// специализация для пустого списка – возвращаем 0
template <> struct PinWriteIterator<NullType>
{
template<class DataType>
static uint8_t UppendValue(const DataType &value)
{
return 0;
}
};
// специализация для непустого списка
template <class Head, class Tail>
struct PinWriteIterator< Typelist<Head, Tail> >
{
template<class DataType>
static inline uint8_t UppendValue(const DataType &value)
{
// проверяем, если линии в порту расположены последовательно
// если часть линий в середине списка будет расположена последовательно, то
// это условие не выполнется, так, что есть ещё простор для оптимизации.
if(IsSerial<Typelist<Head, Tail> >::value)
{
// сдвигаем значение на нужное число бит и накладываем не него
маску
if((int)Head::Position > (int)Head::Pin::Number)
return (value >> ((int)Head::Position - (int)Head::Pin::Number))
&
GetPortMask<Typelist<Head, Tail> >::value;
else
return (value << ((int)Head::Pin::Number - (int)Head::Position))
33
34
35
36
37
38
39
40
41
42
43
44
45
&
GetPortMask<Typelist<Head, Tail> >::value;
}
uint8_t result=0;
if((int)Head::Position == (int)Head::Pin::Number)
result |= value & (1 << Head::Position);
else
// это условие будет вычисляться во время выполнения программы
if(value & (1 << Head::Position))
result |= (1 << Head::Pin::Number);
// рекурсивно обрабатываем оставшиеси линии в списке
return result | PinWriteIterator<Tail>::UppendValue(value);
}
};
Для определения того, что линии в порту расположены последовательно
напишем следующий шаблон.
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
template <class TList> struct IsSerial;
// специализация для пустого списка
template <> struct IsSerial<NullType>
{
// пустой список последователен
enum{value = 1};
// номер текущей линии
enum{PinNumber = -1};
// признак конца списка
enum{EndOfList = 1};
};
// для непустого списка
template <class Head, class Tail>
struct IsSerial< Typelist<Head, Tail> >
{
// последовательна ли оставшаяся часть списка
typedef IsSerial<Tail> I;
// запоминаем номер текущей линии в её порту
enum{PinNumber = Head::Pin::Number};
// не конец списка
enum{EndOfList = 0};
// список последователен если
// номер текущей линии равен номеру следующей - 1 И
// оставшаяся часть списка последовательна ИЛИ
// текущая линия последняя в списке
enum{value = ((PinNumber == I::PinNumber - 1) && I::value) || I::EndOfList};
};
С учётом всего выше написанного класс PinSet будет выглядеть так:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
template<class PINS>
struct PinSet
{
private:
// конвертируем список линий в соответствующий список портов
typedef typename GetPorts<PINS>::Result PinsToPorts;
public:
typedef PINS PinTypeList;
// генерируем список портов без дудликатов
typedef typename NoDuplicates<PinsToPorts>::Result Ports;
// длинна списка линий
enum{Length = Length<PINS>::value};
// выбираем тип данных записываемый в список линий
// если длинна списка меньше или равна 8 берём тип uint8_t,
// если больше – uint16_t
typedef typename IoPrivate::SelectSize<Length <= 8>::Result DataType;
//записать значение в список линий
static void Write(DataType value)
{
PortWriteIterator<Ports, PINS>::Write(value);
}
};
Собственно списки линий уже должны работать:
1
2
3
4
typedef MakePinList<0, Pa1, Pa2, Pa3, Pb3, Pb4>::Result MyList;
typedef PinSet<MyList> MyPins;
...
MyPins::Write(0x55);
Однако, пользоваться ими пока не очень удобно. Поэтому сделаем вокруг
нашей реализации списков линий прозрачную и удобную обёртку:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
template
<
typename T1 = NullType, typename T2 = NullType, typename T3 = NullType,
typename T4 = NullType, typename T5 = NullType, typename T6 = NullType,
typename T7 = NullType, typename T8 = NullType, typename T9 = NullType,
typename T10 = NullType, typename T11 = NullType, typename T12 = NullType,
typename T13 = NullType, typename T14 = NullType, typename T15 = NullType,
typename T16 = NullType, typename T17 = NullType
>
struct PinList: public PinSet
<
typename MakePinList
< 0, T1,
T2 , T3 , T4 ,
T5
, T6 , T7 ,
T8 , T9 , T10,
T11, T12, T13,