Динамическая индикация – это одна из проблем, с которой сталкиваются начинающие программисты микроконтроллеров. О ней сказано многое, но я решил подкрепить известное картинками и примерами исходных текстов на Си, чтобы было проще освоить этот метод индикации.

1 Основы основ, или вступление

Прежде всего, определимся с терминологией, которой будем пользоваться на протяжении всей статьи.

Дисплей – средство отображения информации. Мы будем подразумевать, что дисплей у нас светодиодный, хотя принципиально он может быть любым – жидкокристаллическим, электролюминисцентным и даже плазменным.

Сегмент, пиксел – единичная светящаяся часть дисплея.

Знакоместо – для символьных дисплеев это элементарная ячейка, отображающая комбинацией светящихся сегментов тот или иной символ. Например, для дисплея из семисегментных светодиодных индикаторов знакоместо состоит из одного индикатора. т. е. содержит 8 сегментов. В некоторых случаях «знакоместо» используется в качестве синонима слова «разряд».

Теперь несколько слов о том, для чего и как делается динамическая индикация.

Если требуется управлять дисплеем, состоящим из единственного семисегментного знакоместа, это не вызывает никаких проблем – его можно представить, как 8 независимых светодиодов. Если требуется вывести информации побольше, чем единственный символ, начинаются проблемы: 2 знакоместа составляют 16 светодиодов, три – 24 и т. д., то есть уже для трехразрядного дисплея может элементарно не хватить выводов микроконтроллера, не говоря о 6-и или более разрядных дисплеях и, тем более, матричных индикаторах.

Условимся для простоты, что все наши индикаторы с общим катодом. Решение проблемы достаточно простое: соединяют выводы сегментов всех индикаторов между собой. Теперь, если требуется вывести информацию в первое знакоместо, следует подать на линии сегментов нужные уровни, а общий вывод первого индикатора соединить с общим проводом схемы. Разумеется, на общих катодоах всех прочих индикаторов должны присутствовать высокие уровни. Очевидно, что нужные сегменты первого индикатра засветятся. Для вывода на второй, третий и т. д. индикаторы следует поступить аналогично, т. е. подавая на один из общих катодов логический ноль, мы выбираем текущий индицируемый разряд, а состояние линий сегментов определяет видимый символ.

Принцип динамической индикации

Чтобы весь дисплей воспринимался, как светящийся непрерывно, следует переключать разряды быстро – чаще 25 раз в секунду. Как видим, уровни всех выводов (которых, кстати, стало существенно меньше, чем при обычном подходе) непрерывно изменяются, т. е. имеют не статические уровни, а динамические, отсюда и название способа индикации – динамическая.

Изображение при динамической индикации

2 Разновидности аппаратной реализации

2.1 Плоские матрицы

Если абстрагироваться от семисегментных индикаторов, то наш дисплей можно представить в виде матрицы отдельных светодиодов, аноды которых объединены в строки матрицы, а катоды – в столбцы. Собственно, именно так оно и есть.

Очевидно, что подавая нужные уровни на строки и столбцы нашей матрицы, мы можем зажечь любой элементарный светодиод-сегмент (он же пиксел – это более традиционный термин применительно к матричным дисплеям). В зависимости от того, как именно мы будем сменять уровни на строках и столбцах, мы можем получить несколько разновидностей динамической индикации:

• по строкам;
• по столбцам;
• посегментно (попиксельно);
• смешанным образом.

Вариант по столбцам мы расмотрели в предыдущей главе. Вариант по строкам отличается от него илшь тем, что строки и столбцы нашей матрицы меняются местами. Посегментный способ заключается в том, что в любой момент времени только на одной строке и на однойм столбце присутствует уровень, необходимый для зажигания светодиода. То есть в любой момент времени может светиться лишь один светодиод всей матрицы (в отличие от предыдущих вариантов, когда одновременно может светиться целиком вся строка или весь столбец). Этот способ напоминает развертку телевизора, когда луч обегает весь экран, засвечивая в нужных местах люминофор. Смешанный вариант, как следует из самого названия, состоит в том, что одновременно «активные» уровни могут присутствовать сразу на нескольких строках и столбцах.

