Задания

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

Заключение

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

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

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

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

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

На этой схеме выводы порта РВ (РВ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 — мы сохраняем текущее значение в переменной (последний зажженный разряд индикатора).

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

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

Как говорит его название, состоит из семи элементов индикации (сегментов), включающихся и выключающихся по отдельности. Включая их в разных комбинациях, из них можно составить упрощённые изображения арабских цифр.
Сегменты обозначаются буквами от A до G; восьмой сегмент - десятичная точка (decimal point, DP), предназначенная для отображения дробных чисел.
Изредка на семисегментном индикаторе отображают буквы.

Бывают разных цветов, обычно это белый, красный, зеленый, желтый и голубой цвета. Кроме того, они могут быть разных размеров.

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

Кроме десяти цифр, семисегментные индикаторы способны отображать буквы. Но лишь немногие из букв имеют интуитивно понятное семисегментное представление.
В латинице : заглавные A, B, C, E, F, G, H, I, J, L, N, O, P, S, U, Y, Z, строчные a, b, c, d, e, g, h, i, n, o, q, r, t, u.
В кириллице : А, Б, В, Г, г, Е, и, Н, О, о, П, п, Р, С, с, У, Ч, Ы (два разряда), Ь, Э/З.
Поэтому семисегментные индикаторы используют только для отображения простейших сообщений.

Всего семисегментный светодиодный индикатор может отобразить 128 символов:

В обычном светодиодном индикаторе девять выводов: один идёт к катодам всех сегментов, а остальные восемь - к аноду каждого из сегментов. Эта схема называется «схема с общим катодом» , существуют также схемы с общим анодом (тогда все наоборот). Часто делают не один, а два общих вывода на разных концах цоколя - это упрощает разводку, не увеличивая габаритов. Есть еще, так называемые «универсальные», но я лично с такими не сталкивался. Кроме того существуют индикаторы со встроенным сдвиговым регистром, благодаря чему намного уменьшается количество задействованных выводов портов микроконтроллера, но они намного дороже и в практике применяются редко. А так как необъятное не объять, то такие индикаторы мы пока рассматривать не будем (а ведь есть еще индикаторы с гораздо большим количеством сегментов, матричные).

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

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

На схеме ниже, показано как подключается одноразрядный семисегментный индикатор к микроконтроллеру.
При этом следует учитывать, что если индикатор с ОБЩИМ КАТОДОМ , то его общий вывод подключается к «земле» , а зажигание сегментов происходит подачей логической единицы на вывод порта.
Если индикатор с ОБЩИМ АНОДОМ , то на его общий провод подают «плюс» напряжения, а зажигание сегментов происходит переводом вывода порта в состояние логического нуля .

Осуществление индикации в одноразрядном светодиодном индикаторе осуществляется подачей на выводы порта микроконтроллера двоичного кода соответствующей цифры соответствующего логического уровня (для индикаторов с ОК — логические единицы, для индикаторов с ОА — логические нули).

Токоограничительные резисторы могут присутствовать в схеме, а могут и не присутствовать. Все зависит от напряжения питания, которое подается на индикатор и технических характеристик индикаторов. Если, к примеру, напряжение подаваемое на сегменты равно 5 вольтам, а они рассчитаны на рабочее напряжение 2 вольта, то токоограничительные резисторы ставить необходимо (чтобы ограничить ток через них для повышенного напряжении питания и не сжечь не только индикатор, но и порт микроконтроллера).
Рассчитать номинал токоограничительных резисторов очень легко, по формуле дедушки Ома .
К примеру, характеристики индикатора следующие (берем из даташита):
— рабочее напряжение — 2 вольта
— рабочий ток — 10 мА (=0,01 А)
— напряжение питания 5 вольт
Формула для расчета:
R= U/I (все значения в этой формуле должны быть в Омах, Вольтах и Амперах)
R= (напряжение питания — рабочее напряжение)/рабочий ток
R= (5-2)/0.01 = 300 Ом

Схема подключения многоразрядного семисегментного светодиодного индикатора в основном та-же, что и при подключении одноразрядного индикатора. Единственное, добавляются управляющие транзисторы в катодах (анодах) индикаторов:

На схеме не показано, но между базами транзисторов и выводами порта микроконтроллера необходимо включать резисторы, сопротивление которых зависит от типа транзистора (номиналы резисторов рассчитываются, но можно и попробовать применить резисторы номиналом 5-10 кОм).

Осуществление индикации разрядами осуществляется динамическим путем:
— выставляется двоичный код соответствующей цифры на выходах порта РВ для 1 разряда, затем подается логический уровень на управляющий транзистор первого разряда
— выставляется двоичный код соответствующей цифры на выходах порта РВ для 2 разряда, затем подается логический уровень на управляющий транзистор второго разряда
— выставляется двоичный код соответствующей цифры на выходах порта РВ для 3 разряда, затем подается логический уровень на управляющий транзистор третьего разряда
— итак по кругу
При этом надо учитывать:
— для индикаторов с ОК применяется управляющий транзистор структуры NPN (управляется логической единицей)
— для индикатора с ОА — транзистор структуры PNP (управляется логическим нулем)

В продолжение урока, рассмотрим динамическую индикацию. Если вы внимательно изучили статическую индикацию, то знаете, что сегментный индикатор это набор светодиодов. Для того, чтобы подключить индикатор, нужно 7 ножек микроконтроллера. Но, вдруг нам понадобилось использовать несколько индикаторов, например 2, 3, 4…

Тогда нам понадобится уже 14, 21, 28 ножек, а ножек итак мало… Тут нам на помощь приходит динамическая индикация. Основная задача динамической индикации — снизить количество используемых ножек микроконтроллера. Обратите внимание на схеме задействовано 9, а не 14 ножек. Ножки управления все подключены параллельно.

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

Более детально. В первый момент времени все выключено PORTB=0x00; PORTD=0xFF; так как схема с общим «+», анодом. Далее на PORTD посылается конфигурация первого числа, например «0». Из статической индикации мы помним:

case 0: { PORTD=0xC0; break; }

Но обратите внимание, «+» подключен к PORTB.1, т.е. чтобы зажечь сегмент нужно включить ножку PORTB.1=1;

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

При высоких частотах, человеческий глаз не способен разглядеть эти переключения, и кажется что индикатор горит постоянно. Рекомендуется не использовать частоты кратные 50Гц. В своем тестовом проекте я использовал 120Гц. Таймер настроен на частоту 1МГц. Код обрабатывается в прерывании таймера1. Прерывание вызывается 240 раз в секунду, потому что индикаторов два, поэтому 1000 000/240=4166 или 0x1046 пихаем в регистр сравнения. Протеус подружить с динамическим индикатором не удалось, зато на железе заработало сразу.

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

Для схемы с общим анодом

Для схемы с общим катодом

В качестве тестовой прошивки использовал таймер из предыдущего проекта.

Видео работы прошивки

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

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 . Программно на основе этой таблицы организуется все: от инверсии в зависимости типа индикатора, до перестановки битов по разным портам. При этом исходный код программы динамической индикации остается неизменным всегда, а таблица конфигурации составляется конечным пользователем в зависимости от своих предпочтений. Метод действиетльно универсальный и гибкий, однако сопряжен с повышенным расходом памяти программ.

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