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

В статье будет рассмотрено подключение светодиодов к микроконтроллеру, работа с портами и написание программы на СИ. Статья, прежде всего, предназначена новичкам, которые только взялись за микроконтроллеры AVR.

Для начала нужно выбрать микроконтроллер. В моем случае это ATmega8535. В данном случае микроконтроллер можно брать любой, так как данная задача легко реализуется под любой МК. Писать программу для микроконтроллера можно на Ассемблере, СИ, Pascal-е и Bascom. Я использовал язык СИ, все эти языки разные.
Конкретную разницу между Си и Паскалем можно увидеть ниже.

//Мигающий светодиод void main() { ddrB = 0b11111111; //задаём порты B на выход portB = 0b11111111; //по умолчанию всё выключено while(1) { portB = ˜portB; //переключаем состояние светодиода на обратное delay_ms(100); //делаем задержку на 100 миллисекунд } }

Program First; begin ddrB:= $FF; //задаём порт B на выход portB:= $FF; //по умолчанию ничего не горит while(1) do begin portB:= not(portB); //переключаем состояние светодиода на обратное delay_ms(100); //делаем небольшую задержку end; end.

Список радиоэлементов

Добавлено: 28.06.2017 в 13:00

В этом примере мы напишем нашу первую программу на Си для микроконтроллера ATtiny13. Предполагается, что у нас уже подготовлено к работе всё необходимое: среда разработки, компилятор и т.д. Подопытным у меня будет самодельная отладочная плата , соответственно весь код буду приводить применительно к ней.
В качестве тестовой программы напишем классический, простейший пример "blink", который будет мигать светодиодом с определённой частотой.

Итак, создаём новый проект и приступаем. Приведу сразу полный код программы, а затем поясню всё более подробно:

/* * tiny13_board_blink * Демо-прошивка отладочной платы на ATtiny13 * с целью проверки работоспособности МК. * Мигаем светодиодом. */ #define F_CPU 1200000UL // Указываем тактовую частоту МК #define LED PB2 // Используем светодиод, подключенный к PB2 (7 пин) #include // Подключаем определения ввода/вывода #include // Подключаем библиотеку функций задержки int main(void) { // Светодиод DDRB |= (1<

В самом начале задаём значения констант и подключаем заголовочные файлы и библиотеки.
Файл avr/io.h подключает определения ввода/вывода для конкретного типа микроконтроллера (тип МК указывается в виде опции для компилятора).
Библиотеку util/delay.h подключаем для использования функций задержки, в нашем случае: _delay_ms() . Для работы функций задержки мы должны указать тактовую частоту процессора. Поэтому ДО подключения util/delay.h определяем константу F_CPU (в данном случае - 1,2МГц).

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

while (1) { ... }

Для начала, мы должны сконфигурировать порт ввода/вывода. В МК AVR старших моделей портов в/в может быть несколько (A, B, C, D). К каждому порту может быть подключено до восьми ножек. Каждая из ножек может быть настроена как на вход, так и на выход. ATtiny13 имеет только один порт (B), к которому подключены шесть ножек (PB0-PB5, см. datasheet). По умолчанию все ножки настроены на вход, а чтобы управлять светодиодом, мы должны использовать соответствующую ножку как выход. В микроконтроллерах AVR вся аппаратная часть настраивается посредством восьмибитных регистров. Направление (вход-выход) устанавливается битами регистров DDRx (где x - буква порта, в нашем случае B). Значение бита "0" - соответствует входу, "1" - выходу. Таким образом, чтобы использовать ножку PB2, как выход, мы должны установить второй бит регистра DDRB в единицу:

DDRB |= (1<

Для управления состоянием выхода предназначены регистры PORTx. Например, чтобы выключить светодиод, подключенный к ножке PB2 (подать низкий уровень сигнала), мы должны записать ноль во второй бит регистра PORTB :

PORTB &= ~(1<

Чтобы включить (подать высокий уровень сигнала) - соответственно, записываем единицу:

PORTB |= (1<

Теперь, когда порт в/в сконфигурирован, мы запускаем основной цикл, в котором будем инвертировать состояние выхода PB2 (чередовать высокий и низкий уровень сигнала) с задержкой 500мс. Таким образом, светодиод у нас будет мигать с частотой 1 раз в секунду.

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

Большинство команд микроконтроллеров AVR выполняются в один такт генератора задающей частоты. В качестве которого широко используют встроенную в МК RC-цепочку или подключают к выводам XTAL1 и XTAL2 кварцевый резонатор.

Например, если МК работает с частотой 1 Гц, то одна команда будет выполняться за одну секунду

По умолчанию у МК ATmega8 задействован собственный внутренний генератор частоты, а точнее RC-цепочка, которая работает на частоте 1000 000 Гц = 1 МГц. Поэтому время выполнения одной команды равно:

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

#include

int main (void )

DDRD = 0b000000011;

while (1)

PORTD = 0b000000001; // Подаем питание на 1-й светодиод

PORTD = 0b000000010; // Подаем питание на 2-й светодиод

Но на самом деле второй LED загорится с разницей во времени 0,000001 секунды от первого. Наши глаза не могут заметить такой малой разницы во времени. Уже при частоте изображений более 24 Гц (t = 1/24 ≈ 0,042 с) наше зрение формирует из отдельных картинок непрерывный фильм. Поэтому в большинстве случаев мы не различаем 25-й кадр.

Для того, чтобы оба светодиода засветились с разницей во времени 0,5 секунды необходимо между соответствующими двумя командами (PORTD = 0b000000001; и PORTD = 0b000000010; ) поместит еще 500 000 однотактных пустых команд, т. е. заставить МК полсекунды не выполнять никаких полезных действий. Или, как говорят, нужно “убить” 500 000 тактов. Если код пишется на Ассемблере, то программисты применяют различных циклы, которые “съедают” определенное число тактов и тем самым получают различные интервалы времени.

#include

int main (void )

DDRD = 0b000000011;

while (1)

PORTD = 0b000000001; // Подаем питание на 1-й светодиод

Для получения задержки 0,5 секунды сюда нужно вставить

500 000 однотактных команд

PORTD = 0b000000010; // Подаем питание на 2-й

Функция _delay_ms() и мигающий светодиод

При написании кода на Си в Atmel Studio имеется очень удобная функция _delay_ms () . Для работы данной функции ее необходимо предварительно подключить директивой препроцессора .

В круглых скобках данной функции можно задавать время в миллисекундах, тогда перед скобками нужно записать ms, или в микросекундах – us:

При использовании данной функции для того, чтобы при компиляции Atmel Studio не выдавала никаких предупреждений, следует объявить частоту с помощью оператора #define . Так как по умолчанию для ATmega8 она равна 1 000 000 Гц, то это значение мы и объявим. Это делается следующей строкой:

#define F_CPU 1000000UL

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

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

# define

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

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

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

#define MIG 300

_ delay _ ms (MIG);

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

После строки с директивой препроцессора #define точка с запятой не ставится. Между именем константы и числовым значением ставится пробел.

Данная строка работает следующим образом. Перед началом компиляции выполняется замена числом 300 всех констант с именем MIG.

#define и регистры

Также оператор #define хорош тем, что с помощью него можно задавать имена регистрам. Например, если мы подключаем к порту D светодиоды, то вместо PORTD мы можем записать, например VD:

#define VD PORTD

VD = 0b00000001;

Давайте перепишем программу, применяю директиву #define :

#define F_CPU 1000000UL

#include

#include

• Перевод

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

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

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

В блоге Evil Mad Scientist недавно был рассказ о похожих светодиодах. Там было показано, как они «поют», если преобразовать изменения яркости в звук. А также - как с их помощью управлять более мощным диодом. Подобные трюки основаны на том, что светодиод потребляет больший ток в те моменты, когда контроллер зажигает его ярче. Обычный светодиод, включенный последовательно с мерцающим, показывает очень похожие изменения яркости. Иными словами, падение напряжения на добавочном резисторе изменяется пропорционально яркости.

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

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

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

Любопытно, что частота сигнала - примерно 440 Гц, как у стандартного камертона (нота Ля первой октавы - прим. перев. ). Совпадение? Или разработчик просто взял генератор из какой-то музыкальной схемы? Так что есть доля правды в рассказах о «музыкальности» этих светодиодов. Каждый «кадр» постоянной яркости составляет ровно 32 такта и длится около 72 мс. Это соответствует 13-14 кадрам в секунду.

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

График яркости в зависимости от времени наводит на некоторые мысли: изменения яркости случайны, дискретны и имеют неравномерное распределение. Кажется, существуют 16 уровней яркости, низшие 4 из которых используются очень редко. Им соответствуют только 13 из 3600 отсчетов.

Постороение гистограммы открывает всю картину: фактически используется только 12 уровней яркости. Ровно половина кадров имеет максимальную яркость, остальные значения распределены примерно поровну.

Как это может быть реализовано на аппаратном уровне? Вполне вероятно, используется генератор равномерно распределенных случайных чисел, которые пропускают через простую функцию-формирователь. Для того распределения, которое мы наблюдаем, требуется как минимум 12x2=24 дискретных уровня. Половина из них отображаются в один. Это весьма любопытно, так как генератор, скорее всего, выдает двоичные числа. Наиболее логичной была бы разрядность числа 5 бит, а это 32 состояния. Отобразить 32-уровневую дискретную случайную величину в 24 уровня, не изменив распределения, не так просто, как кажется. Не забываем также, что это совсем не критичная схема, и у разработчика, вероятно, не было много времени на красивое решение. Поэтому он применил самое простое, своего рода хак.

Единственный простой способ, что приходит на ум - просто отбрасывать неподходящие значения и брать следующее случайное число. Нежелательные значения можно легко отделить по битовой маске. Так как схема синхронная, есть только конечное число попыток, пока не начнется следующий кадр. Если контроллер не уложился в заданное количество попыток, он застрянет на «неправильном» значении. Помните редкие выбросы на графике яркости?

Реализация на ANSI-C могла бы выглядеть так:
char attempts=0; char out; while(attempts++15) out=15; // верхняя половина диапазона соответствует максимальной яркости

Можно узнать, сколько делается попыток? По статистике, доля a=0,25 всех чисел должн быть отброшена и сгенерирована заново. Вероятность того, что за n попыток не будет выбрано «правильное» число, равна a n .
n=1 0,25 n=2 0,0625 n=3 0,015625 n=4 0,003906

Доля аномально низких уровней яркости составляет 13/3600=0,0036 , что хорошо совпадает с вариантом n=4 . Таким образом, MAX_ATTEMPTS==4 .

Обратите внимание, что более простым решением было бы просто использовать значение из предыдущего кадра, если встретилось недопустимое число. Этот вариант можно было бы исключить, исходя из автокорреляции (см. ниже). Наиболее же простое, вероятно, решение - изменить схему ШИМ - не было здесь использовано.

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

Я рассчитал автокорреляцию всей последовательности значений. Самоподобия не было найдено вплоть до 3500 кадров (на графике выше показано только 1200), что означает уникальность мерцания на протяжении по меньшей мере 4 минут. Неясно, наблюдалось ли дальнейшее повторение последовательности, или логический анализатор автора просто не позволял записывать дольше - прим. перев. Поскольку на каждый кадр нужно как минимум 5 бит случайных данных (а учитывая механизм отбрасывания нежелательных чисел - еще больше), псевдослучайная последовательность имеет длину по меньшей мере 17500 бит. Для этого потребуется регистр разрядности не менее 17, либо настоящий аппаратный генератор случайных чисел. В любом случае, интересно, как много внимания при разработке уделили тому, чтобы картина мерцания не повторялась.

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

Каков же лучший алгоритм мерцания? Можно ли улучшить этот?

Дополнение: Я наконец нашел время написать эмулятор. Написанная на ANSI-C программа, эмулирующая поведение этого светодиода,

Схема мигающего светодиода проста, это типовая обвязка микроконтроллера AVR Atmega8 (смотри ) + резистор со светодиодом подключенные к выводу 14.

Надеюсь что с установкой и скачкой утилиты вопросов не возникает. Поэтому после инсталляции и перезагрузки ПК запускаем программу и создаем новый проект. Для этого нажимаем в меню File->New. Появится окно "Createe New File" (Создать новый файл). В нем выбираем File Type (Тип файла) - Project (проект) и нажимаем Ok. Появляется новое окно "Вы хотите создать новый проект и использовать генератор кода?" Отвечаете Да (Yes). В окне генератора кода мы выбираем что будет проинициализировано нашим микроконтроллером перед стартом основной программы. Начнем с вкладки Chip , в ней выбираем наш МК: Atmega 8 с частотой 4 МГЦ.

Переходим в следующую вкладку Ports . Здесь в Port B нулевой бит переключаем с In на Out. Значение по умолчанию на выходе оставляем нулевым. Это значит что при запуске МК на порту B в нулевом разряде будет логический ноль. Далее сохраняем наш проект жесткий диск, например в C:/my_cvavr/project_led.

Для генерации стартового кода жмем на иконку "шестеренка" (немного правее иконки сохранить) и дважды под тем же именем сохраняем проект. Давайте теперь рассмотрим отдельные моменты полученного кода.

Строка: include mega8.h в ней мы говорим компилятору о том, что требуется подключить файл с описаниями всех регистров ATmega8

Строка: PORTB=0x00; по умолчанию установлен логический ноль на выходе. Правда этим выражением выводится нули в весь порт. А можно чуть по проще PORTB.0=0x00;

Строка: DDRB=0x01 ; Вспоминаем статью " ". Так как цифра 0x01 в hex равна 0b00000001 и bin. переведя это выражение из шестнадцатеричной системы в двоичную, мы поймем, что в нулевой разряд регистра направления DDRB записали 1, т.е будем выводить данные через нулевой разряд порта В.

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

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

PORTB.0 = 0x01;
PORTB.0 = 0x00;

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

Что же нам делать? Как вариант, можно вставить паузы длинной в пол секунды или использовать аппаратный таймер с прерыванием. Но раз уж мы мы работаем в утилите CodeVisionAVR, а в ней есть отличная библиотека полезных функций, в которой можно выбрать паузу delay_ms(int x) или delay_us(int x) . В первом случае будет пауза длинной х миллисекунд, а в другом х микросекунд. Но чтоб ей пользоваться придется вернуться на самый верх кода и после строки #include допишем под ней #include , т.е подключим библиотеку и можем пользоваться функциями пауз. Допишем наш код.

PORTB.0 = 0x01;
delay_ms(500);
PORTB.0 = 0x00;
delay_ms(500);

Для сборки проекта. В меню нажимаем Project->Build All, После сборки мы увидим окно в котором говорится, что все сделано без ошибок и нет различных предупреждений. Две строки: No errors и No warnings.