Первые два варианта очень легко реализуются, и потому нашли широкое распространение. Третий вариант используется реже, т. к. требует более высоких скоростей обновления информации на строках и столбцах, да и средний ток через сегмент (т. е. яркость сегмента) в этом случае существенно ниже, чем в прочих. Последний смешанный способ наименее распространен, хотя и имеет ряд положительных качеств. Прежде всего, для этого способа необходимо, чтобы в цепях строк и столбцов использовались источники стабильного тока, иначе яркость светящихся сегментов неизбежно будет зависеть от их общего числа. Да и вычисление комбинаций сигналов на строках и столбцах не очень просто дается.

2.2 Многомерные матрицы

Рассмотренные нами примеры предполагают реализацию монохромного дисплея, т. е. состоящего из одноцветных светодиодов. Как же быть, если требуется получить многоцветный дисплей, например, из RGB-светодиодов? Напрашивается два варианта решения.

Первый – это просто увеличить число строк (или столбцов) нашей матрицы, рассматривая каждый RGB-светодиод как 3 независимых отдельных светодода. Большой минус этого подхода – увеличение в 3 раза числа строк (или столбцов). На простом примере легко видно, во что это выливается практически: при помощи двух восьмиразрядных протров микроконтроллера мы можем иметь монохромную матрицу 8×8 сегментов или цветную 4×4. Согласитесь, что во втором случае ничего вразумительного отобразить практически нельзя…

Второй способ – это перейти от «плоской» матрицы сегментов к «многомерной». Если сигнал каждой строки пропустить через мультиплексор 1×3, то систему дисплея из RGB-светодиодов мы можем представить как 3 независимых матрицы исходной размерности: каждая матрица состоит из светодиодов одного цвета, а сигналами управления мультиплексорами мы выбираем нужную матрицу. Рисунок поясняет сказанное.

Очевидно, что в случае многомерной матрицы так же требуется дополнительное количество линий управления, однако, это число не так велико: на тех же двух портах контроллера мы можем получить цветной дисплей 7×7!!!

2.3 Способы уменьшения размерности матриц

Если число выводов микроконтроллера очень ограничено, нам придется искать способы уменьшить число строк и столбцов нашей матрицы. Разумеется, чудес не бывает, и в этом случае нам придется заплатить тем, что кроме микроконтроллера будут применяться дополнительные микросхемы. Как вы уже догадались, тут можно использовать ранее рассмотренный способ «многомерных» матриц – ведь никто не запретит нам вместо RGB-светодиодов просто использовать утроенное количество одноцветных? Главное, расположить их соответствующим образом…

Итак, уменьшить размерность матрицы мы можем, применив:

• дешифраторы или мультиплексоры;
• сдвиговые регистры.

С мультиплексорами мы уже познакомились ранее, дешифратор, как вы можете догадаться, от мультиплексора отличается непринципиально. Следует лишь дополнить, что используя дешифраторы/мультиплексоры и для строк и для столбцов, можно добиться согращения размерности матрицы сразу по обеим измерениям, однако в этом случае может потребоваться использовать только посегментную динамическую индикацию, со всеми ее недостатками.

Сдвиговые регистры могут помочь намного лучше дешифраторов. Рассмотрим схему на рисунке ниже.

Легко видеть, что любое количество строк и столбцов потребует только увеличения числа регистров, а число задействованных линий управления микроконтроллера останется прежним! Небольшим минусом данного подхода является то, что по мере роста числа регистров в цепочке придется увеличивать скорость последовательного вывода информации в них, что не всегда легко достижимо. Так, например, распространенные микроконтроллеры семейства AVR, практически не позволяют превзойти скорость последовательного вывода в 10 мегабит/сек. С другой стороны, если применять иные контроллеры, способные выдавать сигналы быстрее, могут начаться проблемы другого порядка: распространение высокочастотного тактового сигнала по длинной линии (а при большом числе регистров она неизбежно будет таковой) происходит совсем не так, как низкочастотного, поэтому потребуются особые меры при разводке печатной платы и другие вещи, которые в рамках данной статьи мы рассматривать не будем.

Использование регистров для увеличения размеров матрицы

3 Способы программной реализации

Рассматривать программную реализацию всех упомянутых вариантов динамической индикации мы не будем – это необоснованно раздует статью. Мы ограничимся лишь тремя наиболее «ходовыми» примерами: плоская матрица с непосредственным управлением строками и столбцами, то же самое с применением дешифратора, и, наконец, вариант с применением сдвиговых регистров. Во всех случаях особое внимание будет уделяться всяким нюансам программной реализации, то есть код на Си будет сопровождаться пояснениями только в тех случаях, когда это совпадает с намерением автора, а отнюдь не с вашим уровнем подготовки. Этим я намекаю, что основы Си вы должны знать и без меня.

