Семисегментный индикатор. Краткие теоретические сведения

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

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

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

Если требуется управлять дисплеем, состоящим из единственного семисегментного знакоместа, это не вызывает никаких проблем - его можно представить, как 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;

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

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

< SCR_SZ; pos++){ ROWS = SCR; COLS = ~(1 << pos); }

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

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

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

Unsigned char pos; while(1) for(pos = 0; pos < SCR_SZ; pos++){ COLS = 0xFF; ROWS = SCR; COLS = ~(1 << pos); delay(); }

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

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

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

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

ISR(TIMER0_OVF_vect){ static unsigned char pos = 0; COLS = 0xFF; ROWS = SCR; 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; COLS = ~(1 << pos); if(++pos == SCR_SZ) pos = 0; }

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

COLS |= 0x3F; // так гасим все знакоместа COLS &= ~(1<

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

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

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

ISR(TIMER0_OVF_vect){ static unsigned char pos = 0; COLS |= 0x3F; ROWS = (ROWS & 0xF0) | (SCR & 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); 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; 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; COLS |= (1 << pos); #else COLS |= 0x3F; ROWS = SCR; COLS &= ~(1 << pos); #endif if(++pos == SCR_SZ) pos = 0; }

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

4.2 Мерцание

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

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

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

ISR(TIMER0_OVF_vect){ static unsigned char pos = 0; static unsigned char entry = 0; COLS |= 0x3F; if(!(blink & (1<

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

PORTD = (PORTD & ~MASKD) | (SCR & MASKD); PORTB = (PORTB & ~MASKB) | ((SCR & MASKB) >> 6); PORTC = (PORTC & ~MASKC) | ((SCR & _BV(6)) | (((SCR & _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 & MASKD); PORTB = (PORTB & ~MASKB) | ((SCR & MASKB) >> 6); PORTC = (PORTC & ~MASKC) | ((SCR & _BV(6)) | (((SCR & _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 = 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 & 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 , хотя оптимальнее было бы один раз считать значение в локальную переменнную, а потом оперировать уже с ее значением. Хотя оптимизатор наверняка выручит и с моим подходом, в целях практики стоит попробовать и самостоятельно пооптимизировать, контролируя себя по размеру получающегося кода и/или быстродействию программы.

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

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

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

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

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

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

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

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

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

Скорость обновления информации в рассмотренной схеме будет в четыре раза меньше частоты генератора. То есть для того, чтобы получить частоту мерцания индикаторов 100 Гц, требуется частота генератора 400 Гц.

Во сколько же раз мы в результате уменьшили количество соединительных проводников? Это зависит от того, где мы проведем сечение схемы. Если мы на плате индикации оставим только индикаторы, то для их работы потребуется 7 информационных сигналов для сегментов и четыре коммутирующих сигнала. Всего 11 проводников. В статической схеме индикации нам потребовалось бы 7×4=28 проводников. Как видим, выигрыш налицо. При реализации 8-ми разрядного блока индикации выигрыш будет еще больше.

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

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

Как уже упоминалось ранее, для нормальной работы светодиода требуется ток от 3 до 10 мА. Зададимся минимальным током светодиода 3 мА. Однако при импульсном режиме работы яркость свечения индикатора падает в N раз, где коэффициент N равен скважности импульсов тока, подаваемых на этот индикатор.

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

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

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

Как вам такой ток?! В радиолюбительских схемах я часто встречаю решения, где коммутирующий ток берется непосредственно с выхода дешифратора, который не может выдать ток больше 20 мА, и задаю себе вопрос — а где смотреть такой индикатор? В полной темноте? Получается «прибор ночного видения», то есть прибор, показания которого видны только в полной темноте.

А теперь давайте рассмотрим принципиальную схему полученного блока индикации. Она приведена на рисунке 3.

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

В качестве недостатка следует привести наличие больших импульсных токов, а так как любой проводник является антенной, то динамическая индикация служит мощным источником помех. Еще одним путем распространения помех является источник питания.

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

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

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

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

Литература:

Вместе со статьей "Динамическая индикация" читают:

Индикаторы предназначены для отображения различных видов информации для человека. Простейший вид информации - это...
http://сайт/digital/Indic.php

Газоразрядные индикаторы используются как для индикации битовой информации, так и для отображения десятичной информации. При построении десятичных индикаторов катод...
http://сайт/digital/GazIndic/

В настоящее время практически везде для отображения двоичной информации используются светодиоды. Это обусловлено тем...
http://сайт/digital/LED.php

Принципы работы жидкокристаллических индикаторов... Режимы работы жидкокристаллических индикаторов... Формирование цветного изображения...
http://сайт/digital/LCD.php

В одном из предыдущих уроков мы научились зажигать сегменты светодиодного индикатора. Хотя это можно сделать только с помощью Ардуино, мы использовали в нашем уроке дополнительный компонент — . Эта полезная микросхема сэкономила нам несколько ценных выводов микроконтроллера. Но один семисегментный индикатор почти бесполезен. Он ведь отображает всего одну цифру. А что если мы хотим вывести большое число, скажем, от 0 до 500? Нам потребуется целых три цифры, а значит и три индикатора. Как будем подключать их к контроллеру? Можем напрямую, но тогда мы займем 7*3 = 21 вывод! Это очень расточительно. К тому же, нужна будет уже другая плата, так как у Ардуино Уно просто не хватит цифровых выводов. Попробуем использовать сдвиговый регистр? Уже лучше. Теперь нам понадобится три регистра, объединенных в цепочку, а также три вывода Ардуино для управления ими. В общем то на этом можно бы было и остановить оптимизацию нашей схемы, но мы пойдем дальше. Обойдемся всего одним сдвиговым регистром!

Динамическая индикация

Подключение к Ардуино

next_flick){ next_flick = tm + to_flick; digit++; if(digit == 3) digit = 0; setDigit(digit, counter); } } Часть этой программы, включая переменные data_pin , sh_pin , st_pin и функцию fill уже известны нам из . Массив digits хранит десять комбинаций сегментов для цифр от 0 до 9. Для экономии памяти мы храним каждую комбинацию в одном байте, а для лучшего понимания мы записали их в бинарном виде. Чтобы переключать индикаторы воспользуемся . Будем каждую миллисекунду заполнять регистр нужной комбинацией и включать соответствующий индикатор. Для этого мы используем функцию setDigit . Аргумент digit — это индекс включаемого в данный момент индикатора, а counter — трехзначное число, которые мы хотим высветить. Параметр to_flick отвечает за период переключения индикатора. Он равен 1, а значит смена цифр для отображения происходит каждую миллисекунду. Что если увеличить этот параметр? Скажем до 100мс, или даже до 500мс. Эффект инерции зрения пропадет и мы начнем замечать смену цифр. Программа счетчика с динамической индикацией В предыдущем примере переменная counter хранила число 125 по-умолчанию. Попробуем теперь добавить в программу счетчик секунд, чтобы counter увеличивался на единицу каждую секунду, вплоть до числа 999. const byte digit_pins = {5,6,7}; const byte data_pin = 2; const byte sh_pin = 4; const byte st_pin = 3; unsigned long tm, next_sec, next_flick; const unsigned int to_sec = 1000; const unsigned int to_flick = 1; unsigned int counter = 0; byte digit = 0; const byte digits = { B11101110, B10000010, B11011100, B11010110, B10110010, B01110110, B01111110, B11000010, B11111110, B11110110 }; void fill(byte d){ for(char i=0; i<8; i++){ digitalWrite(sh_pin, LOW); digitalWrite(data_pin, digits[d] & (1< next_sec){ next_sec = tm + to_sec; counter++; if(counter == 1000) counter = 0; } tm = millis(); if(tm > next_flick){ next_flick = tm + to_flick; digit++; if(digit == 3) digit = 0; setDigit(digit, counter); } } Загружаем программу на Ардуино и наблюдаем работу счетчика!

Задания

1. Цифровой секундомер. Собрать схему с трехцифровым индикатором. Добавить в схему . При нажатии на кнопку, секундомер должен запускать отсчет. При повторном нажатии — останавливать. Дополнительно, к секундомеру можно добавить дробную часть, отображаемую на третьем индикаторе через точку.
2. Цифровой вольтметр для напряжений от 0 до 10 Вольт. Собрать схему с трехцифровым индикатором. Добавить в схему делитель напряжения из двух резисторов на 10 кОм, подключенный к аналоговому входу Ардуино. Написать программу, которая будет каждые 100 мс считывать значение на аналоговом входе, переводить его в Вольты и выводить на индикатор. Для правильного отображения дробной части, необходимо подключить восьмой сегмент — точку.

Заключение

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

Обновлено 3.04.15. Всем привет. В прошлой статье мы с Вами рассмотрели алгоритм общения с ЖКИ, а также вывод информациина нее, и протестировали в симуляторе. В этой записи я кратенько расскажу о “недорогом” способе вывода информации — это семисегментный индикатор , который является наиболее простым из индикаторов, для отображения арабских цифр, а также некоторых символов, которые возможно на нем вывести. Также рассмотрим программу на Си для AVR, и подключение в железе и симуляторе.

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

Если индикаторов несколько, следовательно и управляются катоды несколькими ножками МК. !!! Но всегда используйте транзисторы, т.к. порты ввода-вывода могут сгореть из-за относительно большого тока. Я использовал обычные 315 транзисторы. На рисунке ниже я отобразил примерное подключение, через них, управляющего вывода индикатора и контроллера. Для монтажа нам потребуется 11 ножек микроконтроллера, т.е. для отображения информации на сегментах 8 ножек (7 +точка) и по одной ножки на каждый индикатор для его управления, у меня их три, поэтому и ножки управления тоже три. Ниже я привел и описал программу. Для управления сегментами будем использовать пины одного порта, что б не путаться. Писал под микроконтроллер ATmega8 . Если Вы хотите отвязаться от “камня” то это не проблема, например в , где без проблем можно изменить настройки под другой “камень”, в основном это номера пинов и портов. Там же описаны общие правила универсальности и переноса.

Рисунок подключения транзистора к МК и индикатору.

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

PB0 — 12 — управление первым элементом

PB6 — 9 — управление вторым элементом
PB7 — 8 — управление третьим элементом
PD7 – 11 — (A) — 128
PD6 – 10 — (F) — 64
PD5 – 7 — (B) — 32
PD4 – 5 — (G) — 16
PD3 – 4 — — 8
PD2 – 3 — (DP) — 4
PD1 – 2 — (D) — 2
PD0 – 1 — (E) — 1

#include

#include

#include

/*Определим каждому пину порта элемент семи сегментника (риунок выше)*/

#define a 128

#define b 32

#define c 8

#define d 2

#define e 1

#define f 64

#define g 16

#define dp 4

/*Эти макросы содержат числа, соответствующие двойке, возведенной в степень, равной номеру "ножки" того порта, к которому подключен сегмент индикатора с одноименным макросу названием. */

short unsigned int j, k = 0; /*переменные исп-ся в макросе прерывания*/

float i = 0; /*Переменная для вывода на индикатор*/

short unsigned int w = 0; /*Переменная индикатор для включения точки*/

unsigned char Slot; /*Массив в котором хранятся числа, которые нужно

вывести через порт на индикатор, чтобы он показал цифру, равную номеру

элемента массива. Числа зависят только от макросов.*/

void Slot_init () /*Функция инициализации индикатора*/

{

Slot = (a+b+c+d+e+f);

Slot = (b+c);

Slot = (a+b+g+e+d);

Slot = (a+b+g+c+d); .

Slot = (f+g+b+c); /*Имена макросов соответствуют именам сегментов индик*/

Slot = (a+f+g+c+d);

Slot = (a+f+g+c+d+e);

Slot = (a+b+c);

Slot = (a+b+c+d+e+f+g);

Slot = (a+b+c+d+f+g);

Slot = dp; /*Точка*/

}

/*В этих переменных хранятся цифры, которые нужно отобразить*/

char Elem1, Elem2, Elem3;

/* Функция выделяет цифры из трехзначного числа Number*/

void Display (float Number)

{

float N1, N2; /*Переменные для функции modf*/

N1 = modf (Number, &N2); /*Разбиваем число на целую и дробную части, N1 = дробной N2 = целой*/

if (N1 != 0) /*Еслине равно нулю то присутствует дробь*/

{

Number= Number*10; /*тогда умножаем число на 10, для обычного вывода на индикатор трехзначного дробного числа*/

w = 1; /* переменная индикатор которая используется в цикле ниже, чтобы включать точку*/

}

short unsigned int Num1, Num2, Num3;

Num1=Num2=0;

while (Number >= 100) /*Сотни*/

{

Number -= 100;

Num1++;

}

while (Number >= 10) /*Десятки*/

{

Number -= 10;

Num2++;

}

Num3 = Number; /*Еденицы*/

Elem1 = Slot;

if (w == 1) /*Условие дя включения точки на втором элементе*/

{

Elem2 = (Slot|0×04); /*логическое сложение с пином отвечающим за точку*/

w = 0; /*Выключаем точку*/

}

else

Elem2 = Slot;

Elem3 = Slot;

}

int main (void) /*начало основой программы*/

{

DDRB = 0Xff; /*все выводы порта B сконфигурировать как выходы*/

DDRD = 0xff; /*все выводы порта D сконфигурировать как выходы*/

PORTD = 0×00; /*Устанавливаем 0*/

PORTB |= _BV (PB6);

PORTB |= _BV (PB0);

PORTB |= _BV (PB7);

Slot_init ();

sei (); /*Разрешить общее прерыввание*/

/*Инициализация таймера Т0*/

TIMSK = (1</*Флаг разрешенияя по переполнению таймера счетчика Т0*/

TCCR0 = (0</* 1000000/8 = 125000= 125000/256 = 488,28 гц */

while (1) /*Бесконечный цикл, выводим переменную на индикатор*/

{

_delay_ms (1000);

i= i+0.1;

if (i == 99.9)

i = 0.0;

Display (i);

} /*Закрывающая скобка бесконечного цикла*/

} /*Закрывающая скобка основной программы*/

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

ISR (TIMER0_OVF_vect)
{
PORTB &= 0x3e; //Очистка PB7, PB6, PB0
_for (j = 0; j<=30; j++) { } // Задержка для выключения транзистора
(k == 3) ? k = 0: k++; /*Переменная, которая отвечает за очередность загорания трехэлементного индикатора, 0,1 и 2. При определенной цифре, на определенной ножке усатнавливается 1, далее открывается транзистор и загорается сегменты индикатора, соответсвующие переменной Elemn */
switch (k)
{
case 0: PORTB |= (1 << PINB7); // Единицы
PORTD = Elem3;
break;
case 1: PORTB |= (1 << PINB6); // Десятки
PORTD = Elem2;
break;
case 2: PORTB |= (1 << PINB0); // Сотни
PORTD = Elem1;
}
}

Выше приведенная программа испытана в железе и в симуляторе. Ниже выложены рисунки соответственно. В железе я все спаял навесом, на быструю руку. Как видите три элемента индикатора соответственно три транзистора (обведено кружочком) . В симуляторе(Proteus) транзисторы нам не нужны. Так же одно существенное отличие в программе, а именно в прерывании, где происходит з адержка для выключения транзистора - в симуляторе пропишите 50 тактов. Все должно работать.

По ходу публикации постов, программа для индикатора у нас немного изменилась, а именно добавился четвертый элемент, вывод на него знака минус, символов “H” и “C", формат вывода времени и объединение всех режимов . Так что читайте, анализируйте и экспериментируйте.

Ниже исходники и проект по выше приведенному материалу.

(Скачали: 795 чел.)

На этом все. В следущей статье я опишу подключение датчиков температуры и выведем инфорацию на индикатор. До скорой встречи!

Программирование работы многоразрядного семисегментного индикатора

Алгоритм работы программы

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

Подключение многоразрядного семисегментного индикатора

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

На этой схеме выводы порта РВ (РВ0 — РВ7) микроконтроллера через токоограничительные резисторы подключены к соответствующим сегментам (a-g) многоразрядного семисегментного индикатора. Соответствующие сегменты всех разрядов индикатора соединены параллельно. Катоды (аноды) каждого разряда индикатора подключены через транзисторы к выводам порта PD.

Организация динамической индикации

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

1. На управляющий транзистор первого разряда индикатора (7Seg1), с вывода порта микроконтроллера PD0 подается логическая единица, которая открывает транзистор, в результате чего подается напряжение питания на данный разряд индикатора. На базах остальных транзисторов — логический ноль, транзисторы закрыты.
2. На выводах порта РВ0-РВ7 выставляется двоичный код соответствующей десятичной цифры — высвечивается нужная цифра в первом разряде.
3. На управляющий транзистор второго разряда (7Seg2) с вывода порта PD1 подается логическая единица (на остальные транзисторы — логический ноль) — подается питание на второй разряд индикатора.
4. На выводах порта РВ0-РВ7 выставляется двоичный код следующей (второй) десятичной цифры — высвечивается нужная цифра во втором разряде.
5. На управляющий транзистор третьего разряда (7Seg3) с вывода порта PD2 подается логическая единица (на остальные транзисторы — логический ноль) — подается питание на третий разряд индикатора.
6. На выводах порта РВ0-РВ7 выставляется двоичный код следующей (третьей) десятичной цифры — высвечивается нужная цифра во втором разряде.
7. И так, по кругу

Такая работа многоразрядного семисегментного индикатора называется —динамическая индикация .
Частота переключения разрядов должна быть в пределах 100 герц, тогда не будет заметно мерцание разрядов.

Для переключения разрядов можно задействовать (на примере микроконтроллера ATtiny2313) таймер «TIMER 0 «.
Настройка таймера производится следующим образом (при тактовой частоте 1 мГц — заводская установка):
— предделитель таймера устанавливаем в СК/8
— вызов прерывания по переполнению счетчика таймера

Вот так настройка таймера выглядит в программе:
Где:
— SP — настройка стека
— Timer 0 — настройка параметров таймера
— TIMSK — настройка прерывания

Алгоритм работы программы

Рассмотрим алгоритм программы для осуществления динамической индикации и вывода данных в многоразрядный семисегментный индикатор:

Этот алгоритм, в принципе, иллюстрирует организацию динамической индикации данных на многоразрядном индикаторе. При этом надо учитывать, что при первом прерывании выполняется первый «прямоугольник», а затем происходит выход из подпрограммы, при втором прерывании выполняется второй «прямоугольник» и тоже выход из подпрограммы и при третьем прерывании — нижний «прямоугольник» с выходом из подпрограммы, и далее по кругу.

Ну а теперь — самое легкое. Напишем программу вывода данных на многоразрядный семисегментный индикатор с динамической индикацией.

Программа индикации на многоразрядном семисегментном индикаторе

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

Назначение переменных:

Давайте посмотрим какие переменные для работы подпрограммы вывода данных на индикатор назначил я:

Data0, Data1 и Data2 — переменные, в которые основная программа записывает вычисленное значение (трехзначное)
Data — переменная, в которой записан адрес первой переменной данных — Data0
@Data — эта запись означает, что в переменной Data будет храниться адрес первой переменной данных — Data0
DataIndex — эта переменная хранит текущий номер переменной данных, которая выводилась на индикацию последней (0, 1 или 2, соответственно для Data0, Data1 или Data2)
PortDigits — эта переменная хранит данные о том, какой разряд индикатора зажигался последним

Настройка стека:

Стек настраивается в самом начале основной программы, мы его рассматривать не будем, так как к нашей подпрограмме он не относится

Настройка восьмиразрядного таймера Taimer0:

Taimer0 в подпрограмме используется как средство обеспечивающее динамическую индикацию разрядов индикатора

Настроенный таймер через определенные промежутки времени вызывает прерывание, в результате чего происходит остановка основной программы и осуществляется переход в подпрограмму обработки прерывания. В нашем случае — вызывается подпрограмма вывода данных на индикатор.
Как настраивается таймер: Частота переключения разрядов должна быть в пределах 100 Гц для предотвращения мерцания индикаторов при их поочередном зажигании (дело это в принципе индивидуальное, и зависит от особенностей вашего зрения).
Тактовая частота микроконтроллера — 1 мГц, или 1 000 000 Гц
Устанавливаем внутренний делитель частоты таймера в СК/8 — рабочая частота таймера будет в 8 раз меньше тактовой частоты микроконтроллера
Получаем: 1000 000/8 = 125 000 Гц, или 125 кГц — тактовая частота таймера
Настраиваем вызов прерывания по переполнению счетчика таймера (счетчик таймера восьмиразрядный и считает до 255, после этого сбрасывается в ноль и вызывается прерывание)
Получаем: 125 000/255 = 490 Гц (что соответствует времени приблизительно в 2 миллисекунды)
Мы поочередно зажигаем три разряда:
Получаем: 490/3 = 163 Гц — разряды индикатора будут переключаться с частотой 163 Гц.
Настройка таймера производится соответствующей настройкой соответствующих регистров таймера.
Давайте посмотрим как это происходит в Algorithm Builder:

Инициализация индикатора

Инициализация индикатора — эта фраза подразумевает настройку разрядов портов, к которым подключены выводы индикатора на вывод, а также обнуление переменных данных Data0…2 и запись первоначальных данных в остальные переменные. Процесс инициализации индикатора прописывается в начале основной программы.
Назовем подпрограмму инициализации Ini_Indikator2/
Давайте посмотрим этот процесс на примере:

В первой строке разряды порта РВ с 0 по 6 (к которым подключены семь сегментов индикатора) настраиваются на вывод информации (десятичную точку индикатора не используем).
Во второй строке разряды порта PD с 0 по 2 (к которым подключены управляющие транзисторы) также настраиваются на вывод.
Третьей строкой на выходах порта РВ устанавливается логический ноль — сегменты индикатора погашены для индикаторов с общим катодом).
Четвертая строка — обнуляем переменную DataIndex
Пятая строка — в переменную PortDigits записываем единицу
Следующие три строки — обнуляем переменные данных

Теперь нам необходимо куда-то записать которые будут подаваться на разряды порта PB для высвечивания соответствующей цифры на индикаторе.
В статье по программированию работы одноразрядного семисегментного индикатора, мы эти коды записывали программным путем в ОЗУ микроконтроллера. Сейчас мы сделаем по-другому — запишем двоичные коды в теле самой программы.
Для этого создадим таблицу двоичных кодов и присвоим ей имя, к примеру D0_9:

В этой таблице размещены двоичные коды (хотя и записаны в шестнадцатиричной системе) цифр от 0 до 9.

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

Подпрограмма вывода данных на многоразрядный семисегментный индикатор

Присвоим подпрограмме имя, к примеру Indikator2 , посмотрим на нее и разберем построчно:


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

В переменной DataIndex храниться номер ячейки памяти (0, 1 или 2) с данными (Data0, Data1 или Data2) которые необходимо вывести на разряд индикатора в текущий момент. Первоначально мы записали в нее ноль.
Первой строкой мы записываем содержимое DataIndex в регистр R20 , теперь в нем соответственно то-же ноль.
Во второй строчке мы увеличиваем содержимое регистра R20 на единицу (r20++) , теперь в R20 записана единица, означающая, что данные мы будем брать из переменной Data1. При втором прерывании R20 увеличится еще на единицу, станет равным 2, и соответственно следующие данные мы будем брать из переменной Data2. При следующем прерывании R20 станет равным 3.
Следующей строчкой (r20<3) мы проверяем какая цифра записана в регистре R20 — если меньше трех (0,1 или 2), то переходим по стрелке, а если равно трем, то обнуляем регистр R20 и данные теперь берем из переменной Data0.
Далее записываем содержимое R20 в переменную DataIndex .
Следующей командой @Data -> Y записываем адрес переменной Data0 в двойной регистр Y (R28, R29).
Затем складываем содержимое двойного регистра Y с содержимым R20 (0,1 или 2).
Командой [Y] -> r21 записываем содержимое переменной данных (или Data0, или Data1, или Data2 — в зависимости от значения r20) в рабочий регистр R21. Теперь в регистре R21 записана цифра из соответствующей переменной данных (к примеру цифра 5).
Следующей командой @D0_9*2 -> Z мы загружаем начальный адрес таблицы с двоичными кодами в двойной регистр Z (R30, R31). По начальному адресу у нас находится двоичный код для цифры 0.
Теперь мы складываем содержимое Z с R21 (с пятеркой) и получаем в регистре Z адрес в таблице двоичного кода с цифрой 5.
Следующей командой LPM[Z] -> R21 мы записываем двоичный код цифры 5 в рабочий регистр R21.
Команду NOP — холостой ход , можно и не прописывать — она вставлена для разделения отдельных кусков программы для наглядности.
Следующей командой PortDidgit -> R20 мы загружаем в рабочий регистр R20 содержимое переменной PortDidgit, а в нее мы предварительно записали единицу. Теперь в R20 записана единица (#b 0000 0001).
Следующей командой <Следующей командой R20 -> PortD мы подаем напряжение на второй разряд индикатора. При следующем прерывании произойдет еще один сдвиг влево (#b 0000 0100) и будет подключен третий разряд индикатора.
С помощью команды R20.3=1 записанной в овале, мы проверяем — достигла ли логическая единица при сдвигах третьего разряда регистра, и если — да, то записываем в R20 единицу (начинается новый круг).
Командой R21 -> PortB мы выводим двоичный код соответствующей цифры на подключенный разряд индикатора.
Командой R20 -> PortDigits — мы сохраняем текущее значение в переменной (последний зажженный разряд индикатора).