Самоучитель по языку си для микроконтроллеров. Вы еще не программируете микроконтроллеры? Тогда мы идем к вам! Полный текст программы
В этом учебном курсе по avr я постарался описать все самое основное для начинающих программировать микроконтроллеры avr . Все примеры построены на микроконтроллере atmega8 . Это значит, что для повторения всех уроков вам понадобится всего один МК. В качестве эмулятора электронных схем используется Proteus - на мой взгляд, - лучший вариант для начинающих. Программы во всех примерах написаны на компиляторе C для avr CodeVision AVR. Почему не на каком-нибудь ассемблере? Потому что начинающий и так загружен информацией, а программа, которая умножает два числа, на ассемблере занимает около ста строк, да и в сложных жирных проектах используют С. Компилятор CodeVision AVR заточен под микроконтроллеры atmel, имеет удобный генератор кода, неплохой интерфейс и прямо с него можно прошить микроконтроллер.
В этом учебном курсе будет рассказано и показано на простых примерах как:
- Начать программировать микроконтроллеры, с чего начать, что для этого нужно.
- Какие программы использовать для написания прошивки для avr, для симуляции и отладки кода на ПК,
- Какие периферийные устройства находятся внутри МК, как ими управлять с помощью вашей программы
- Как записать готовую прошивку в микроконтроллер и как ее отладить
- Как сделать печатную плату для вашего устройства
- Proteus - программа-эмулятор (в ней можно разработать схему, не прибегая к реальной пайке и потом на этой схеме протестировать нашу программу). Мы все проекты сначала будем запускать в протеусе, а потом уже можно и паять реальное устройство.
- CodeVisionAVR - компилятор языка программирования С для AVR. В нем мы будем разрабатывать программы для микроконтроллера, и прямо с него же можно будет прошить реальный МК.
Он нам предлагает посмотреть проекты которые идут с ним, мы вежливо отказываемся. Теперь давайте создадим в ней самую простую схему. Для этого кликнем на значок визуально ничего не происходит. Теперь нужно нажать на маленькую букву Р (выбрать из библиотеки)
в панели списка компонентов, откроется окно выбора компонентов 
в поле маска вводим название компонента, который мы хотим найти в библиотеке. Например, нам нужно добавить микроконтроллер mega8 
в списке результатов тыкаем на mega8 и нажимаем кнопку ОК
. У нас в списке компонентов появляется микроконтроллер mega8
Таким образом добавляем в список компонентов еще резистор, введя в поле маска слово res
и светодиод led
Чтобы разместить детали на схеме, кликаем на деталь, далее кликаем по полю схемы, выбираем место расположения компонента и еще раз кликаем. Для добавления земли или общего минуса на схему слева кликаем "Терминал" и выбираем Ground. Таким образом, добавив все компоненты и соединив их, получаем вот такую простенькую схемку
Все, теперь наша первая схема готова! Но вы, наверное, спросите, а что она может делать? А ничего. Ничего, потому что для того, чтобы микроконтроллер заработал, для него нужно написать программу. Программа - это список команд, которые будет выполнять микроконтроллер. Нам нужно, чтобы микроконтроллер устанавливал на ножке PC0
логический 0 (0 вольт) и логическую 1 (5 вольт).
Написание программы для микроконтроллера
Программу мы будем писать на языке С в компиляторе CodeVisionAVR. После запуска CV, он спрашивает нас, что мы хотим создать: Source или Project
Мы выбираем последнее и нажимаем кнопку ОК. Далее нам будет предложено запустить мастер CVAVR CodeWizard (это бесценный инструмент для начинающего, потому как в нем можно генерировать основной скелет программы) 
выбираем Yes
Мастер запускается с активной вкладкой Chip, здесь мы можем выбрать модель нашего МК - это mega8, и частоту, на которой будет работать МК (по умолчанию mega8 выставлена на частоту 1 мегагерц), поэтому выставляем все, как показано на скриншоте выше.
Переходим во вкладку Ports
У микроконтроллера atmega8 3 порта: Port C, Port D, Port B. У каждого порта 8 ножек. Ножки портов могут находиться в двух состояниях: - Выход
- DDRx.y = 0 - вывод работает как ВХОД
- DDRx.y = 1 вывод работает на ВЫХОД
#include
Здесь вам может показаться все страшным и незнакомым, но на самом деле все не так. Код можно упростить, выкинув инициализацию неиспользуемых нами периферийных устройств МК. После упрощения он выглядит так:
#include
Всё хорошо. Но для того, чтобы светодиод замигал, нам нужно менять логический уровень на ножке PC0. Для этого в главный цикл нужно добавить несколько строк:
#include
Все, теперь код готов. Кликаем на пиктограму Build all Project files, чтобы скомпилировать (перевести в инструкции процессора МК) нашу программу. В папке Exe, которая находится в нашем проекте, должен появиться файл с расширением hex, это и есть наш файл прошивки для МК. Для того, чтобы нашу прошивку скормить виртуальному микроконтроллеру в Proteus, нужно два раза кликнуть на изображении микроконтроллера в протеусе. Появится вот такое окошко
кликаем на пиктограму папки в поле Program File, выбераем hex - файл нашей прошивки и нажимаем кнопку ОК.
Теперь можно запустить симуляцию нашей схемы. Для этого нажимаем кнопку "Воспроизвести" в нижнем левом углу окна Протеус.
Побитовые операции основаны на логических операциях, которые мы уже рассмотрели ранее. Они играют ключевую роль при программировании микроконтроллеров AVR и других типов. Практически ни одна программа не обходится без применения побитовых операций. До этого мы намеренно избегали их, чтобы облегчить процесс изучения программирования МК.
Во всех предыдущих статьях мы программировали только порты ввода-вывода а и не задействовали дополнительные встроенные узлы, например, такие как таймеры, аналогово-цифровые преобразователи, прерывания и другие внутренние устройства без которых МК теряет всю свою мощь.
Прежде, чем перейти к освоению встроенных устройств МК, необходимо научится управлять или проверять отдельные биты регистров МК AVR. Ранее же мы выполняли проверку или устанавливали разряды сразу всего регистра. Давайте разберемся, в чем состоит отличие, а затем продолжим далее.
Побитовые операции
Чаще всего при программировании микроконтроллеров AVR мы пользовались , поскольку она имеет большую наглядность по сравнению с и хорошо понятна для начинающих программистов МК. Например, нам нужно установить только 3-й бит порта D. Для этого, как мы уже знаем, можно воспользуемся следующим двоичным кодом:
PORTD = 0b00001000;
Однако этой командой мы устанавливаем 3-й разряд в единицу, а все остальные (0, 1, 2, 4, 5, 6 и 7-й) мы сбрасываем в ноль. А теперь давайте представим ситуацию, что 6-й и 7-й разряды задействованы как входы АЦП и в это время на соответствующие выводы МК поступает сигнал от какого-либо устройства, а мы, применяемой выше командой, обнуляем эти сигналы. В результате чего микроконтроллер их не видит и считает, что сигналы не приходили. Поэтому вместо такой команды нам следует применить другую, которая бы установила только 3-й бит в единицу, при этом не влияя на остальные биты. Для это обычно применяется следующая побитовая операция:
PORTD |= (1<<3);
Синтаксис ее мы подробно разберем далее. А сейчас еще один пример. Допустим нам нужно проверить состояние 3-го разряда регистра PIND, тем самым проверяя состояние кнопки. Если данный разряд сброшен в ноль, то мы знаем, что кнопка нажата и далее выполняется код команды, который соответствует состоянию нажатой кнопки. Ранее мы бы воспользовались следующей записью:
if (PIND == 0b00000000)
{ какой-либо код}
Однако с помощью нее мы проверяем не отдельный, – 3-й, а сразу все биты регистра PIND. Поэтому даже если кнопка нажат и нужный разряд сброшен, но в это время на какой-либо другой вывод порта D поступит сигнал, то соответствующий быт установится в единицу, и условие в круглых скобках будет ложным. В результате код, находящийся в фигурных скобках, не будет выполняться даже при нажатой кнопке. Поэтому для проверки состояния отдельного 3-го бита регистра PIND следует применять побитовую операцию:
if (~PIND & (1<<3))
{ какой-либо код}
Для работы с отдельными битами микроконтроллера в арсенале языка программирования C имеются , с помощью которых можно изменять или проверять состояние одного или нескольких отдельных бит сразу.
Установка отдельного бита
Для установки отдельного бита, например порта D, применяется побитовая операция ИЛИ. Именно ее мы применяли в начале статьи.
PORTD = 0b00011100; // начальное значение
PORTD = PORTD | (1<<0); применяем побитовую ИЛИ
PORTD |= (1<<0); // сокращенная форма записи
PORTD == 0b00011101; // результат
Эта команда выполняет установку нулевого разряда, а остальные оставляет без изменений.
Для примера установим еще 6-й разряд порта D.
PORTD = 0b00011100; // начальное состояние порта
PORTD |= (1<<6); //
PORTD == 0b01011100; // результат
Чтобы записать единицу сразу в несколько отдельных бит, например нулевой, шестой и седьмой порта B применяется следующая запись.
PORTB = 0b00011100; // начальное значение
PORTB |= (1<<0) | (1<<6) | (1<<7); //
PORTB == 0b1011101; // результат
Сброс (обнуление) отдельных битов
Для сброса отдельного бита применяются сразу три ранее рассмотренные команды: .
Давайте сбросим 3-й разряд регистра PORTC и оставим без изменений остальные.
PORTC = 0b00011100;
PORTC &= ~(1<<3);
PORTC == 0b00010100;
Выполним подобные действия для 2-го и 4-го разрядов:
PORTC = 0b00111110;
PORTC &= ~((1<<2) | (1<<4));
PORTC == 0b00101010;
Переключение бита
Кроме установки и сброса также применяется полезная команда, которая переключает отдельный бит на противоположное состояние: единицу в ноль и наоборот. Данная логическая операция находит широкое применение при построении различных световых эффектов, например, таких как новогодняя гирлянда. Рассмотрим на примере PORTA
PORTA = 0b00011111;
PORTA ^= (1<<2);
PORTA == 0b00011011;
Изменим состояние нулевого, второго и шестого битов:
PORTA = 0b00011111;
PORTA ^= (1<<0) | (1<<2) | (1<<6);
PORTA == 0b01011010;
Проверка состояния отдельного бита. Напомню, что проверка (в отличии от записи) порта ввода-вывода осуществляется с помощью чтения данных из регистра PIN.
Наиболее часто проверка выполняется одним из двух операторов цикла: if и while. С этими операторами мы уже знакомы ранее.
Проверка разряда на наличие логического нуля (сброса) с if
if (0==(PIND & (1<<3)))
Если третий разряд порта D сброшен, то выполняется Код1. В противном случае, выполняется Код2.
Аналогичные действия выполняются при и такой форме записи:
if (~PIND & (1<<3))
Проверка разряда на наличие логической единицы (установки) с if
if (0 != (PIND & (1<<3)))
if (PIND & (1<<3))
Приведенные выше два цикла работаю аналогично, но могут, благодаря гибкости языка программирования C, иметь разную форму записи. Операция!= обозначает не равно. Если третий разряд порта ввода-вывода PD установлен (единица), то выполняется Код1, если нет ‑ Код2.
Ожидание сброса бита с while
while (PIND & (1<<5))
Код1 будет выполняться пока 5-й разряд регистра PIND установлен. При сбросе его начнет выполняться Код2.
Ожидание установки бита с while
Здесь синтаксис языка С позволяет записать код двумя наиболее распространёнными способами. На практике применяются оба типа записи.
Итак, что вообще такое микроконтроллер (далее МК)? Это, условно говоря, маленький компьютер, размещенный в одной интегральной микросхеме. У него есть процессор (арифметическо-логическое устройство, или АЛУ), flash-память, EEPROM-память, множество регистров, порты ввода-вывода, а также дополнительные «навороты», такие как таймеры, счетчики, компараторы, USARTы и т. п. Микроконтроллер после подачи питания загружается и начинает выполнять программу, записанную в его flash-памяти. При этом он может через порты ввода/вывода управлять самыми разнообразными внешними устройствами.
Что же это означает? Это значит, что в МК можно реализовать любую логическую схему, которая будет выполнять определенные функции. Это значит, что МК – микросхема, внутреннее содержимое которой, фактически, мы создаем сами. Что позволяет, купив несколько совершенно одинаковых МК, собрать на них совершенно разные схемы и устройства. Если вам захочется внести какие-либо изменения в работу электронного устройства, то не нужно будет использовать паяльник, достаточно будет лишь перепрограммировать МК. При этом не нужно даже вынимать его из вашего дивайса, если вы используете AVR, т. к. эти МК поддерживают внутрисхемное программирование. Таким образом, микроконтроллеры ликвидируют разрыв между программированием и электроникой.
AVR – это 8-битные микроконтроллеры, т. е. их АЛУ может за один такт выполнять простейшие операции только с 8-ми битными числами. Теперь пора поговорить о том, какой МК мы будем использовать. Я работаю с МК ATMega16. Он очень распространенный и приобрести его можно практически в любом магазине радиодеталей где-то за 100 руб. Если вы его не найдете – тогда можно купить любой другой МК серии MEGA, но в этом случае придется искать к нему документацию, т. к. одни и те же «ножки» разных МК могут выполнять разные функции, и, подключив, казалось бы, правильно все выводы, вы, может быть, получите рабочее устройство, а, может быть, лишь облако вонючего дыма. При покупке ATMega16 проверьте, чтобы он был в большом 40-ножечном DIP-корпусе, а также купите к нему панельку, в которую его можно будет вставить. Для работы с ним потребуются также дополнительные устройства: светодиоды, кнопки, разъемы и т. п..
ATMega16 обладает очень большим количеством самых разнообразных функций. Вот некоторые его характеристики:
- Максимальная тактовая частота – 16 МГц (8 МГц для ATMega16L)
- Большинство команд выполняются за один такт
- 32 8-битных рабочих регистра
- 4 полноценных 8-битных порта ввода/вывода
- два 8-битных таймера/счетчика и один 16-битный
- 10-разрядный аналогово-цифровой преобразователь (АЦП)
- внутренний тактовый генератор на 1 МГц
- аналоговый компаратор
- интерфейсы SPI, I2C, TWI, RS-232, JTAG
- внутрисхемное программирование и самопрограммирование
- модуль широтно-импульсной модуляции (ШИМ)
Полные характеристики этого устройства, а также инструкции по их применению можно найти в справочнике (Datasheetе) к этому МК. Правда, он на английском языке. Если вы знаете английский, то обязательно скачайте этот Datasheet, в нем много полезного.
Приступим, наконец, к делу. Я рекомендую изготовить для микроконтроллера специальную макетно-отладочную плату, на которой можно будет без паяльника (или почти без него) собрать любую электрическую схему с микроконтроллером. Использование такой платы значительно облегчит работу с МК и ускорит процесс изучения его программирования. Выглядит это так:
Что для этого понадобится?
Во-первых, потребуется сама плата. Я купил уже готовую в магазине радиодеталей за 115 руб. Потом припаял к ней все необходимые детали. Получилась неимоверно удобная вещь, на которой можно за считанные минуты собрать какую-либо электрическую схему путем перетыкания шлейфов и установки микросхем и индикаторов.
Для соединения элементов схемы очень удобно использовать шлейфы, на концах которых установлены разъемы. Эти разъемы надеваются на «ножки», торчащие рядом с каждым портом МК. Микроконтроллер следует устанавливать в панельку, а не припаивать к плате, иначе его очень трудно будет вынуть в случае, если вы его случайно сожжете. Ниже приведена цоколевка МК ATMEGA16:
Поясним, какие ножки нас сейчас интересуют.
- VCC – сюда подается питание (4,5 – 5,5 В) от стабилизированного источника
- GND – земля
- RESET – сброс (при низком уровне напряжения)
- XTAL1, XTAL2 – сюда подключается кварцевый резонатор
- PA, PB, PC, PD – порты ввода/вывода (A, B, C и D соответственно).
В качестве источника питания можно использовать все, что выдает 7-11 В постоянного тока. Для стабильной работы МК нужно стабилизированное питание. В качестве стабилизатора можно использовать микросхемы серии 7805. Это линейные интегральные стабилизаторы, на вход которых подают 7-11 В постоянного нестабилизированного тока, а на выходе получают 5 В стабилизированного. Перед 7805 и после него нужно поставить фильтрующие конденсаторы (электролитические для фильтрации помех низких частот и керамические для высоких). Если не удается найти стабилизатор, то можно в качестве источника питания использовать батарейку на 4,5 В. От нее МК нужно питать напрямую.
Ниже приведу схему подключения МК:
Давайте теперь разберемся, что здесь для чего.
BQ1 – это кварцевый резонатор, задающий рабочую частоту МК. Можно поставить любой до 16 МГц, но, поскольку мы планируем работать в будущем и с COM-портом, то рекомендую использовать резонаторы на следующие частоты: 14,7456 МГц, 11,0592 МГц, 7,3725 МГц, 3,6864 МГц или 1,8432 МГц (позже станет ясно, почему). Я использовал 11,0592 МГц. Понятное дело, что чем больше частота, тем выше и скорость работы устройства.
R1 – подтягивающий резистор, который поддерживает напряжение 5 В на входе RESET. Низкий уровень напряжения на этом входе означает сброс. После сброса МК загружается (10 – 15 мс) и начинает выполнять программу заново. Поскольку это высокоомный вход, то нельзя оставлять его «болтающимся в воздухе» - небольшая наводка на нем приведет к непредвиденному сбросу МК. Именно для этого и нужен R1. Для надежности рекомендую также установить конденсатор С6 (не более 20 мкФ).
SB1 – кнопка сброса.
Кварцевый резонатор и фильтрующий конденсатор C3 должны располагаться как можно ближе к МК (не далее 5-7 см), т. к. иначе могут возникать наводки в проводах, приводящие к сбоям в работе МК.
Синим прямоугольником на схеме обведен собственно программатор. Его удобно выполнить в виде провода, один конец которого втыкается в LPT порт, а другой – в некий разъем рядом с МК. Провод не должен быть чрезмерно длинным. Если возникнут проблемы с этим кабелем (обычно не возникают, но всякое бывает) то придется спаять адаптер Altera ByteBlaster. О том, как это сделать, написано в описании к программатору AVReal.
Теперь, когда разобрались с железом, пора перейти к программному обеспечению.
Для программирования AVR есть несколько сред разработки. Во-первых, это AVR Studio – официальная система программирования от Atmel. Она позволяет писать на ассемблере и отлаживать программы, написанные на ассемблере, С и С++. IAR – это коммерческая система программирования на C, С++ и ассемблере. WinAVR – компилятор с открытыми исходниками. AtmanAVR – система программирования для AVR с интерфейсом, почти «один в один» таким же, как у Visual C++ 6. AtmanAVR также позволяет отлаживать программы и содержит множество вспомогательных функций, облегчающих написание кода. Эта система программирования коммерческая, но, согласно лицензии, ее можно в течение месяца использовать «нахаляву».
Я предлагаю начать работу с IAR как с наиболее «прозрачной» средой разработки. В IAR проект целиком создается «ручками», соответственно, сделав несколько проектов, вы уже будете четко знать, что означает каждая строчка кода и что будет, если ее изменить. При работе же с AtmanAVR придется либо пользоваться предварительно созданным шаблоном, который очень громоздкий и трудный для понимания для человека, не имеющего опыта, либо иметь множество проблем с заголовочными файлами при сборке проекта «с нуля». Разобравшись с IAR, мы впоследствии рассмотрим другие компиляторы.
Итак, для начала раздобудьте IAR. Он очень распространен и его нахождение не должно быть проблемой. Скачав где-либо IAR 3.20, устанавливаем компилятор / рабочую среду, и запускаем его. После этого можно начинать работу.
Запустив IAR, выбираем file / new / workspace , выбираем путь к нашему проекту и создаем для него папку и даем имя, например, «Prog1». Теперь создаем проект: Project / Create new project… Назовем его также – «Prog1». Щелкаем правой кнопкой мыши на заголовке проекта в дереве проектов и выбираем «Options»
Здесь будем настраивать компилятор под конкретный МК. Во-первых, нужно выбрать на вкладке Target тип процессора ATMega16, на вкладке Library Configuration установить галочку Enable bit definitions in I/O-include files (чтобы можно было использовать в коде программы имена битов различных регистров МК), там же выбрать тип библиотеки С/ЕС++. В категории ICCAVR нужно на вкладке Language установить галочку Enable multibyte support, а на вкладке Optimization выключить оптимизацию (иначе она испортит нашу первую программу).
Далее выбираем категорию XLINK. Здесь нужно определить формат откомпилированного файла. Поскольку сейчас мы задаем опции для режима отладки (Debug), о чем написано в заголовке, то на выходе нужно получить отладочный файл. Позже мы его откроем в AVR Studio. Для этого нужно выбрать расширение.cof, а тип файла – ubrof 7.
Теперь нажимаем ОК, после чего меняем Debug на Release.
Снова заходим в Options, где все параметры, кроме XLINK, выставляем те же. В XLINK меняем расширение на.hex, а формат файла на intel-standart.
Вот и все. Теперь можно приступать к написанию первой программы. Создаем новый Source/text и набираем в нем следующий код:
#include "iom16.h" short unsigned int i; void main (void ) { DDRB = 255; PORTB = 0; while (1) { if (PORTB == 255) PORTB = 0; else PORTB++; for (i=0; iФайл «iom16.h» находится в папке (C:\Program Files)\IAR Systems\Embedded Workbench 3.2\avr\inc . Если вы используете другой МК, например, ATMega64, то выбирайте файл «iom64.h». В этих заголовочных файлах хранится информация о МК: имена регистров, битов в регистрах, определены имена прерываний. Каждая отдельная «ножка» порта A, B, C или D может работать либо как вход, либо как выход. Это определяется регистрами Data Direction Register (DDR). 1 делает «ножку» выходом, 0 – входом. Таким образом, выставив, например, DDRA = 13, мы делаем выходами «ножки» PB0, PB2, PB3, остальные – входы, т.к. 13 в двоичном коде будет 00001101.
PORTB – это регистр, в котором определяется состояние «ножек» порта. Записав туда 0, мы выставляем на всех выходах напряжение 0 В. Далее идет бесконечный цикл. При программировании МК всегда делают бесконечный цикл, в котором МК выполняет какое-либо действие, пока его не сбросят или пока не произойдет прерывание. В этом цикле пишут как бы «фоновый код», который МК выполняет в самую последнюю очередь. Это может быть, например, вывод информации на дисплей. В нашем же случае увеличивается содержимое регистра PORTB до тех пор, пока он не заполнится. После этого все начинается сначала. Наконец, цикл for на десять тысяч тактов. Он нужен для формирования видимой задержки в переключении состояния порта В.
Теперь сохраняем этот файл в папке с проектом как Prog1.c, копируем в папку с проектом файл iom16.h, выбираем Project/Add Files и добавляем «iom16.h» и «Prog1.c». Выбираем Release, нажимаем F7, программа компилируется и должно появиться сообщение:
| Total number of errors: 0 |
| Total number of warnings: 0 |
Приведу фотографию своего программатора:
Скачиваем программатор AVReal. Копируем его (AVReal32.exe) в папку Release/exe, где должен лежать файл Prog1.hex. Подаем питание на МК, подключаем кабель-программатор. Открываем Far Manager (в нем наиболее удобно прошивать МК), заходим в эту папку, нажимаем Ctrl+O. Поскольку у нас совершенно новый МК, то набиваем
avreal32.exe +MEGA16 -o11.0592MHZ -p1 -fblev=0,jtagen=1,cksel=F,sut=1 –w
Не забудьте правильно указать частоту, если используете не 11059200 Гц! При этом в МК прошиваются т.н. fuses – регистры, управляющие его работой (использование внутреннего генератора, Jtag и т.п.). После этого он готов к приему первой программы. Программатору в качестве параметров передают используемый LPT-порт, частоту, имя файла и другие (все они перечислены в описании к AVReal). Набираем:
Avreal32.exe +Mega16 -o11.0592MHz -p1 -e -w -az -% Prog1.hex
В случае правильного подключения программатор сообщит об успешном программировании. Нет гарантии, что это получится с первого раза (при первом вызове программы). У меня самого бывает программируется со второго раза. Возможно, LPT-порт глючный или возникают наводки в кабеле. При возникновении проблем тщательно проверьте свой кабель. По своему опыту знаю, что 60% неисправностей связаны с отсутствием контакта в нужном месте, 20% - с наличием в ненужном и еще 15% - с ошибочной пайкой не того не к тому. Если ничего не получится, читайте описание к программатору, попробуйте собрать Byte Blaster.
Предположим, у вас все работает. Если теперь подключить к порту В МК восемь светодиодов (делайте это в выключенном состоянии МК, и желательно последовательно со светодиодами включить резисторы в 300-400 Ом) и подать питание, то произойдет маленькое чудо – по ним побежит «волна»!
© Киселев Роман
Май 2007
Здравствуйте, уважаемые Хабражители!
В этой статье я хочу рассказать о том, как однажды решил начать программировать микроконтроллеры, что для этого понадобилось и что в итоге получилось.
Тема микроконтроллеров меня заинтересовала очень давно, году этак в 2001. Но тогда достать программатор по месту жительства оказалось проблематично, а о покупке через Интернет и речи не было. Пришлось отложить это дело до лучших времен. И вот, в один прекрасный день я обнаружил, что лучшие времена пришли не выходя из дома можно купить все, что мне было нужно. Решил попробовать. Итак, что нам понадобится:
1. Программатор
На рынке предлагается много вариантов - от самых дешевых ISP (In-System Programming) программаторов за несколько долларов, до мощных программаторов-отладчиков за пару сотен. Не имея большого опыта в этом деле, для начала я решил попробовать один из самых простых и дешевых - USBasp. Купил в свое время на eBay за $12, сейчас можно найти даже за $3-4. На самом деле это китайская версия программатора от Thomas Fischl . Что могу сказать про него? Только одно - он работает. К тому же поддерживает достаточно много AVR контроллеров серий ATmega и ATtiny. Под Linux не требует драйвера.
Для прошивки надо соединить выходы программатора VCC, GND, RESET, SCK, MOSI, MISO с соответствующими выходами микроконтроллера. Для простоты я собрал вспомогательную схему прямо на макетной плате:
Слева на плате - тот самый микроконтроллер, который мы собираемся прошивать.
2. Микроконтроллер
С выбором микроконтроллера я особо не заморачивался и взял ATmega8 от Atmel - 23 пина ввода/вывода, два 8-битных таймера, один 16-битный, частота - до 16 Мгц, маленькое потребление (1-3.6 мА), дешевый ($2). В общем, для начала - более чем достаточно.
Под Linux для компиляции и загрузки прошивки на контроллер отлично работает связка avr-gcc + avrdude. Установка тривиальная. Следуя инструкции , можно за несколько минут установить все необходимое ПО. Единственный ньюанс, на который следует обратить внимание - avrdude (ПО для записи на контроллер) может потребовать права супер-пользователя для доступа к программатору. Выход - запустить через sudo (не очень хорошая идея), либо прописать специальные udev права. Синтаксис может отличаться в разных версиях ОС, но в моем случае (Linux Mint 15) сработало добавление следующего правила в файл /etc/udev/rules.d/41-atmega.rules:
# USBasp programmer SUBSYSTEM=="usb", ATTR{idVendor}=="16c0", ATTR{idProduct}=="05dc", GROUP="plugdev", MODE="0666"
После этого, естественно, необходим перезапуск сервиса
service udev restart
Компилировать и прошивать без проблем можно прямо из командной строки (кто бы сомневался), но если проектов много, то удобнее поставить плагин и делать все прямо из среды Eclipse.
Под Windows придется поставить драйвер. В остальном проблем нет. Ради научного интереса попробовал связку AVR Studio + eXtreme Burner в Windows. Опять-таки, все работает на ура.
Начинаем программировать
Программировать AVR контроллеры можно как на ассемблере (AVR assembler), так и на Си. Тут, думаю, каждый должен сделать свой выбор сам в зависимости от конкретной задачи и своих предпочтений. Лично я в первую очередь начал ковырять ассемблер. При программировании на ассемблере архитектура устройства становится понятнее и появляется ощущение, что копаешься непосредственно во внутренностях контроллера. К тому же полагаю, что в особенно критических по размеру и производительности программах знание ассемблера может очень пригодиться. После ознакомления с AVR ассемблером я переполз на Си.После знакомства с архитектурой и основными принципами, решил собрать что-то полезное и интересное. Тут мне помогла дочурка, она занимается шахматами и в один прекрасный вечер заявила, что хочет иметь часы-таймер для партий на время. БАЦ! Вот она - идея первого проекта! Можно было конечно заказать их на том же eBay, но захотелось сделать свои собственные часы, с блэк… эээ… с индикаторами и кнопочками. Сказано - сделано!
В качестве дисплея решено было использовать два 7-сегментных диодных индикатора. Для управления достаточно было 5 кнопок - “Игрок 1” , “Игрок 2” , “Сброс” , “Настройка” и “Пауза” . Ну и не забываем про звуковую индикацию окончания игры. Вроде все. На рисунке ниже представлена общая схема подключения микроконтроллера к индикаторам и кнопкам. Она понадобится нам при разборе исходного кода программы:
Разбор полета
Начнем, как и положено, с точки входа программы - функции main . На самом деле ничего примечательного в ней нет - настройка портов, инициализация данных и бесконечный цикл обработки нажатий кнопок. Ну и вызов sei() - разрешение обработки прерываний, о них немного позже.Int main(void)
{
init_io();
init_data();
sound_off();
sei();
while(1)
{
handle_buttons();
}
return 0;
}
Рассмотрим каждую функцию в отдельности.
Void init_io()
{
// set output
DDRB = 0xFF;
DDRD = 0xFF;
// set input
DDRC = 0b11100000;
// pull-up resistors
PORTC |= 0b00011111;
// timer interrupts
TIMSK = (1< Настройка портов ввода/вывода происходит очень просто - в регистр DDRx (где x - буква, обозначающая порт) записивается число, каждый бит которого означает, будет ли соответствующий пин устройством ввода (соответствует 0) либо вывода (соответствует 1). Таким образом, заслав в DDRB и DDRD число 0xFF, мы сделали B и D портами вывода. Соответственно, команда DDRC = 0b11100000; превращает первые 5 пинов порта C во входные пины, а оставшиеся - в выходные. Команда PORTC |= 0b00011111; включает внутренние подтягивающие резисторы на 5 входах контроллера. Согласно схеме, к этим входам подключены кнопки, которые при нажатии замкнут их на землю. Таким образом контроллер понимает, что кнопка нажата. Далее следует настройка двух таймеров, Timer0 и Timer1. Первый мы используем для обновления индикаторов, а второй - для обратного отсчета времени, предварительно настроив его на срабатывание каждую секунду. Подробное описание всех констант и метода настройки таймера на определенноый интервал можно найти в документации к ATmega8. Обработка прерываний
ISR (TIMER0_OVF_vect)
{
display();
if (_buzzer > 0)
{
_buzzer--;
if (_buzzer == 0)
sound_off();
}
}
ISR(TIMER1_COMPA_vect)
{
if (ActiveTimer == 1 && Timer1 > 0)
{
Timer1--;
if (Timer1 == 0)
process_timeoff();
}
if (ActiveTimer == 2 && Timer2 > 0)
{
Timer2--;
if (Timer2 == 0)
process_timeoff();
}
}
При срабатывании таймера управление передается соответствующему обработчику прерывания. В нашем случае это обработчик TIMER0_OVF_vect, который вызывает процедуру вывода времени на индикаторы, и TIMER1_COMPA_vect, который обрабатывает обратный отсчет. Вывод на индикаторы
Void display()
{
display_number((Timer1/60)/10, 0b00001000);
_delay_ms(0.25);
display_number((Timer1/60)%10, 0b00000100);
_delay_ms(0.25);
display_number((Timer1%60)/10, 0b00000010);
_delay_ms(0.25);
display_number((Timer1%60)%10, 0b00000001);
_delay_ms(0.25);
display_number((Timer2/60)/10, 0b10000000);
_delay_ms(0.25);
display_number((Timer2/60)%10, 0b01000000);
_delay_ms(0.25);
display_number((Timer2%60)/10, 0b00100000);
_delay_ms(0.25);
display_number((Timer2%60)%10, 0b00010000);
_delay_ms(0.25);
PORTD = 0;
}
void display_number(int number, int mask)
{
PORTB = number_mask(number);
PORTD = mask;
}
Функция display использует метод динамической индикации. Дело в том, что каждый отдельно взятый индикатор имеет 9 контактов (7 для управления сегментами, 1 для точки и 1 для питания). Для управления 4 цифрами понадобилось бы 36 контактов. Слишком расточительно. Поэтому вывод разрядов на индикатор с несколькими цифрами организован по следующему принципу: Напряжение поочередно подается на каждый из общих контактов, что позволяет высветить на соответствующем индикаторе нужную цифру при помощи одних и тех же 8 управляющих контактов. При достаточно высокой частоте вывода это выглядит для глаза как статическая картинка. Именно поэтому все 8 питающих контактов обоих индикаторов на схеме подключены к 8 выходам порта D, а 16 управляющих сегментами контактов соединены попарно и подключены к 8 выходам порта B. Таким образом, функция display с задержкой в 0.25 мс попеременно выводит нужную цифру на каждый из индикаторов. Под конец отключаются все выходы, подающие напряжение на индикаторы (команда PORTD = 0;). Если этого не сделать, то последняя выводимая цифра будет продолжать гореть до следующего вызова функции display, что приведет к ее более яркому свечению по сравнению с остальными. Обработка нажатий
Void handle_buttons()
{
handle_button(KEY_SETUP);
handle_button(KEY_RESET);
handle_button(KEY_PAUSE);
handle_button(KEY_PLAYER1);
handle_button(KEY_PLAYER2);
}
void handle_button(int key)
{
int bit;
switch (key)
{
case KEY_SETUP: bit = SETUP_BIT; break;
case KEY_RESET: bit = RESET_BIT; break;
case KEY_PAUSE: bit = PAUSE_BIT; break;
case KEY_PLAYER1: bit = PLAYER1_BIT; break;
case KEY_PLAYER2: bit = PLAYER2_BIT; break;
default: return;
}
if (bit_is_clear(BUTTON_PIN, bit))
{
if (_pressed == 0)
{
_delay_ms(DEBOUNCE_TIME);
if (bit_is_clear(BUTTON_PIN, bit))
{
_pressed |= key;
// key action
switch (key)
{
case KEY_SETUP: process_setup(); break;
case KEY_RESET: process_reset(); break;
case KEY_PAUSE: process_pause(); break;
case KEY_PLAYER1: process_player1(); break;
case KEY_PLAYER2: process_player2(); break;
}
sound_on(15);
}
}
}
else
{
_pressed &= ~key;
}
}
Эта функция по очереди опрашивает все 5 кнопок и обрабатывает нажатие, если таковое случилось. Нажатие регистрируется проверкой bit_is_clear(BUTTON_PIN, bit) , т.е. кнопка нажата в том случае, если соответствующий ей вход соединен с землей, что и произойдет, согласно схеме, при нажатии кнопки. Задержка длительностью DEBOUNCE_TIME и повторная проверка нужна во избежание множественных лишних срабатываний из-за дребезга контактов. Сохранение статуса нажатия в соответствующих битах переменной _pressed используется для исключения повторного срабатывания при длительном нажатии на кнопку. Полный текст программы
#define F_CPU 4000000UL
#include Прототип был собран на макетной плате. Всем привет. Как и обещал, с сегодняшнего дня начинаем изучать программирования AVR микроконтроллеров (на примере Atmega8). Тем же читателям, которым интересно программирование платы ардуино, не волнуйтесь, статьи по данному направлению будут продолжаться 🙂 .
Можно задать логичный вопрос, почему из ряда других микроконтроллеров (далее — МК) в качестве подопытного выбран именно МК AVR
. На это есть несколько причин: Как говорил ранее, в качестве подопытного будем использовать МК Atmega8
. Почему именно его? Данный микроконтроллер может похвастаться наличием 3 портов ввода/вывода. Кроме этого он довольно дешевый. Под портами, понимают шины данных, которые могут работают в двух противоположных направлениях (то бишь на вывод и на ввод). У Atmega8
3 порта. Порт B состоит из 8 ножек-выводов (нумерация 0,1,2,3,4,5,6,7). Порт С состоит из 7 ножек-выводов (нумерация 0,1,2,3,4,5,6). Порт D состоит из 8 ножек-выводов (нумерация 0,1,2,3,4,5,6,7). Запитывать микроконтроллер можно от 3,3 и 5 В. При напряжении питания 5 В максимальная частота тактирования составляет 16 МГц, а при напряжении питания 3,3 В – максимальная частота тактирования 8 МГц. Пока не будем заморачиваться относительно частот тактирования. Питания подаётся на 7 ножку-вывод, а «земля» подводится к 8 ножке. Скачивается бесплатно. Скачали, установили, запустили 🙂 Первое, с чего следует начать знакомство с Atmel Studio – это создание проекта. Выбираем File -> new -> project . Откроется окно выбора. Выбираем папку «Browse», в которой будем сохранять написанные проекты. Папку для проектов создал заранее. Присваиваем имя проекту, в моём случае lesson_avr_1 Обратите внимание на галочку «create directory for solution». Если отметка стоит, то в той папке, которую мы выбрали для сохранения проектов, будет создана отдельная папка под текущий проект. На этом всё – проект создан. Займемся настройкой созданного нами проекта. Нажимаем Projest -> lesson_avr_1 properties или (alt+F7) Переходим на вкладку Tool. Выбираем – симулятор. Совершенные нами действия сделают возможным отлаживать написанный код. Сохраняем изменения. Можно сохранить изменения в одном (текущем) файле или же во всех файлах проекта сразу. Закрываем настройки.
Функции обработки нажатий достаточно тривиальны и полагаю, что в дополнительных комментариях не нуждаются. 