Для всех примеров условимся, что наш дисплей построен на семисегментных индикаторах с общим катодом.

3.1 Простейший способ

Очевидно, что в программе было бы наиболее удобно иметь некий массив, содержимое котрого однозначно определяло бы то, какие сегменты в каких знакоместах дисплея светятся – эдакий аналог экранного ОЗУ.

Введем определение следующих констант:

#define SCR_SZ 6 /* число знакомест дисплея */
#define ROWS PORTB /* порт «строк» дисплея, т.е. управления сегментами */
#define COLS PORTD /* порт управления «столбцами», т.е. общими катодами */

Я настоятельно рекомендую именно объявить эти константы макросами, это признак хорошего стиля программирования (не вдаваясь в детали – просто поверьте, что это хорошо).

Теперь объявим массив-экран:

unsigned char SCR[SCR_SZ];

Для начала будем считать, что каждый элемент массива соответствует знакоместу дисплея, а каждый бит этого элемента соответствует определенному сегменту индикатора. Какой бит какому сегменту соответствует – в данном случае не важно, как не важно и то, как эти биты устанавливаются в байтах нашего массива, просто будем пока считать, что они там уже есть. Так же для простоты будем считать, то общие катоды подключены к выводам порта COLS последовательно: младший бит – самый правый индикатор, затем второй, затем третий и т. д.

Как же заставить этот массив «отобразиться» на дисплее? Напишем такой код:

unsigned char pos;
while(1)
   for(pos = 0; pos < SCR_SZ; pos++){
      ROWS = SCR[pos];

      COLS = ~(1 << pos);
   }

Будет ли он выполнять требуемую функцию? Да. Но плоховато.

Прежде всего, обратите внимание, что мы никак не управляем скоростью обновления содержимого строк и столбцов. Во-вторых, обратите внимание, что к моменту вывода нового элемента массива в ROWS на линиях COLS еще присутствует старое значение! К чему это приведет? Да к тому, что какую-то долю секунды на знакоместе будут отображаться сегменты соседнего знакоместа, т. е. некоторые сегменты будут ложно засвечены.

Избежать этого эффекта можно так: перед тем, как обновить содержимое ROWS, всегда погасить то знакоместо, которое было предыдущим. Чтобы не заморачиваться с определением предыдущего знакоместа, можно гасить сразу все. Итак, наш код принимает следующий вид:

unsigned char pos;
while(1)
   for(pos = 0; pos < SCR_SZ; pos++){
      COLS = 0xFF;

      ROWS = SCR[pos];

      COLS = ~(1 << pos);

      delay();
   }

Мы добавили гашение всего дисплея перед тем, как обновить состояние линий сегментов (подав высокий уровень на общие катоды, мы погасим индикатор не зависимо от того, что присутствует на анодах) и ввели задержку в конце цикла. Теперь индикация будет работать существенно лучше. Но хорошую ли программу мы написали? Увы, нет.

Дело в том, что бесконечный цикл индикации while просто не позволит нам сделать что-то еще. Что ж за программа такая у нас выйдет, которая только и умеет, что что-то выводить на индикатор?! Конечно, все плохо не на все 100%, так как что-то полезное можно делать по прерываниям… да и вместо задержки delay () можно выполнять какие-то действия… Но все это очень и очень криво: в обработчиках прерывания не желательно выполнять что-то сложное и громоздкое; с другой стороны, если что-то сложное и громоздкое делать вместо задержки, то сложно обеспечить одинаковость времени вычислений, в противном случае получится, что знакоместа светятся в течение разного промежутка времени, что визуально будет выглядеть как разнояркое их свечение или мерцание.

В общем, этот вариант можно допустить лишь в виде исключения только в качестве учебного примера или в том случае (но пять-таки, только в виде исключения!), когда основная решаемая задача очень проста (такой может быть, например, задача измерения при помощи АЦП напряжения и вывод его на дисплей).

Как же следует поступать? Ответ, как всегда, прост: все процессы, которые должны выполняться незаметно от решения основной задачи (а индикация, безусловно, является таким процессом), следует выполнять по прерываниям от таймера.
Прерывания будут поступать через строго определенные промежутки времени, что обеспечит равномерность свечения знакомест. Фоновая индикация позволит нам в главном цикле просто записать в нужный момент что-то в массив SCR[] – и оно мгновенно отобразится на дисплее! А все переделки кода сведутся к тому, что вместо циклов мы используем функцию-обработчик прерывания:

