Золотовский Д.В. Учебный курс для новичков по микроконтроллерам AVR. Часть 1
Подождите немного. Документ загружается.
порт и номер бита передавать в виде параметров шаблона. С номером бита
всё ясно – это целое число, его легко передать как нетиповой параметр
шаблона. А как быть с портом? Посмотрим, как определены порты ввода-
вывода в заголовочных файлах avr-gcc:
1
2
3
#define _MMIO_BYTE(mem_addr) (*(volatile uint8_t *)(mem_addr))
#define _SFR_MEM8(mem_addr) _MMIO_BYTE(mem_addr + __SFR_OFFSET)
#define PORTB _SFR_IO8(0x18)
Параметры шаблона могут быть только типовыми или целочисленными
константными выражениями, вычисляемыми во время компиляции. Ни
указатель, ни ссылку нельзя предать как параметр шаблона:
1
2
3
template<uint8_t *PORT, uint8_t PIN> //ошибка
class Pin
{...};
Может быть попробовать передавать адрес порта в виде целого числа, а
потом его преобразовывать в указатель:
1
2
3
4
5
6
7
8
9
10
template<unsigned PORT, uint8_t PIN>
class Pin
{
public:
static void Set()
{
*(volatile uint8_t*)(PORT + __SFR_OFFSET) |= (1 << PIN);
}
...
};
Это уже работает, но адрес порта придется задавать вручную в виде целого
числа, что неудобно:
1
2
3
typedef Pin<0x18, 1> Pin1;
...
Pin1::Set(); //sbi 0x18, 1
Взять адрес PORTB по имени не получится потому, что операция взятия
адреса не может появляться в константных выражениях, коими должны быть
параметры шаблона:
1
typedef Pin<(unsigned)&PORTB, 1> Pin1; // ошибка
Однако, нам нужно передавать не только адрес порта, ещё нужны PINx и
DDRx регистры. К тому-же, в таком виде о переносимости не может быть и
речи. Можно, конечно, написать макрос, которому передаём
соответствующие имена регистров, и он генерирует соответствующий класс.
Но тогда Pin будет слишком жестко завязан на конкретную реализацию
портов.
Можно написать перечисление в котором объявлены все порты с
удобочитаемыми именами и функцию, которая возвращает нужный порт в
зависимости от переданного параметра шаблона.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
enum
Ports {Porta, Portb, Portc};
template<Ports PORT, uint8_t PIN>
class Pin
{
public:
static volatile uint8_t & GetPort()
{
switch(PORT)
{
case Porta: return PORTA;
case Portb: return PORTB;
case Portc: return PORTC;
}
}
static volatile uint8_t & GetPin(){...}
static volatile uint8_t & GetDDR(){...}
static void Set()
{
GetPort() |= (1 << PIN);
}
...
};
Функцию GetPort можно объявить как внутри класса, так и снаружи.
Реализовать её можно, например, с помощью оператора switch или
специализаций шаблонной функции:
1 template<Ports PORT>
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
volatile uint8_t & GetPort();
template<>
volatile uint8_t & GetPort<Porta>()
{
return PORTA;
}
template<>
volatile uint8_t & GetPort<Portb>()
{
return PORTB;
}
...
template<Ports PORT, uint8_t PIN>
class Pin
{
public:
static void Set()
{
GetPort<PORT>() |= (1 << PIN);
}
};
Однако, такой подход всё равно ограничен. В первую очередь потому, что
мы жестко завязываемся на конкретную реализацию портов. Во многих
семействах МК для управления портами ввода-вывода имеются
дополнительные регистры для быстрого сброса/установки/переключения
отдельных бит и много чего ещё. Вот, например, структура, описывающая
порт в МК семейства Atmel XMega:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
typedef struct PORT_struct
{
register8_t DIR; /* I/O Port Data Direction */
register8_t DIRSET; /* I/O Port Data Direction Set */
register8_t DIRCLR; /* I/O Port Data Direction Clear */
register8_t DIRTGL;
/* I/O Port Data Direction Toggle */
register8_t OUT; /* I/O Port Output */
register8_t OUTSET; /* I/O Port Output Set */
register8_t OUTCLR; /* I/O Port Output Clear */
register8_t OUTTGL; /* I/O Port Output Toggle */
register8_t IN; /* I/O port Input */
register8_t INTCTRL; /* Interrupt Control Register */
register8_t INT0MASK; /* Port Interrupt 0 Mask */
register8_t INT1MASK;
/* Port Interrupt 1 Mask */
register8_t INTFLAGS; /* Interrupt Flag Register */
register8_t reserved_0x0D;
17
18
19
20
21
22
23
24
25
26
27
register8_t reserved_0x0E;
register8_t reserved_0x0F;
register8_t PIN0CTRL; /* Pin 0 Control Register */
register8_t PIN1CTRL; /* Pin 1 Control Register */
register8_t PIN2CTRL; /* Pin 2 Control Register */
register8_t PIN3CTRL; /* Pin 3 Control Register */
register8_t PIN4CTRL; /* Pin 4 Control Register */
register8_t PIN5CTRL; /* Pin 5 Control Register */
register8_t PIN6CTRL; /* Pin 6 Control Register */
register8_t PIN7CTRL; /* Pin 7 Control Register */
} PORT_t;
Чтобы изолировать класс Pin от конкретной реализации портов ввода-вывода
введём дополнительный уровень абстракции. Добавление нового уровня
абстракции вовсе не обязательно влечёт за собой какие-то накладные
расходы.
С классом описывающим порт ввода-вывода у нас возникает та-же проблема,
что и с классом Pin: как связать класс с конкретными регистрами? Можно
конечно попытаться сделать это с помощью перечислений и частичной
специализации, но в данном случае это всё-таки лучше сделать с помощью
препроцессора:
1
2
3
4
#define MAKE_PORT(portName, ddrName, pinName, className, ID) \
class className{\
...
};
Теперь объявим портов на все случаи жизни:
1
2
3
4
5
6
7
#ifdef PORTA
MAKE_PORT(PORTA, DDRA, PINA, Porta, 'A')
#endif
...
#ifdef PORT
MAKE_PORT(PORTR, DDRR, PINR, Portr, 'R')
#endif
Проанализировав реализацию портов ввода-вывода различных семейств МК
составим минимальный интерфейс для эффективного управления портами
(управление режимами подтяжки пока опустим):
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
35
36
37
38
39
40
41
42
43
44
45
// Для ARM, например, это будет uint32_t.
typedef uint8_t DataT;
// Записать значение в порт PORT = value
static void Write(DataT value);
// Прочитать значение записанное в порт
static DataT Read();
//Записать значение направления линий В/В
static void DirWrite(DataT value);
// прочитать направление линий В/В
static DataT DirRead();
//Установить биты в порту PORT |= value;
static void Set(DataT value);
// Очистить биты в проту PORT &= ~value;
static void Clear(DataT value);
// Очистить по маске и установить PORT = (PORT & ~clearMask) | value;
static void ClearAndSet(DataT clearMask, DataT value);
// Переключить биты PORT ^= value;
static void Togle(DataT value);
// Установить биты направления
static void DirSet(DataT value);
// Очистиь биты направления
static void DirClear(DataT value);
// Переключить биты направления
static void DirTogle(DataT value);
// прочитать состояние линий В/В
static DataT PinRead();
// Уникальный идентификотор порта
enum{Id = ID};
// Разрядность порта (бит)
enum{Width=sizeof(DataT)*8};
Реализация этого интерфейса для семейств Tiny и Mega AVR будет
выглядеть так:
1
2
3
#define MAKE_PORT(portName, ddrName, pinName, className, ID) \
class className
{\
public:\
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
typedef uint8_t DataT;\
private:\
static volatile DataT &data()\
{\
return portName;\
}\
static volatile DataT &dir()\
{\
return ddrName;\
}\
static volatile DataT &pin()\
{\
return pinName;\
}\
public:\
static void Write(DataT value)\
{\
data() = value;\
}\
static void ClearAndSet(DataT clearMask, DataT value)\
{\
data() = (data() & ~clearMask) | value;\
}\
static DataT Read()\
{\
return data();\
}\
static void DirWrite(DataT value)\
{\
dir() = value;\
}\
static DataT DirRead()\
{\
return dir();\
}\
static void Set(DataT value)\
{\
data() |= value;\
}\
static void Clear(DataT value)\
{\
data() &= ~value;\
}\
static void Togle(DataT value)\
{\
data() ^= value;\
}\
static void DirSet(DataT value)\
{\
dir
() |= value;\
}\
static void DirClear(DataT value)\
56
57
58
59
60
61
62
63
64
65
66
67
68
69
{\
dir() &= ~value;\
}\
static void DirTogle(DataT value)\
{\
dir() ^= value;\
}\
static DataT PinRead()\
{\
return pin();\
}\
enum{Id = ID};\
enum{Width=sizeof(DataT)*8};\
};
Поскольку в семействе XMega все регистры порта сгруппированы в одну
структуру и есть специальные регистры чтобы быстро
устанавливать/очищать/переключать отдельные биты порта, реализация
нашего интерфейса будет несколько проще:
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
#define MAKE_PORT(portName, className, ID) \
class className{\
public:\
typedef uint8_t DataT;\
public:\
static void Write(DataT value)\
{\
portName.OUT = value;\
}\
static void ClearAndSet(DataT clearMask, DataT value)\
{\
Clear(clearMask);\
Set(value);\
}\
static DataT Read()\
{\
return portName.OUT;\
}\
static void DirWrite(DataT value)\
{\
portName.DIR = value;\
}\
static DataT DirRead()\
{\
return portName.DIR;\
}\
static void Set(DataT value)\
{\
portName.OUTSET = value;\
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
60
61
62
63
64
65
}\
static void Clear(DataT value)\
{\
portName.OUTCLR = value;\
}\
static void Togle(DataT value)\
{\
portName.OUTTGL = value;\
}\
static void DirSet(DataT value)\
{\
portName.DIRSET = value;\
}\
static void DirClear(DataT value)\
{\
portName.DIRCLR = value;\
}\
static DataT PinRead()\
{\
return portName.IN;\
}\
static void DirTogle(DataT value)\
{\
portName.DIRTGL = value;\
}\
enum{Id = ID};\
enum{Width=8};\
};
#ifdef PORTA
MAKE_PORT(PORTA, Porta, 'A')
#endif
...
#ifdef PORTR
MAKE_PORT(PORTR, Portr, 'R')
#endif
Аналогично можно определить порты В\В для других семейств МК.
Порты В/В теперь инкапсулированы в классы, и мы можем их использовать
как типовые параметры шаблонов. Приступим к реализации класса для линии
ввода-вывода:
1
2
3
4
5
6
7
template<class PORT, uint8_t PIN>
class TPin
{
public:
typedef PORT Port;
enum{Number = PIN};
static void Set()
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
{
PORT::Set(1 << PIN);
}
static void Set(uint8_t val)
{
if(val)
Set();
else Clear();
}
static void SetDir(uint8_t val)
{
if(val)
SetDirWrite();
else SetDirRead();
}
static void Clear()
{
PORT::Clear(1 << PIN);
}
static void Togle()
{
PORT::Togle(1 << PIN);
}
static void SetDirRead()
{
PORT::DirClear(1 << PIN);
}
static void SetDirWrite()
{
PORT::DirSet(1 << PIN);
}
static uint8_t IsSet()
{
return PORT::PinRead() & (uint8_t)(1 << PIN);
}
};
Протестируем полученный класс:
1
2
3
4
5
6
7
8
9
10
11
12
typedef TPin<Porta, 1> Pa1;
...
Pa1::Set();
//sbi 0x1b, 1 ; 27
Pa1::Clear();
//cbi 0x1b, 1 ; 27
Pa1::Togle();
//in r24, 0x1b ; 27
//ldi r25, 0x02 ; 2
//eor r24, r25
//out 0x1b, r24 ; 27
Для удобства определим короткие имена для всех возможных линий В/В:
1
2
3
4
5
6
7
8
9
10
11
#ifdef PORTA
typedef TPin<Porta, 0> Pa0;
...
typedef TPin<Porta, 7> Pa7;
#endif
...
#ifdef PORTR
typedef TPin<Portr, 0> Pr0;
...
typedef TPin<Portr, 7> Pr7;
#endif
Как видно, никаких накладных расходов нет, эффективность получилась на
уровне того, что можно получит с помощью препроцессора. Те кто давно
пишут на Си могут возразить – стоило ли писать какие-то непонятные классы
на две страницы вместо того, чтобы написать пару однострочных #define-ов
и получить тоже самое?
Конечно-же стоило. Ведь получили мы далеко не тоже самое. Во-первых,
класс TPin объединяет в себе все операции применимые к линии В/В. Во-
вторых, он жестко типизирован и его можно использовать как параметр
шаблона. Например, класс для записи значения в сдвиговый регистр:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
template<class ClockPin, class DataPin, class LatchPin, class T = uint8_t>
class ThreePinLatch
{
public:
typedef T DataT;
enum{Width=sizeof(DataT)*8};
static void Write(T value)
{
for(uint8_t i=0; i < Width; ++i)
{
DataPin::Set(value & 1);
ClockPin::Set();
value >>= 1;
ClockPin::Clear();
}
LatchPin::Set();
LatchPin
::Clear();
}
};