Золотовский Д.В. Учебный курс для новичков по микроконтроллерам AVR. Часть 1
Подождите немного. Документ загружается.
18
19
20
21
22
23
T14, T15, T16, T17
>::Result
>
{
// тело этого класса пусое, весь функционал наследован от PinSet
};
Теперь можно объявлять списки линий следующим образом:
1
2
typedef PinList<Pa1, Pa2, Pa3, Pb3, Pb4> MyPins;
MyPins::Write(0x55);
Стало достаточно удобно – можно один раз объявить такой список линий, а
потом использовать его где угодно, передавать его как шаблонный параметр
в классы и функции реализующие управление периферией. А для того, чтобы
изменить способ подключения достаточно подправить только одну строку.
Настало время протестировать списки линий с различными конфигурациями
и на разных МК.
Выше приведённый пример компилируется в следующий ассемблерный
листинг:
1
2
3
4
5
6
7
8
9
10
//вывод в PORTA
in r24, 0x1b
andi r24, 0xF1
ori r24, 0x0A
out 0x1b, r24
//вывод в PORTB
in r24, 0x18
andi r24, 0xE7
ori r24, 0x10
out 0x18, r24
Как видно, компилятору все значения были известны и он благополучно
посчитал все битовые маски и логические операции, не оставив ничего
лишнего на время выполнения. А как он поведёт себя если записываемое
значение не известно во время компиляции? Рассмотрим следующий пример
(список линий тот-же самый):
1
2
// MCU AtMega16
MyPins::Write(PORTC);
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// читаем PORTC
in r18, 0x15 ; 21
//вывод в PORTA
in r25, 0x1b ; 27
mov r24, r18
add r24, r24
andi r24, 0x0E ; 14
andi r25, 0xF1 ; 241
or r24, r25
out 0x1b, r24 ; 27
//вывод в PORTB
in r24, 0x18 ; 24
andi r18, 0x18 ; 24
andi r24, 0xE7 ; 231
or r18, r24
out 0x18, r18 ; 24
В качестве значения неизвестного используем PORTC. Результат впечатляет,
неправда ли? Даже на ассемблере сложно написать эффективнее. К тому-же
если вручную считать все эти битовые маски, то очень велик риск
ошибиться.
Рассмотрим тот же пример скомпилированный для AtXMega128a1. В этом
МК порты В/В находятся в расширенном пространстве ввода-вывода и
недоступны для операций in и out. Реализация портов, учитывающая
особенности семейства XMega у нас уже написана.
1
2
typedef PinList<Pa1, Pa2, Pa3, Pb3, Pb4> MyPins;
MyPins::Write(PORTC.IN);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
// читаем PORTC.
I
N
lds r18, 0x0648
mov r25, r18
add r25, r25
andi r25, 0x0E ; 14
//вывод в PORTA
ldi r30, 0x00 ; 0
ldi r31, 0x06 ; 6
ldi r24, 0x0E ; 14
std Z+6, r24 ; 0x06
std Z+5, r25 ; 0x05
15
16
17
18
19
20
21
22
andi
r18, 0x18 ; 24
//вывод в PORTB
ldi r30, 0x20 ; 32
ldi r31, 0x06 ; 6
ldi r24, 0x18 ; 24
std Z+6, r24 ; 0x06
std Z+5, r18 ; 0x05
Как видно, говорить об избыточности и накладных расходах, которые может
повлечь использование Си++ здесь не приходится. Аналогичным образом
реализуем запись направления линий. Единственное отличие это то, что
теперь значение записывается в регистры управления направлением линий
(DDRx).
1
2
3
4
5
6
7
8
9
10
11
12
13
14
template<class PINS>
struct PinSet
{
...
static void Write(DataType value)
{
PortWriteIterator<Ports, PINS>::Write(value);
}
//запись направления
static void DirWrite(DataType value)
{
PortWriteIterator<Ports, PINS>::DirWrite(value);
}
};
И соответствующие дополнения в класс PortWriteIterator.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
template <class Head, class Tail, class PinList>
struct PortWriteIterator< Typelist<Head, Tail>, PinList>
{
...
template<class DataType>
static void DirWrite(DataType value)
{
uint8_t result = PinWriteIterator<Pins>::UppendValue(value);
if((int)Length<Pins>::value == (int)Port::Width)
Port::DirWrite(result);
else
{
Port
::DirClear(Mask);
Port::DirSet(result);
16
17
18
19
}
PortWriteIterator<Tail, PinList>::DirWrite(value);
}
};
Для полноты добавим, аналогичным образом операции Set, Clear, DirSet,
DirClear для установки и обнуления битов соответственно в регистрах порта
и регистрах направления.
Остаётся реализовать чтение состояния порта. Это несколько проще, чем
запись:
•
Читаем значение из каждого порта,
•
Проецируем биты из порта в выходное значение (в обратном порядке,
чем при записи),
•
Объединяем значения со всех портов в одно выходное значение.
Подробно на чтении останавливаться не будем.
Итак у нас уже есть средство для эффективной манипуляции портами ввода-
вывода МК. Но ведь задача была изначально шире – полностью изолировать
драйвера от с способа подключения устройств. И эта цель уже достигнута.
Класс TPin, реализующий линию ввода-вывода, как и списки линий
полностью изолированы от реализации портов В/В. Это было видно на том
примере, что у нас уже реализованы порты как для семейств Tiny/Mega AVR,
так и для XMega. Так вот, достаточно написать класс, реализующий
интерфейс порта В/В, и списки линий будут с ним прекрасно работать. Для
примера возьмём, уже рассмотренный ранее, сдвиговый регистр и будем его
использовать для расширения количества доступных линий В/В.
1
2
3
4
5
6
7
template<class ClockPin, class DataPin, class LatchPin, unsigned ID, class T = uint8_t>
class ThreePinLatch
{
public:
typedef T DataT;
// нужен для сортировки портов в списках линий
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
enum
{Id = ID};
//разрядность регистра
enum{Width=sizeof(DataT)*8};
// запись значения
static void Write(T value)
{
_currentValue = value;
for(uint8_t i=0; i < Width; ++i)
{
DataPin::Set(value & 1);
ClockPin::Set();
value >>= 1;
ClockPin::Clear();
}
LatchPin::Set();
LatchPin::Clear();
}
static DataT Read()
{
return _currentValue;
}
static void ClearAndSet(DataT clearMask, DataT value)
{
Write(_currentValue = (_currentValue & ~clearMask) | value);
}
static void Set(DataT value)
{
Write(_currentValue |= value);
}
static void Clear(DataT value)
{
Write(_currentValue &= ~value);
}
static void Togle(DataT value)
{
Write(_currentValue ^= value);
}
static void DirWrite(DataT value)
{ /*не можем менять направление*/ }
static DataT DirRead()
{
return 0xff; //всегда выход
}
static void DirSet(DataT value)
{/* не можем менять направление */}
static void DirClear(DataT value)
{/* не можем менять направление */ }
static void DirTogle(DataT value)
{/* не можем менять направление */}
protected
:
// текущее значение в регистре
static DataT _currentValue;
60
61
62
63
};
template<class ClockPin, class DataPin, class LatchPin, unsigned ID, class T>
T ThreePinLatch<ClockPin, DataPin, LatchPin, ID, T>::_currentValue = 0;
Мы не можем прочитать состояние выходных линий регистра – он всегда
работает на выход, поэтому функцию чтения состояния не реализуем и не
объявляем. Попытка прочитать состояние такого пора вызовет ошибку
компиляции. Зато на запись нет никаких ограничения. И мы свободно можем
использовать этот «порт» со списками линий.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
typedef ThreePinLatch<Pa0, Pa1, Pa3, 'R1'> ShiftReg1;
typedef TPin<ShiftReg1, 0> Rg0;
typedef TPin<ShiftReg1, 1> Rg1;
typedef TPin<ShiftReg1, 2> Rg2;
typedef TPin<ShiftReg1, 3> Rg3;
typedef TPin<ShiftReg1, 4> Rg4;
typedef TPin<ShiftReg1, 5> Rg5;
typedef TPin<ShiftReg1, 6> Rg6;
typedef TPin<ShiftReg1, 7> Rg7;
typedef PinList<Rg4, Rg5, Rg6, Rg7, Pb0, Pb1, Pb2, Pb3> MyPins;
...
MyPins::Write(PORTC);
Причем нет никаких ограничений на состав списка линий – можно
смешивать в одном списке линии сдвигового регистра и линии обычных
портов.
В наших целях значится не только работа с многобитными значениями, но и
манипуляции отдельными битами, поэтому добавим в интерфейс списков
линий функциональность для этого. Во первых, это доступ к отдельным
линиям из списка. Для этого в класс PinSet допишем следующий код:
1
2
3
template<uint8_t PIN>
class Pin :public TypeAt<PINS, PIN>::Result::Pin
{};
Здесь мы воспользовались алгоритмом TypeAt из библиотеки Loki, который
возвращает из списка типов указанную в параметре позицию. Пользоваться
этим достаточно просто:
1
2
3
4
5
// Установить линию с индексом 1 в единичное состояние.
// индексация начинается с 0
MyPins::Pin<1>::Set();
...
MyPins::Pin<1>::Clear();
Обобщая доступ к отдельным битам в списке линий приходим к концепции
среза. Не буду вдаваться в подробности их реализации, приведу лишь пример
использования:
1
2
// берём срез из MyPins начиная с 4-го бита, длинной 4 бита.
typedef MyPins::Slice<4, 4> OtherPins;
В результате получаем новый список линий OtherPins, который будет
содержать:
1
<Pb0, Pb1, Pb2, Pb3>
Этот механизм удобен для того, чтобы изменить значения отдельной группы
линий, не изменяя остальных. Компилятор для этого случая может
сгенерировать более эффективный код. В приведенном примере вызов
OtherPins::Write(что-нибудь) запишет значение в 4 бита PORTB, не затронув
линии в сдвиговом регистре.
Подведём итоги
Цели, поставленные перед реализацией ввода-вывода для МК на Си++ , были
достигнуты в полной мере. Достигнута как эффективность манипуляций с
многобитовыми значениями, так и отдельными линиями ввода-вывода.
Списки линий, как и код их использующий, полностью изолированы от
конкретной реализации портов. Чтобы добавить новый способ подключения
(например, через SPI расширитель портов) устройства использующего
списки линий, или портировать его на другое семейство МК, достаточно
написать соответствующий класс реализующий интерфейс порта ввода-
вывода.
Единственными существенными недостатками этого подхода является
относительная сложность реализации списков линий (но ведь они уже
написаны) и необходимость изучения языка Си++.
Архив с примерами для AVR Studio
© Константин Чижов
Email: klen1@mail.ru Сентябрь 2010
P.S. Наиболее актуальную версию списков линий (PinList) можно найти по
адресу:
github.com/KonstantinChizhov/AvrProjects/tree/master/avrcpp/
Управление множеством сервомашинок
При построении разных роботов порой приходится использовать несколько
сервоприводов. А если это какой-нибудь шестиногий паук, то приводов там
этих просто тьма. Как ими управлять? На форуме кое кто даже сокрушался,
что ему бы для этих целей плисину применить. Хотя на кой черт там
ПЛИСка, когда с рулением даже трех десятков сервоприводов справится
самый рядовой микроконтроллер, затребовав под это дело всего один таймер.
Итак, кто не помнит, как управляются сервы, может прогуляться в старую
статью и освежить знания.
Возьмем, для начала, 8 сервомашинок. На каждую серву идет вот такой
сигнал:
На каждую серву со своей ноги контроллера должна идти такая вот
последовательность. Итого подобие ШИМ’a на 8 каналов. Как сгенерировать
эту бодягу? Да проще простого. Принцип тут простой. Импульсы медленные
— всего то 50Гц, меняются тоже нечасто — серва штука инерционная,
поэтому даже сто раз в секунду ей не подергаешь. Так что времени на
обработку у нас вагон и маленькая тележка.
Сами импульсы будут генерироваться одним таймером, в фоновом режиме.
Принцип генерации прост: Все импульсы стартуют одновременно, выставляя
свои уровни в 1.
Затем в таймер, в регистр сравнения, заносится время длительности первого
импульса. По прерыванию сравнения происходит:
•
Сброс бита на порту первого канала
•
Загрузка в регистр сравнения таймера значения длительности второго
импульса
И таймер продолжает считать дальше. Загружая по очереди длительности
импульсов и отрабатывая все каналы. Когда досчитает до конца, то надо
настройкой прескалера замедлить его ход и отщелкать 20мс, а затем
повторить цикл.
Таким образом, у нас все восемь каналов формируются в прерывании
конечным автоматом, который сам себя загружает, сам сбрасывает биты и
так далее. Практически не тратя временные ресурсы контроллера, беря на
себя управление только тогда, когда надо сменить уровень на ноге, а это
очень малая по времени операция и очень редкое, в масштабах контроллера,
событие.
Есть лишь одна деталь — для успешной работы каналы серв должны быть
сортированы по возрастанию. Чтобы можно было просто последовательно
загружать значение и все.