ISR(TIMER0_OVF_vect){
   static unsigned char pos = 0;
   COLS = 0xFF;
   ROWS = SCR[pos];
   COLS = ~(1 << pos);
   if(++pos == SCR_SZ) pos = 0;
}

Несколько комментариев.

Переменную pos, обозначающую номер текущего светящегося знакоместа, мы делаем локальной статической переменной, чтобы она сохраняла свое значение от прерывания к прерыванию. В конце функции мы самостоятельно (ведь цикла у нас больше нет) увеличиваем номер знакоместа до тех пор, пока не достигнем предела – в этом случае переходим снова к началу.

В основной программе нам надо будет лишь проинициализировать порты и таймер (в данном случае – Timer 0), чтобы он переполнялся через нужные нам промежутки времени, да разрешить прерывания. После этого об индикации можно не вспоминать – она будет тихо-мирно работать сама по себе. Но как определить нужный интервал переполнения таймера? Очень просто. Человеческий глаз воспринимает мерцание с частотой более 25 Гц, как непрерывное свечение. Индикаторов у нас 6, каждый из них должен мерцать с такой частотой, значит, обновление информации на дисплее должно происходить с частотой 25×6 = 150 Гц или более. Теперь рассчитаем значение предделителя таймера: поделим тактовую частоту МК на 256 (Timer 0 у всех AVR восьмибитный, а значит, переполняется, досчитав до 256) – это и будет желаемое значение предделителя таймера. Разумеется, маловероятно, что результат получится совпадающим с одним из стандартных значений предделителя – это не проблема, можно взять ближайшиее меньшее подходящее значение. Индикация будет работать на более высокой частоте, но ведь это не ухудшит ее качество! Побочным эффектом будет большая загрузка ядра МК на индикацию. Если это будет сильно мешать основной программе – придется перевести индикацию на другой таймер, например, 16-битный Timer 1, или ввести счетчик пропускаемых переполнений таймера:

#define SKIP 15 /* число пропускаемых прерываний таймера */
ISR(TIMER0_OVF_vect){
   static unsigned char pos = 0;
   static unsigned char skip = SKIP;
   if (--skip) return;
   skip = SKIP;
   COLS = 0xFF;
   ROWS = SCR[pos];
   COLS = ~(1 << pos);
   if(++pos == SCR_SZ) pos = 0;
}

В этих упрощенных примерах мы считаем, что к порту COLS, кроме общих катодов индикаторов, ничего больше не подключено. Однако, в реальной жизни такое счастье выпадает нечасто, и к оставшимся линиям этого порта скорее всего подключено что-то иное. Поэтому при организации динамической индикации следует всегда обеспечивать неизменность состояния всех линий портов, не занятых непосредственно в индикации. Делается это просто: вместо обычной записи в порт новго значения следует использовать маскирование ненужных битов:

COLS |= 0x3F; // так гасим все знакоместа
COLS &= ~(1<<pos); // так включаем нужное знакоместо

Оба оператора не изменяют значение старших битов порта COLS.

3.2 Способ с дешифратором

Дешифратор может использоваться либо для преобразования HEX или BCD кода в семисегментные символы, либо для выбора одного из столбцов матрицы. Оба варианта будут отличаться от рассмотренного ранее простейшего способа лишь тем, как будет организован вывод в порты ROWS и/или COLS, к которым будут подключены входы дешифратора.
Вариант использования дешифратора для получения семисегментного символа:

ISR(TIMER0_OVF_vect){
   static unsigned char pos = 0;
   COLS |= 0x3F;
   ROWS = (ROWS & 0xF0) | (SCR[pos] & 0x0F);
   COLS &= ~(1 << pos);
   if(++pos == SCR_SZ) pos = 0;
}

Как видите, изменения минимальны – перед тем, как вывести в ROWS код символа из массива SCR[], маскируются старшие биты, после чего младшие устанавливаются в соответствии с кодом символа. То есть мы считаем, что дешифратор подключен к 4-ем младшим битам порта ROWS.

Приводить пример для дешифрации столбцов, надеюсь, смысла нет – все и так понятно.

3.3 Способ с регистрами

Хотя динамическая индикация при помощи сдвиговых регистров принципиально не отличается от ранее рассмотренных способов, есть несколько вариантов ее реализации. Мы рассмотрим наиболее простой – вывод битов чисто программными средствами. А в реализации других (с использованием USI/USART/SPI/TWI) вы можете попробовать свои силы самостоятельно.

Для варианта ранее выбранного дисплея из 6-и семисегментных знакомест мы используем 2 сдвиговых регистра типа 74HC595. Управляется этот регистр тремя сигналами: тактовые импульсы последовательного ввода данных CLK, собственно данные DATA и импульс одновременного параллельного вывода записанной в регистр информации SET. Объявим соответствующие макросы (для простоты, все сигналы «заведем» на один порт):

#define CLK _BV(PB0)
#define DATA _BV(PB1)
#define SET _BV(PB2)
#define REG_PORT PORTB

Для записи в регистр удобно написать отдельную функцию:

static void shift(unsigned char d){
   unsigned char i;
   for (i=0; i < 8; i++){
      // устанавливаем нужный уровеньDATA
      if(d & 1)
         REG_PORT |= DATA;
      else
         REG_PORT &= ~DATA;
      REG_PORT |= CLK; // даем импульсCLK
      REG_PORT &= ~CLK;
      d >>= 1;
   }
}

Крайне желательно эту функцию делать статической, т. к. она будет использоваться в обработчике прерываний. Статические функции компилятор скорее всего сделает в виде inline-вставок в обработчик прерывания, т. е. никакого лишнего использования стека не будет, чего не гарантируется для нестатических функций.

Теперь наш обработчик прерывания станет выглядеть так:

ISR(TIMER0_OVF_vect){
   static unsigned char pos = 0;
   shift(SCR[pos]);
   shift(~(1<< pos));
   REG_PORT |= SET; // выдаем импульсSET
   REG_PORT &= ~SET;
   if(++pos == SCR_SZ) pos = 0;
}

Так как записанные в регистры данные появляются на его выходах одновременно, нет нужды предварительно гасить индикаторы. Следует помнить, что программный последовательный вывод – достаточно долгий процесс, особенно для матриц больших размерностей, поэтому следует максимально оптимизировать его по быстродействию. Лучше всего это можно сделать, используя аппаратные средства последовательного вывода, имеющиеся в МК.

4 Для тех, кому всегда всего мало

Итак, вы познакомились с основами реализации динамической индикации. Но, как обычно, вопросов не убавляется, а прибавляется. Предвидя некоторые из них, попробую сразу же дать нужные ответы.

4.1 Аноды, катоды – что выбрать?

Все, что мы рассматривали ранее, относилось к индикаторам с общими катодами. А если требуется использовать с общими анодами? В общем, все остается по-прежнему, кроме того, что перед выводом нужно будет проинвертировать данные – гашение знакоместа осуществлять выводом нулей в COLS, зажигание – соответственно, единиц, а сегменты в ROWS будут включаться нулями вместо единиц. Так что обработчик прерывания станет примерно таким:

ISR(TIMER0_OVF_vect){
   static unsigned char pos = 0;
   COLS &= 0xC0;
   ROWS = ~SCR[pos];
   COLS |= (1 << pos);
   if(++pos == SCR_SZ) pos = 0;
}

Все просто. Если, конечно, не стараться написать универсальный код, пригодный и для общих анодов, и для общих катодов. Сделать это можно двумя способами: либо при помощи директив условной компиляции, либо при помощи функции преобразования. Первый вариант я продемонстрирую, а над вторым предлагаю подумать самостоятельно.

#define COMMON_ANODE 1



ISR(TIMER0_OVF_vect){
   static unsigned char pos = 0;
#if COMMON_ANODE != 1
   COLS &= 0xC0;
   ROWS = ~SCR[pos];
   COLS |= (1 << pos);
#else
   COLS |= 0x3F;
   ROWS = SCR[pos];
   COLS &= ~(1 << pos);
#endif
   if(++pos == SCR_SZ) pos = 0;
}

Это хоть и немного громоздко, зато, написав это один раз, вы сможете использовать во всех проектах практически без изменений.

4.2 Мерцание

Во многих случаях дисплей используется не только как средство отображения информации, поступающей изнутри устройства, но и для отображения вводимой пользователем информации. А в этом случае необходимо иметь возможность как-то отделить неизменное от изменяемого на дисплее. Проще всего это сделать, заставив мерцать соответствующее знакоместо (или несколько знакомест).

Сделать это очень просто. Введем глобальную переменную, каждый единичный бит которой будет обозначать мигающее знакоместо:

unsigned char blink = 0;

Теперь немного модифицируем обработчик прерывания:

ISR(TIMER0_OVF_vect){
   static unsigned char pos = 0;
   static unsigned char entry = 0;
   COLS |= 0x3F;
  if(!(blink & (1<<pos)) || (++entry & 0x80)){
     ROWS = (ROWS & 0xF0) | (SCR[pos] & 0x0F);
     COLS &= ~(1 << pos);
   }
   if(++pos == SCR_SZ) pos = 0;
}

Как видите, добавлена всего одна статическая переменная – счетчик входов в обработчик прерывания entry, и оператор проверки условия. Логика проста: вывод очередного знакоместа осуществляется лишь в том случае, если либо в соответствующем бите blink ноль, либо старший бит счетчика entry равен 1. Если, предположим, blink содержит все нули, то данное условие выполняется всегда – выводятся все знакоместа. Если же blink содержит 1 в одном из своих битов, то соответствующее знакоместо будет высвечиваться лишь в то время, когда старший бит счетчика равен 1. Так как счетчик увеличивается каждый раз при входе в обработчик прерываний, то соответствующее знакоместо будет мерцать с частотой в 128 раз меньшей, чем частота прерываний.

4.3 Регулировка яркости сегментов

О регулировке яркости я писал в отдельной статье, которая так и называлась Динамическая индикация и регулировка яркости.

4.4 Произвольное распределение выводов

Ранее говорилось, что счастье выделить порт МК целиком под индикацию, выпадает довольно редко. Но еще реже выпадает счастье получить удобную трассировку печатной платы, если использован один порт целиком под строки, а другой порт – под столбцы матрицы дисплея. Гораздо чаще оптимальная трассировка получается лишь в том случае, когда строки и столбцы перемешаны между двумя, а то и более портами микроконтроллера. Жертвовать красотой печатной платы не придется, если организовать программную перестановку битов при индикации.

Рассмотрим некий абстрактный пример. Пусть наилучшая трассировка обеспечивается при следующем распределении сигналов по линиям портов МК:

Как видите, линии матрицы перемешаны среди трех портов, причем все неиспользуемые линии этих портов не должны, естественно, менять своих уровней в процессе индикации.

Разработку функции динамической индикации для этого случая лучше всего начать с распределения сегментов по битам символа. Раньше мы считали, что в массиве SCR[] у нас хранятся битовые маски символов, т. е. единичками в байте обозначены светящиеся сегменты. О том, какой бит какому сегменту соответствует, мы не задумывались. Так вот, сейчас пора задуматься об этом.

Удобно разрисовать назначение линий портовв виде трех табличек:

PORTB

PORTC

PORTD

Мы должны собрать все сегменты в один байт. Делать это придется операциями сдвига, поэтому следует постараться распределить их так, чтобы делать минимум сдвигов. Будем рассуждать.

Если биты сегментов FEGDC оставить в символе так, чтобы они попадали в PORTD без сдвигов, тогда сегмент H так же может остаться в 6-ом бите символа, и его тоже не придется сдвигать перед выводом PORTC, зато для сегментов А и В останутся биты 7 и 3, то есть скорее всего сегмент В придется сдвигать на 3 позиции перед выводом, а сегмент А – на 6. Я остановлюсь на этом варианте, а вы можете продолжить поиск минимума сдвигов (сдвиги на несколько позиций – не такая уж быстрая операция, поэтому желательно свести их число к минимуму).

Итак, в нашем случае получилось такое распределение битов по байту-символу:

Отметим маски битов для вывода в соответствующие порты:

При помощи этих масок операцией «побитовое И» мы выделим нужные биты для вывода в порт.

Объявим константы масок:

#define MASKD 0x37
#define MASKB 0x80
#define MASKC 0x48

Ранее мы выводили символ в единственный порт ROWS, теперь же эта процедура разделится на три части:

PORTD = (PORTD & ~MASKD) | (SCR[pos] & MASKD);
PORTB = (PORTB & ~MASKB) | ((SCR[pos] & MASKB) >> 6);
PORTC = (PORTC & ~MASKC) |
              ((SCR[pos] & _BV(6)) |
              (((SCR[pos] & _BV(3)) >> 3);

Обратите внимание, что для вывода в PORTC один бит надо выводить без сдвига, а второй – со сдвигом, поэтому вместо MASKC пришлось использовать отдельные макросы _BV ().

Теперь осталось решить, как гасить и зажигать соответствующие знакоместа. Объявим константы, соответствующие битам управления знакоместами:

#define COM0 _BV(0)
#define COM1 _BV(3)
#define COM2 _BV(4)
#define COM3 _BV(5)
#define COM4 _BV(7)
#define COM5 _BV(3)
#define COM_D (COM5)
#define COM_C (COM2 | COM3 | COM4)
#define COM_B (COM0 | COM1)

Для гашения всех знакомест надо вывести в порты соответствующие константы COM_x:

PORTD |= COM_D;
PORTC |= COM_C;
PORTB |= COM_B;

А вот для включения знакоместа придется мудрить (нет смысла осуществлять вывод во все три порта, ведь активным будет только один-единственный бит в определенном порту в зависимости от значения pos), например, при помощи оператора switch:

switch(pos){
case 0: PORTB &= ~COM0; break;
case 1: PORTB &= ~COM1; break;
case 2: PORTC &= ~COM2; break;
case 3: PORTC &= ~COM3; break;
case 4: PORTC &= ~COM4; break;
case 5: PORTD &= ~COM5; break;
}

Это не самый красивый способ, но он работает.

Таким образом, наш обработчик прерывания приобретает следующий вид:

ISR(TIMER0_OVF_vect){
   static unsigned char pos = 0;
   static unsigned char entry = 0;
   // гасим
   PORTD |= COM_D;
   PORTC |= COM_C;
   PORTB |= COM_B;
   // выводим
   PORTD = (PORTD & ~MASKD) |
                 (SCR[pos] & MASKD);
   PORTB = (PORTB & ~MASKB) |
                ((SCR[pos] & MASKB) >> 6);
   PORTC = (PORTC & ~MASKC) |
                ((SCR[pos] & _BV(6)) |
                (((SCR[pos] & _BV(3)) >> 3);
   // мигаем
   if(!(blink & (1<< pos)) || (++entry & 0x80)) {

      switch(pos){
      case 0: PORTB &= ~COM0; break;
      case 1: PORTB &= ~COM1; break;
      case 2: PORTC &= ~COM2; break;
      case 3: PORTC &= ~COM3; break;
      case 4: PORTC &= ~COM4; break;
      case 5: PORTD &= ~COM5; break;
      }
   }
   if(++pos == SCR_SZ) pos = 0;
}

Теперь осталось разобраться, как же поудобнее описать символы для вывода… Я предлагаю поступить следующим образом: определить константы, соответствующие битам сегментов, а затем из этих констант «сконструировать» нужные символы:

// элементарные сегменты
#define _A _BV(7)
#define _B _BV(3)
#define _C _BV(0)
#define _D _BV(1)
#define _E _BV(4)
#define _F _BV(5)
#define _G _BV(2)
#define _H _BV(6)

// символыцифр
#define d_0 (_A | _B | _C | _D | _E | _F)
#define d_1 (_B | _C)
#define d_2 (_A | _B | _G | _D | _E)
// и так далее

Таким образом, если вам понадобится вывести в крайнюю правую позицию дисплея нолик, вы всего-навсего должны написать в нужном месте:

SCR[0] = d_0;

Если в другом проекте вам понадобится иначе распределить биты, вы поменяете только цифры в макросах _BV () для элементарных сегментов, и все символы «переделаются» автоматически. Для описанных в начале простейших случаев не придется больше ничего делать вообще, а для варианта с «перестановкой битов», придется, конечно повозиться.

4.5 Поддержка кнопок

При традиционном дефиците выводов МК, проблема большого количества кнопок, без которых редко какое устройство обходится, стоит весьма остро. В ход идут разные матричные включения и т. п. ухищрения, однако, немного усложнив функцию динамической индикации, легко получить в распоряжение столько кнопок, сколько знакомест в дисплее, при этом дополнительно потребуется задействовать только один порт микроконтроллера. Правда, на каждую кнопку еще придется ставить по диоду.

Схемотехнически это показано на рисунке.

Реализация кнопок совместно с динамической индикацией

А программно выглядит следующим образом:

#define keypin() (!(PIND & _BV(KEY)))





ISR(TIMER0_OVF_vect){
   static unsigned char pos = 0;
   static unsigned char entry = 0;
   static unsigned char tmp_key = 0;
   ROWS = 0;
   if(keypin()) tmp_key |= 1<< pos;
   COLS |= 0x3F;
   if(!(blink & (1<< pos)) || (++entry &0x80)){
      ROWS = (ROWS & 0xF0) | (SCR[pos] & 0x0F);
      COLS &= ~(1 << pos);
   }
   if(++pos == SCR_SZ){
      pos = 0;
      key = tmp_key;
      tmp_key = 0;
   }
}

Здесь KEY – это макрос, задающий бит выбранного порта, на котором «соединяются» все кнопки, макрос keypin () возвращает логическое значение ИСТИНА, если на выбранном пине присутствует низкий логический уровень. В примере кнопки подключены к PORTD.

Каждый раз, когда возникает прерывание таймера, сначала гасятся все сегменты – это необходимо для того, чтобы ток через светодиоды не приводил к ошибочному не обнаружению нажатой кнопки. После этого происходит опрос кнопочного входа – если там низкий уровень, значит, нажата кнопка, подключенная к соответствующему pos катоду. В переменной tmp_key накапливаются состояния кнопок, которые переписываются в глобальную переменную key после завершения цикла индикации. Вам остается лишь время от времени анализировать значение key и обрабатывать обнаруженные нажатия:

static unsigned char get_key(){
   unsigned char tmp = 0;
   tmp = key;
   _delay_ms(10);
   if(key == tmp)
      return tmp;
   else
      return 0;
}

Эта несложная функция гарантирует отсутствие дребезга кнопок, не смотря на то, что из-за «динамического» характера опроса кнопок вероятность дребезга и без того низкая.

5 Что еще?

Итак, вы освоили достаточно характерные приемы реализации динамической индикации. Думаю, этого хватит вам на первое время, а может, и вообще на всю оставшуюся жизнь. В конце концов, главное – это понимание приемов и алгоритмов, а тонкости и нюансы всегда можно прибавить самостоятельно. Но что же еще может ждать «вблизи» динамической индикации?

Как я уже говорил ранее, можно добавить регулировку яркости индикаторов, причем вплоть до независимого регулирования каждого сегмента.

Можно подумать над оптимальностью обработчика прерывания – в учебных целях я писал достаточно грубый код, например, всюду использовал SCR[pos], хотя оптимальнее было бы один раз считать значение в локальную переменнную, а потом оперировать уже с ее значением. Хотя оптимизатор наверняка выручит и с моим подходом, в целях практики стоит попробовать и самостоятельно пооптимизировать, контролируя себя по размеру получающегося кода и/или быстродействию программы.

Можно помозговать над интересной идеей автоматического регулирования яркости дисплея в зависимости от уровня внешней освещенности. Как известно, светодиодные индикаторы тем хуже различимы, чем темнее вокруг – они просто расплываются. Поэтому в темное время суток разумно снижать яркость индикаторов, повышаяя ее в светолое время. Самое простое – использовать отдельный фоторезистор или светодиод в качестве датчика освещенности, но можно поступить и иначе: известно, что светодиод может работать и в качестве фотодиода, поэтому, если для индикации задействовать порт, соединеннный с входом АЦП, то при определенном желании можно измерить фото-эдс несветящегося сегмента индикатора, и использовать это значение для регулировки яркости…

Можно покумекать над использованием аппаратных средств последовательного вывода, о чем я уже намекал.

Интересный вариант полностью универсального подхода к динамической индикации, с которым так же рекомендую познакомиться, предложил MOLCHEC. Кратко суть: распределение сегментов по битам символа, назначение портов для управления индикатором и даже тип индикатора – короче говоря, все-все-все параметры,– задаются в виде таблицы конфигурации в EEPROM. Программно на основе этой таблицы организуется все: от инверсии в зависимости типа индикатора, до перестановки битов по разным портам. При этом исходный код программы динамической индикации остается неизменным всегда, а таблица конфигурации составляется конечным пользователем в зависимости от своих предпочтений. Метод действиетльно универсальный и гибкий, однако сопряжен с повышенным расходом памяти программ.

Ну и конечно массу простора для фантазии открывают многомерные матрицы, о которых мы упоминали.

Надеюсь, эта статья вам помогла узнать и освоить много нового, полезного, а может быть и просто интересного.

Обсудить материал на форуме. (13 сообщений)

Коментарии (3)

1  Написал (а) Igor, в 16:49 05.08.2009 Почитал и позавидовал тем кто умеет программировать на Си… Кажись я так и буду вечно просить кого нибудь написать мне нужную программу. Сколько не пробовал никак не могу научится писать программы Уведомить админа

Только зарегистрированные пользователи могут оставлять коментарии.
Пожалуйста зарегистрируйтесь или войдите в ваш аккаунт.