Первые  шаги.

файлы к статье (размер: 160 КБ)

Данные статьи посвящены программированию микроконтроллеров AVR фирмы Atmel на языках С и С++. AVR – это, пожалуй, самое распространенное семейство микроконтроллеров.

Итак, что вообще такое микроконтроллер (далее МК)? Это, условно говоря, маленький компьютер, размещенный в одной интегральной микросхеме. У него есть процессор (арифметическо-логическое устройство, или АЛУ), 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 В. От нее МК нужно питать напрямую.

PROTEUS скачать свежий стабильный с лекарством и с инструкцией по установке.

Ниже приведу схему подключения МК:

Давайте теперь разберемся, что здесь для чего.

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

Приведу фотографию своего программатора:

Скачиваем программатор 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 Ом) и подать питание, то произойдет маленькое чудо – по ним побежит «волна»!

Таймеры, кнопки и прерывания.

Файлы к статье (размер: 62.2 КБ)

В этой статье будет рассмотрено использование таймеров в МК и способ подсоединения кнопок к нему.

Сначала немного теории.

В МК ATMega16 есть три таймера/счетчика – два 8-битных (Timer/Counter0, Timer/Counter2) и один 16-битный (Timer/Counter1). Каждый из них содержит специальные регистры, одним из которых является счетный регистр TCNTn (n – это число 0, 1 или 2). Каждый раз, когда процессор выполняет одну команду, содержимое этого регистра увеличивается на единицу (либо каждые 8, 64, 256 или 1024 тактов). Потому он и называется счетным. Помимо него, есть еще и регистр сравнения OCRn (Output Compare Register), в который мы можем сами записать какое-либо число. У 8-битного счетчика эти регистры 8-битные. По мере выполнения программы содержимое TCNTn растет и в какой-то момент оно совпадет с содержимым OCRn. Тогда (если заданы специальные параметры) в регистре флагов прерываний TIFR (Timer/Counter Interrupt Flag Register) один из битов становится равен единице и процессор, видя запрос на прерывание, сразу же отрывается от выполнения бесконечного цикла и идет обслуживать прерывание таймера. После этого процесс повторяется.

Ниже представлена временная диаграмма режима CTC (Clear Timer on Compare). В этом режиме счетный регистр очищается в момент совпадения содержимого TCNTn и OCRn, соответственно меняется и период вызова прерывания.

Это далеко не единственных режим работы таймера/счетчика. Можно не очищать счетный регистр в момент совпадения, тогда это будет режим генерации широтно-импульсной модуляции, который мы рассмотрим в следующей статье. Можно менять направление счета, т. е. содержимое счетного регистра будет уменьшаться по мере выполнения программы. Также возможно производить счет не по количеству выполненных процессором команд, а по количеству изменений уровня напряжения на «ножке» T0 или T1 (режим счетчика), можно автоматически, без участия процессора, менять состояние ножек OCn в зависимости от состояния таймера. Таймер/Счетчик1 умеет производить сравнение сразу по двум каналам – А или В.

Далее представлена функциональная схема таймера/счетчика0:

Для запуска таймера нужно выставить соответствующие биты в регистре управления таймером TCCRn (Timer/Counter Control Register), после чего он сразу же начинает свою работу.

Мы рассмотрим лишь некоторые режимы работы таймера. Если вам потребуется работа в другом режиме, то читайте Datasheet к ATMega16 – там все подробнейше по-английски написано, даны даже примеры программ на С и ассемблере (недаром же он занимает 357 страниц печатного текста!).

Теперь займемся кнопками.

Если мы собираемся использовать небольшое количество кнопок (до 9 штук), то подключать их следует между «землей» и выводами какого-либо порта микроконтроллера. При этом следует сделать эти выводы входами, для чего установить соответствующие биты в регистре DDRx и включить внутренний подтягивающий резистор установкой битов в регистре PORTx. При этом на данных «ножках» окажется напряжение 5 В. При нажатии кнопки вход МК замыкается на GND и напряжение на нем падает до нуля (а может быть и наоборот – вывод МК замкнут на землю в отжатом состоянии). При этом меняется регистр PINx, в котором хранится текущее состояние порта (в отличие от PORTx, в котором установлено состояние порта при отсутствии нагрузки, т. е. до нажатия каких-либо кнопок). Считывая периодически состояние PINx, можно определить, что нажата кнопка.

ВНИМАНИЕ! Если соответствующий бит в регистре DDRx будет установлен в 1 для вашей кнопки, то хорошее нажатие на кнопку может привести к небольшому пиротехническому эффекту – возникновению дыма вокруг МК. Естественно, МК после этого придется отправить в мусорное ведро…

Перейдем к практической части. Создайте в IAR новое рабочее пространство и новый проект с именем, например, TimerButton. Установите опции проекта так, как это описано в предыдущей статье. А теперь наберем следующий небольшой код.

#include "iom16.h"



void init_timer0(void)	//Инициализация таймера/счетчика0

{

  OCR0 = 255;           //Содержимое регистра сравнения



  //Задаем режим работы таймера

  TCCR0 = (1 << WGM01) | (1 << COM00) | (1 << CS02) | (1 << CS00); 

}



void init_timer2(void)  //Инициализация таймера/счетчика2

{

  OCR2 = 255;

  TCCR2 = (1 << WGM21) | (1 << CS22) | (1 << CS21) | (1 << CS20);

  TIMSK |= (1 << OCIE2);  //Устанавливаем для него прерывание совпадения

}



void main (void)

{

  DDRB = 255;

  init_timer0();

  init_timer2();

  while(1)

  {

  }

}



#pragma vector = TIMER2_COMP_vect  //Прерывание по таймеру2

__interrupt void flashing()

{

  if ((PORTB & 3) == 1)

  {

    PORTB &= (0xFF << 2);       // Отключение выводов PB0, PB1

    PORTB |= 2;	                // Включение PB1

  }

  else

  {

    PORTB &= (0xFF << 2);	// Отключение выводов PB0, PB1

    PORTB |= 1; 		// Включение PB0

  }

}

Давайте посмотрим, как это работает. В функциях init_timern задаются биты в регистрах TCCRn, OCRn и TIMSK, причем такой способ может кому-нибудь показаться странным или незнакомым. Придется объяснить сначала, что означает запись «(1 << WGM01)». << - это оператор сдвига битов, который имеет следующий синтаксис:

C = (a << b), вернее a << b

где a – это то число, двоичное представление которого нужно сдвинуть, а b показывает, на сколько битов нужно его сдвинуть. При этом возможна потеря значения, хранящегося в a (т.е. не всегда возможно восстановить из С то, что было в а). Рассмотрим пример:

Что окажется в С после выполнения строки C = (22 << 3);?

2 в двоичном коде будет выглядеть как 00010110, а после сдвига влево на 3 бита получим С = 10110000.

Аналогично существует и сдвиг вправо. Еще пример:

char C;

…

C = ((0xFF << 2) >> 2);

Сначала выполнится действие во внутренних скобках (0xFF – это 255 в шестнадцатеричном коде), из 11111111 получится 11111100, потом произойдет сдвиг вправо и получим С = 00111111. Как видим, здесь две взаимно обратные операции привели к другому числу, т. к. мы потеряли два бита. Этого не произошло бы, если бы переменная С была типа int, т. к. int занимает 16 бит.

Теперь рассмотрим еще два битовых оператора, широко применяющиеся при программировании МК. Это оператор «побитовое и» (&) и «побитовое или» ( | ). Как они действуют, думаю, будет понятно из примеров:

Действие:				Результат (в двоичном коде):



С = 0;					// C = 00000000

C = (1 << 5) | (1 << 2) | (1 << 0);	// C = 00100101

C |= (1 << 3);				// C = 00101101

C &= (0xF0 >> 2);			// C = 00101100

C = (C & 4) | 3;			// C = 00000111

Чуть не забыл! Есть еще «побитовое исключающее или» ( ^ ). Оно сравнивает соответствующие биты в числе, и, если они одинаковые, возвращает 0, иначе единицу.

Вернемся к нашей программе. Там написано «(1 << WGM01)». WGM01 – это число? – спросите вы. Да, если заглянуть в файл iom16.h, то там можно будет найти следующее:

/* Timer/Counter 0 Control Register */

#define    FOC0	7

#define    WGM00	6

#define    COM01	5

#define    COM00	4

#define    WGM01	3

#define    CS02	2

#define    CS01	1

#define    CS00	0

При компиляции программы запись WGM01 просто заменяется на число 3, и в результате получается уже корректная запись. WGM01 называется макросом и он, в отличие от переменной, не занимает места в памяти (разве что в памяти программиста:-).

Если заглянуть теперь в Datasheet, но нетрудно будет увидеть, что WGM01 – это имя третьего бита в регистре TCCR0. То же самое касается и остальных битов этого регистра. Это совпадение не случайно и относится ко всем регистрам МК (или почти ко всем). Т. е., написав «(1 << WGM01)», мы установили этот бит в единицу и включили режим СТС, что видно из таблицы из Datasheetа:

Итого, строчка

TCCR0 = (1 << WGM01) | (1 << COM00) | (1 << CS02) | (1 << CS00);

означает, что включен режим СТС, при срабатывании таймера0 меняется состояние «ножки» ОС0 (Она же PB3), содержимое счетчика увеличивается каждые 1024 такта.

Аналогично для таймера2: TCCR2 = (1 << WGM21) | (1 << CS22) | (1 << CS21) | (1 << CS20); Режим СТС, каждые 1024 такта.

В регистре TIMSK (Timer/counter Interrupt MaSK register) задается режим прерываний. Мы написали

TIMSK |= (1 << OCIE2);

что означает прерывание таймера2 по совпадении TCNT2 и OCR2. Самая последняя функция – это собственно функция прерывания совпадения таймера2. Прерывания объявляются следующим образом:

#pragma vector = ВЕКТОР

__interrupt ТИП ИМЯ()

где ВЕКТОР – это макрос вектора прерывания (по смыслу просто число, характеризующее это прерывание); эти макросы в порядке снижения приоритета перечислены в файле iom16.h. ТИП – тип возвращаемого функцией значения, в нашем случае void (ничего). ИМЯ – произвольное имя для этой функции. С прерываниями мы еще успеем наработаться в будущем.

При выполнении нашей функции должны по очереди моргать светодиоды, подключенные к PB0 и PB1. Судя по всему, частота равна 11059200/(256*1024) = 42 Гц. Это быстро, но будет заметно невооруженным глазом. Кстати, применение таймеров дает возможность отсчитывать точные временные интервалы, не зависящие от сложности вашей программы и порядка ее выполнения (но если у Вас не более одного прерывания).

Итак, сохраняем файл как «TimerDebug.c», добавляем его в проект, компилируем, прошиваем МК. Что же мы видим? Светодиод, подключенный к выводу PB3, будет активно моргать, а на PB0 и PB1 нет ни каких изменений. В чем же дело? Неужели что-то неверно?

Чтобы это выяснить, придется отладить нашу программу. Поскольку в IAR нет Debuggerа, придется использовать AVR Studio. Эту среду разработки можно скачать с сайта производителя http://atmel.com. Проблем с ее установкой, думаю, не должно быть. Перед запуском AVR Studio выберите в IAR режим Debug и создайте отладочный cof-файл (все опции проекта должны быть выставлены, как описано в предыдущей статье).

Открыв AVR Studio, мы увидим окно приветствия, в котором выберем «Open». Теперь лезем в папку с проектом, там в Debug\Exe, выбираем там «TimerDebug.cof», создаем проект там, где предложат, выбираем дивайс ATMega16 и режим отладки Simulator. После этого, если все сделали правильно, сразу же идет процесс отладки

Среда отладки здесь очень удобная, т.к. позволяет просматривать содержимое всех регистров МК, а также вручную устанавливать значения для них щелчками мыши. Например, если установить флаг прерывания в регистре TIFR в бите 7 (под черным квадратом в TIMSK), то следующим шагом программы (нажатие F10 или F11) должна быть обработка прерывания (флаг будет установлен автоматически и при совпадении регистров TCNT2 и OCR2). Но, к нашему удивлению, прерывания не будет!

Возникает вопрос: почему?

Откроем регистр CPU, SREG. Этот регистр определяет работу процессора, а конкретно седьмой его бит (I-бит, Interrupt bit) ответственен за обработку всех прерываний в МК. У нас он не установлен. Стоит его выставить, как сразу же пойдет выполняться прерывание (если одновременно установлен седьмой бит в TIFR).

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

Значит, нужно добавить строчку кода для установки этого бита в единичное состояние. Добавим мы его в функцию init_timer2. Получится следующее:

void init_timer2(void)

{

  SREG |= (1 << 7);  //Добавили эту строчку

  OCR2 = 255;

  TCCR2 = (1 << WGM21) | (1 << CS22) | (1 << CS21) | (1 << CS20);

  TIMSK |= (1 << OCIE2);

}

Теперь, выбрав конфигурацию Release и прошив МК нажатием F7 и запуском AVReal32.exe, с радостью увидим, что все работает как надо.

Замечание: при отладке программы следует уменьшать интервалы таймеров, если они слишком длинные, т. к. в процессе отладки в AVR Studio программа выполняется в тысячи раз медленнее, чем внутри МК и вы не дождетесь срабатывания таймера. В целом отладка полностью аналогична таковой в других системах программирования, таких, как Visual C++.

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

#include "iom16.h"



long unsigned int counter = 0;  //Счетчик для формирования временных интервалов

unsigned char B0Pressed = 0;  //Здесь хранится состояние кнопки0 (0 - не нажата, 1 - нажата)

unsigned char B1Pressed = 0;  //Здесь хранится состояние кнопки1 (0 - не нажата, 1 - нажата)



//Инициализация таймера2

//Нужно каждые 11059 такта (1 мс) увеличивать counter. У нас получается каждые 1,001175 мс

void init_timer2()

{

  OCR2 = 173;

  TCCR2 = (1 << WGM21) | (1 << CS22);

  TIMSK = (1 << 7);

}



//Инициализация портов ввода/вывода

init_io_ports()

{

  DDRA =(1<< DDA0)|(1<< DDA1)|(1<< DDA2)|(1<< DDA3)|(1<< DDA4)|(1<< DDA5)|(1<< DDA6)|(1<< DDA7);

  DDRB =(1<< DDB0)|(1<< DDB1)|(1<< DDB2)|(1<< DDB3)|(1<< DDB4)|(1<< DDB5)|(1<< DDB6)|(1<< DDB7);

  DDRC =(0<< DDC0)|(0<< DDC1)|(1<< DDC2)|(1<< DDC3)|(1<< DDC4)|(1<< DDC5)|(1<< DDC6)|(1<< DDC7);

  DDRD =(1<< DDD0)|(1<< DDD1)|(1<< DDD2)|(1<< DDD3)|(1<< DDD4)|(1<< DDD5)|(1<< DDD6)|(1<< DDD7);

  

  PORTA =(0<< PA0)|(0<< PA1)|(0<< PA2)|(0<< PA3)|(0<< PA4)|(0<< PA5)|(0<< PA6)|(0<< PA7);

  PORTB =(0<< PB0)|(0<< PB1)|(0<< PB2)|(0<< PB3)|(0<< PB4)|(0<< PB5)|(0<< PB6)|(0<< PB7);

  PORTC =(1<< PC0)|(1<< PC1)|(0<< PC2)|(0<< PC3)|(0<< PC4)|(0<< PC5)|(0<< PC6)|(0<< PC7);

  PORTD =(0<< PD0)|(0<< PD1)|(0<< PD2)|(0<< PD3)|(0<< PD4)|(0<< PD5)|(0<< PD6)|(0<< PD7);

}



//формирование задержки в Pause_ms миллисекунд

void delay(long unsigned int Pause_ms)

{

  counter = 0;

  while (counter < Pause_ms)

  {}

}



void main()

{

  SREG |= (1 << 7); //Разрешаем прерывания

  init_timer2();  //Включаем таймер2 на каждые 64 такта, считать до 173

  init_io_ports();  //Включаем порты ввода/вывода

  while(1)

  {

    //Обработка кнопки 0  

    if (B0Pressed == 1) //Если произошло нажатие на кнопку, 

    {                   // уведичивает PORTB, ждет отпускания

      PORTB++;

      B0Pressed = 0;

      while ((PINC & (1 << PC0)) == 1)

      {}

    }

    else

    {

      if ((PINC & (1 << PC0)) == 1)      //Фиксирует нажатие

      {

        delay(50);        //Устранение "дребезга клавиш"

        if ((PINC & (1 << PC0)) == 1)    //Проверяет нажатие

        {

          B0Pressed = 1;  //Устанавливает флаг "кнопка нажата"

        }

      }    

    }

    //Обработка кнопки 1

    if (B1Pressed == 1)  //Если произошло нажатие на кнопку, 

    {                     // уменьшает PORTB, ждет отпускания

      PORTB--;

      B1Pressed = 0;

      while ((PINC & (1 << PC1)) == 2)

      {}

    }

    else

    {

      if ((PINC & (1 << PC1)) == 2)      //Фиксирует нажатие

      {

        delay(200);        //Устранение "дребезга клавиш"

        if ((PINC & (1 << PC1)) == 2)    //Проверяет нажатие

        {

          B1Pressed = 1;  //Устанавливает флаг "кнопка нажата"

        }

      }    

    }

  }

}



//Прерывание по таймеру 2, прн этом увеличение счетчика counter

#pragma vector = TIMER2_COMP_vect

__interrupt void inc_delay_counter()

{

  counter++;

}

Сначала предлагаю взять уже готовый файл прошивки (файлы к статье, папка Release, файл TimerButton.hex или откомпилировать этот текст) и записать его в МК. После чего вынуть кабель прошивки, подключить к PC0 и PC1 кнопки и попробовать их понажимать. Увидим, что при нажатии на одну из кнопок увеличивается регистр PORTB (загораются светодиоды), а при нажатии на другую – уменьшается. Если не работает – попробуйте понажимать одну кнопку, удерживая другую – будет действовать. Дело в том, что я подключал кнопки следующим образом: при нажатии на кнопку вывод МК «болтается» в воздухе, а при отпускании замыкается на землю. Если вы подключили кнопки по-другому, то придется лишь чуть модернизировать программу.

Давайте разберемся с кодом. Здесь работа с таймером организована несколько иначе. Он срабатывает каждые 11072 такта (то есть каждые 1,001175 мс) и увеличивает содержимое переменной counter. Есть еще функция delay(long unsigned int Pause_ms), которая берет в качестве параметра количество миллисекунд Pause_ms, сбрасывает counter и ждет, когда counter достигнет значения Pause_ms, после чего продолжает работу МК. Таким образом, написав delay(1500), мы сформируем задержку в программе в 1,5 секунды. Это очень удобно для формирования временных интервалов.

С таймером вроде все понятно. Но для чего он используется? Рассмотрим бесконечный цикл while(1) в main(). В этом цикле проверяется состояние кнопок путем анализа содержимого регистра PINB. А зачем там стоит задержка на 50 мс? Это устранение т. н. «дребезга клавиш». Дело в том, что при нажатии на кнопку происходит удар одного контакта о другой, и, поскольку контакты металлические, удар этот упругий. Контакты, пружиня, замыкаются и размыкаются несколько раз, несмотря на то, что палец сделал лишь одно нажатие. Это приводит к тому, что МК фиксирует несколько нажатий. Давайте рассмотрим график зависимости напряжения на выходе PC0 от времени. Он может выглядеть так:

Точка А – момент нажатия кнопки. Он может быть зафиксирован МК. Затем идут несколько замыканий и размыканий (их может и не быть, а может быть и 12 штук – это явление можно считать случайным). В точке B контакт уже надежно зафиксирован. Между A и B в среднем около 10 мс. Наконец, в точке D происходит размыкание. Как же избавиться от этого неприятного явления? Оказывается, очень просто. Нужно зафиксировать момент нажатия кнопки (точка А), через какое-то время, например, 50 мс (точка С) проверить, что кнопка действительно нажата, сделать действие, соответствующее этой кнопке и ждать момент ее отпускания (точка D). То есть нужно сделать паузу от А до С, такую, чтобы весь «дребезг» оказался внутри этой паузы. А попробуйте теперь убрать строчку, формирующую задержку, откомпилировать программу и зашить ее в МК. Путем простых нажиманий на кнопки сможете легко убедиться, что все эти «мучения» не были напрасными.

А что же делать, если к МК нужно подключить, скажем, 40 кнопок? Ведь у него всего лишь 32 вывода. Казалось бы, никак. На самом деле это возможно. В таком случае используют алгоритм, называемый стробированием. Для этого нужно кнопки соединить в виде матрицы, как это показано на рисунке (рисунок взят из книги Мортона «МК AVR, вводный курс», где написано про программирование AVR на ассемблере).

При подаче на вывод PB0 лог. 1 (+5В), а на выводы PB1 и PB2 лог. 0 разрешается обработка кнопок 1, 4 и 7. После этого состояние каждой из них можно узнать, проверив напряжение на одном из выводов PB3..PB5. Таким образом, подавая последовательно на выводы PB0..PB2 лог. 1, можно определить состояние всех кнопок. Понятное дело, что выводы PB0..PB2 должны быть выходами, а PB0..PB2 входами. Чтобы определить, какое количество выводов потребуется для массива из Х кнопок, нужно найти пару сомножителей Х, сумма которых наименьшая (для нашего случая с 40 кнопками это будут числа 5 и 8). Это означает, что к одному МК можно подключить до 256 кнопок (а с применение дешифраторов и того больше, но о дешифраторах потом). Лучше сделать меньшее число выводов выходами, а большее – входами. В этом случае опрос всех строк матрицы займет меньше времени. Подобный способ подключения (стробирование) свойственен не только для кнопок. Там можно подключать самые разнообразные устройства, начиная от матриц светодиодов и заканчивая микросхемами flash-памяти.

Использование ШИМ. Подключение полевых транзисторов.

Файлы к статье (размер: 103 КБ)

В этой статье мы рассмотрим вопросы регулировки мощности различных устройств, подключенных через полевой транзистор к МК с помощью широтно-импульсной модуляции (ШИМ)

Сначала немного теории. ШИМ - это широко используемый в электронике способ регулировки мощности самых разнообразных устройств. Где он только не нашел еще применения! Способ заключается в кратковременном включении устройства (на доли миллисекунд), а затем его отключении на некоторый момент времени. Такой цикл включений-выключений непрерывно повторяется. Рассмотрим диаграмму ниже.

На диаграмме показана зависимость напряжения на нагрузке от времени. Закрашенное серым - это область, когда управляемый с помощью ШИМ прибор был включен. Выделяемую энергию можно считать пропорциональной площади этой области. Отношение периода повторения импульсов (T) к их длительности (AC) называется скважностью. Величина, обратная скважности, называется коэффициентом заполнения. Судя по диаграмме, скважность наиболее велика в середине диаграммы. Значит, на этом участке на нагрузке выделялось наименьшее количество энергии в единицу времени. Надеюсь, с этим все понятно. Но возникает вопрос: а чем же так хороша ШИМ? Почему бы не использовать для регулировки мощности устройство, способное менять сопротивление (переменный резистор или транзистор)? Рассмотрим две, казалось бы, эквивалентные схемы.

Если менять сопротивление резистора, как показано на графике в центре, а на ключевой элемент правой схемы подавать ШИМ-последовательность, изображенную на диаграмме, то лампочки будут в любой момент времени светить одинаково (U_L - напряжение на лампочке). Но в правой схеме энергия будет выделяться только в лампочке, а в левой - и в лампочке, и в резисторе (или транзисторе, которым можно с успехом его заменить). Резистор будет разогреваться, и, возможно, не хуже лампочки. Поэтому на вопрос, какая схема рациональнее, я думаю, любой ответит, что правая. Она называется импульсной, а левая схема - линейной. Когда работают с мощной сильноточной электроникой, всегда отдают предпочтение именно импульсным элементам и способам. Линейные применяются лишь там, где управляют малыми мощностями и слабыми токами. К тому же, в цифровой электронике, где существуют лишь два состояния - "включено" и "выключено", ШИМ реализовать намного легче. Чем мы и займемся в этой статье.

Для этого нам понадобится совсем немного - полевой транзистор, который и будет работать у нас в качестве ключа (в ключевом режиме). Полевой транзистор предпочтительней потому, что его затвор изолирован от силовой схемы и управление производится электрическим полем, а ток управления достигает микроампер. Это позволяет, используя один-два транзистора, управлять с их помощью нагрузкой огромной мощности (до десятков ампер и десятков-сотен вольт), не нагружая МК. Замечательные мощные и недорогие (10 - 30 руб) транзисторы производит фирма International Rectifier. Они имеют название IRFxxxx, где xxxx - трех или четырехзначный номер. Я использовал в своей макетной плате IRF7311. Подойдут также и другие подобные ему: IRF7341, IRF7103 IRF7301, IRF7343, IRF7401, IRF7403, IRF7413... Эти транзисторы управляются логическим уровнем +5 В, т. е. нашего МК будет достаточно, чтобы полностью их открыть. Они, в свою очередь, могут управлять напряжением от 20 В (все) до 50 В (IRF7103, IRF7341) и через них можно будет открывать и закрывать более мощные транзисторы с достаточно высоким управляющим напряжением, например, IRF530. Таким образом, возможно собрать очень мощный быстродействующий каскад на полевых транзисторах, способный с помощью ШИМ плавно менять мощность на нагрузке, коммутируя токи в десятки ампер. Учитывая также тот факт, что полевые транзисторы можно соединять параллельно (в отличие от биполярных), возможно получить еще более мощный каскад на сотни ампер. Здесь все упирается уже лишь в финансы.

Итак, предположим, Вы решили купить IRF7311. Если открыть его Datasheet (есть в файлах к статье), то выясняется следующее: это махонькая микросхема в корпусе SO-8, внутри которой располагаются два полевых транзистора с индуцированным каналом N-типа и встроенными диодами Шоттки. Это означает, что для открывания транзистора надо подать на затвор G (Gate - "ворота, шлюз") управляющее напряжение +5 В по отношению к истоку S (Source - "источник"). Тогда, если было приложено коммутируемое напряжение "плюсом" к стоку D (Drain - "сток") и "минусом" к истоку, то потечет достаточно сильный ток (до 6 А) от D к S. Наличие диода Шоттки позволяет, не боясь ЭДС самоиндукции, применять эти транзисторы для управления электромоторами. Ниже приведу цоколевку транзистора и его внешний вид (сфотографировать его нереально, поэтому покажу чертеж)

Сверху на корпусе в углу должна быть точка, такая же, как на рисунке. Она стоит рядом с "ножкой" 1. Кстати, у всех микросхем "ножки" нумеруются начиная от подобной метки против часовой стрелки, если смотреть сверху - а то вдруг кто не знает... Если Вы купили полевой транзистор с P-каналом - ничего страшного. Тогда Вам придется подать "минус" на G (относительно S) для включения и поменять полярность нагрузки. То есть для любого полевого транзистора с индуцированным затвором нужно подавать ток против стрелочки, расположенной между затвором и диодом, а нагрузку подключать так, чтобы ток через нее тек в направлении, обратном встроенному диоду. Вот и все.

Прицепим теперь наш транзистор IRF7311 затвором к 21 "ножке" МК (PD7, OC2) и истоком к "земле". К его стоку подключим "плюс" внешнего источника питания (до 20 В), а между его "минусом" и истоком подключим нагрузку, например, лампочку или электромоторчик постоянного тока.

Когда я все собрал, получилось вот так (хоть проводов и не видно, но лампочка подключена):

Осталось только разобраться, как МК реализует ШИМ и написать программу. Как уже говорилось ранее, в нашем МК есть 3 таймера, и все они могут работать в ШИМ-режиме. Таймер1 является самым навороченным и может выводить ШИМ сразу на двух выводах МК. Но мы не будем вдаваться в ненужные нам пока подробности и сложности и рассмотрим работу с ШИМ на примере таймера2.

Существуют два режима работы таймера в качестве ШИМ-модулятора. Это Fast PWM (быстрая ШИМ) и Phase correct PWM (ШИМ с фазовой коррекцией). Рассмотрим оба режима на следующих диаграммах:

Режим работы определяется содержимым битов WGM (Waveform Generation Mode) в регистре TCCR2. В Datasheetе написано, что для ШИМ с фазовой коррекцией нужно установить в единицу WGM20, а для быстрой ШИМ WGM20 и WGM21. Чем же отличаются эти режимы? В быстром режиме меняется состояние "ножки" OC2 в моменты совпадения счетного регистра TCNT2 и регистра сравнения OCR2 (зеленая стрелка), а также в момент сброса таймера (синяя стрелка).При этом серединка импульса (оранжевая) как бы смещается влево, меняется фаза импульса. В режиме фазовой коррекции такого явления не наблюдается. В этом режиме таймер, досчитав до максимума (до 255), начинает счет в другую сторону. В моменты совпадения регистров TCNT2 и OCR2 меняется состояние ножки OC2. При этом серединка импульса никуда не смещается. Этот режим имеет в два раза меньшую частоту, чем быстрый, но изготовитель утверждает, что он лучше подходит для управления электромоторами (скорее всего, шаговыми). Быстрый режим можно использовать в любых других случаях. Все остальные таймеры работают в ШИМ-режиме аналогично, таймер1 позволяет также менять период ШИМ произвольным образом, но, думаю, нам это ни к чему.

С теорией вроде бы теперь все понятно. Откроем IAR, создадим новый проект, наберем следующий код:

#include "iom16.h"



unsigned char pwm = 1;

unsigned char inc = 1; // inc = 0 - уменьшать, inc = 1 - увеличивать яркость



void timer2_init()

{

  OCR2 = 1; //ШИМ почти выключена

  // Быстрая ШИМ, переключать OC2 (PD7), увеличение таймера каждые 64 такта

  TCCR2 |= (1 << WGM20) | ( 1 << WGM21) | (1 << COM21) | (1 << CS22);

}



void timer1_init()

{

  OCR1A = 43200; //Прерывание 32 раза в секунду

  TCCR1A = 0;

  // СТС режим, увеличение таймера каждые 8 тактов

  TCCR1B |= (1 << WGM12) | (1 << CS11);

  // Прерывание по совпадению А таймера1

  TIMSK |= (1 << OCIE1A);

  SREG |= (1 << 7); //Разрешить прерывания

}



void io_init() //Инициализация портов ввода-вывода

{

  DDRD = (1 << PD7);

  PORTD = 0;

}



void main ()

{

  timer2_init();

  timer1_init();

  io_init();

  while(1)

  {

  }

}



// Заставляет лампу плавно загораться и гаснуть раз в 8 секунд

#pragma vector = TIMER1_COMPA_vect 

__interrupt void PWM_change()

{

  if (inc == 1) 

  {

    if (pwm < 254)

    {

      pwm++;  // Увеличиваем яркость лампы, пока не достигнем максимума

      OCR2 = pwm;

    }

    else

    {

      inc = 0;

    }

  }

  else

  {

    if (pwm > 1)

    {

      pwm--;  // Уменьшаем яркость лампы, пока не остигнем минимума

      OCR2 = pwm;

    }

    else

    {

      inc = 1;

    }

  }

}

Функция timer2_init() используется нами для включения таймера в ШИМ-режиме. Таймер будет увеличивать счетный регистр каждые 64 такта, работать в режиме Fast PWM, меняя состояние ОС2 неинвертированным образом (биты СОМ20, СОМ21). Да, забыл сказать. Эти биты отвечают за поведение "ножки" ОС2, к которой подключен транзистор. Режим может быть инвертированным и неинвертированным. Чтобы это понять, посмотрите на диаграмму выше. Там приведен график состояния ОС2 (неинвертированный выход) и ОС2 с чертой (инвертированный выход). Если оба бита установлены в 1, то режим будет инвертированным. При работе с ШИМ и использовании транзисторов есть одна ловушка: не все транзисторы могут очень быстро менять свое состояние. Для одних могут потребоваться десятки-сотни наносекунд (как для нашего), для других - микросекунды и десятки микросекунд. Поэтому не советую, не изучив документацию на транзистор, использовать его на высокой частоте - большая нагрузка при высокой частоте ШИМ может его сжечь.

timer1_init() включает таймер2 и заставляет его делать 32 прерывания в секунду. Когда происходит прерывание, меняется OCR2 регистр и, соответственно, яркость лампы. Таким образом, лампа будет плавно загораться и плавно гаснуть раз в 8 секунд. Можно вместо таймера подключить кнопки и менять яркость при их нажатии. Но у нас для наглядности все будет происходить автоматически.

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

Выбираем Release, нажимаем F7, программа компилируется. Запускаем AVReal, прошиваем МК. Кстати, возможно, у Вас возникал вопрос: а бесконечное ли число раз можно перепрошивать МК? Оказывается, нет. Всего лишь 10000 раз (как минимум). Поэтому, думаю, об этом совершенно не стоит беспокоиться. После того, как все это сделали, можно проверять устройство.

ВАЖНО!!! Сначала нужно подать питание на МК, убедиться, что транзистор подсоединен к МК, и лишь затем подавать питание в цепь с лампой (мотором) и полевым транзистором. Иначе можете сжеть транзистор. Дело в том, что в выключенном состоянии "ножки" МК "болтаются в воздухе" - они ни к чему не подключены, и на них возникают наводки. Этих слабеньких наводок достаточно, чтобы частично открыть очень чувствительный полевой транзистор. Тогда его сопротивление между стоком и истоком упадет от нескольких МОм до нескольких Ом или долей Ом и через него потечет большой ток к лампе. Но транзистор не откроется полностью, т. к. для этого нужно подать на затвор не 1-3 В наводки, а стабильные 5 В, и его сопротивление будет намного больше минимального (для IRF7311 это 0,029 Ом). Это приведет к выделению на нем большого количества тепла, и он задымится, а может, и сгорит. Хотя, конечно, все зависит от мощности лампы или мотора.

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

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

Подключение семисегментных индикаторов.

Файлы к статье (размер: 81.1 КБ)

В этой статье мы рассмотрим подключение семисегментных индикаторов к МК и работу с ними. Что это такое, будет понятно из картинки:

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

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

В качестве примера рассмотрим два индикатора: SA39-11xxx (xxx - три-четыре буквы, кодирующие цвет, в моём случае GWA) и BC56-12xxx (у меня xxx = SRWA).
Приведу ниже список цветов:

• HWA - ярко-красный на фосфиде галлия GaP, 700 нм
• EWA - высокопроизводительный красный на фосфиде-арсениде и фосфиде галлия GaAsP/GaP, 625 нм (не знаю, как по-другому можно перевести "HIGH EFFICIENCY RED")
• GWA - зеленый на фосфиде галлия GaP, 565 нм
• YWA - желтый на фосфиде-арсениде и фосфиде галлия GaAsP/GaP, 590 нм
• SRWA - супер ярко-красный на арсениде галлия-алюминия GaAlAs, 660 нм

В названии индикаторов вторая буква обознаяет тип соединения светодиодов: С - общий катод, А - общий анод. Ниже приведена электрическая схема и чертеж SA39 и SC39. Обратите внимание на буквы, которыми обозначили каждый сегмент (a-g) и обозначение точки (DP). Эти названия мы будем использовать в коде программы для объявления макросов. Это позволит как можно сильнее абстагировать программу от электрической схемы, от способа соединения индикатора и МК.

Значит, "ножки" 3 и 8 нужно подключить к шине +5 В (или, в крайнем случае, подать на них +5 В от МК, но так делать не рекомендуется), а остальные - к какому-либо порту МК. При этом не очень-то важно, в каком порядке, т. к. в случае ошибки Вы просто увидите на индикаторе не цифру, а какую-нибудь букву "зю". Тогда придется либо подключить по-другому, либо внести небольшие изменения в программу. В общем, символ, отображемый на индикаторе, зависит от того, какое число отправить в порт. Всего существует 255 комбинаций, и все они возможны независимо от способа подключения. Я использовал порт D для подключения индикатора.

Остается только лишь написать простенькую программу:

#include "iom16.h"

#define a 1   // Эти макросы содержат числа, соответствующие двойке,

#define b 2   // возведенной в степень, равной номеру "ножки" того

#define c 4   // порта, к которому подключен сегмент индикатора с

#define d 128 // одноименным макросу названием. Для того, чтобы вывести

#define e 64  // какую-либо цифру на индикатор, нужно отправить в порт

#define f 32  // число 255 минус сумму соответствующих сегментам макросов.

#define g 16  // Эти числа позволяют сделать программу независимой от подключения.

#define DP 8  // Измените эти числа, если индикатор выводит букву "зю"



short unsigned int i = 1;

unsigned char DigNumber = 0;

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

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

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



void io_init()

{

  DDRD = 0xFF;  // К порту D подключен индикатор

  PORTD = 0xFF;

}



void timer0_init()

{

  OCR0 = 15;  // Таймер срабатывает каждые 1024 такта. Прерывание каждые

  // 1024*16 тактов.

  TCCR0 |= (1 << WGM01) | (1 << CS00) | (1 << CS02);

  TIMSK |= (1 << OCIE0);

}



void Dig_init()

{

  Dig[0] = 255 - (a+b+c+d+e+f);   // Если индикатор с общим анодом,

  Dig[1] = 255 - (b+c);           // нужно сумму макросов отнять от

  Dig[2] = 255 - (a+b+g+e+d);     // 255. Если с общим катодом, то

  Dig[3] = 255 - (a+b+g+c+d);     // отнимать не нужно.

  Dig[4] = 255 - (f+g+b+c);       // Имена макросов соответствуют

  Dig[5] = 255 - (a+f+g+c+d);     // именам сегментов индикатора

  Dig[6] = 255 - (a+f+g+c+d+e);

  Dig[7] = 255 - (a+b+c);

  Dig[8] = 255 - (a+b+c+d+e+f+g);

  Dig[9] = 255 - (a+b+c+d+f+g);

}



void main()

{

  io_init();

  timer0_init();

  Dig_init();

  SREG |= (1 << 7);

  PORTD = Dig[0];   //Выводим на индикатор цифру "0"

  while(1)

  {}

}



#pragma vector = TIMER0_COMP_vect

__interrupt void Indic_change()

{

  if (i < 675)  // 675*16*1024 = 11,0592 МГц

  {             // Каждую секунду меняется цифра на индикаторе

    i++;

  }

  else

  {

    i = 1;

    if (DigNumber < 9)

      DigNumber++;

    else

      DigNumber = 0;

    PORTD = Dig[DigNumber];

  }

}

Как это работает, думаю, ясно из комментариев к коду. Макросы после #define позволяют сделать код почти независящим от способа подключения индикатора. Если, например, Вы подключили 5-й вывод индикатора (d-сегмент) к выводу PD3 МК, то для того, чтобы все правильно работало, нужно сопоставить макросу d число 2³=8, написав

Откомпилировав программу и прошив ее в МК, если все правильно подключено и соответствующе описано в #define, получаем цифровые электронные часы, которые умеют считать до 10. Если у Вас установлен резонатор на 11,0592 МГц, то эти часы будут тикать раз в секунду и с, казалось бы, поразительной точностью: за час они не собьются ни на секунду! Но удивительного тут ничего нет: вся точность упирается в качество резонатора и отсутствие ошибок в программе. Кстати, в электронных часах стоят такие же резонаторы, только меньших размеров и частот (обычно 3 КГц). Но собирать часы на МК несколько нерационально, потому что существуют специализированные микросхемы для этого, умеющие отсчитывать время, дату, месяц, день недели, год и т.д. Связав с такой микросхемой МК, можно научить его "чувствовать" время.

Но мы несколько отвлеклись от темы нашей статьи. Теперь пора рассмотреть работу с трехзначным индикатором, коим является BC56-12xxx. По логике у него должно быть 8*3+1=25 выводов. Но у него их только лишь 12. Давайте посмотрим его документацию.

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

Итак, подавая напряжение на выводы 1, 2, 3, 4, 5, 7, 10, 11, формируют цифру (символ), мы их назовем информационными или шиной данных, а управляя выводами 8, 9, 12, определяют позицию этой цифры. Выводы 8, 9, 12 назовем выводами выбора устройства или шиной адреса. Понятно, что нельзя одновременно зажечь две или три разные цифры. Придется использовать стробирование, т. е. зажигать цифры по очереди с высокой скоростью. Они будут мерцать, но глаз этого не успеет заметить.

Значит, с выводами 1, 2, 3, 4, 5, 7, 10, 11 работа совершенно аналогична. А выводы 8, 9, 12 нужно замыкать на землю по очереди. Казалось бы, чего проще - присоединить их к МК и все. Но, как я уже говорил, не следует цеплять к МК общий электрод - это слишком большая нагрузка для него, и его порт ввода-вывода может сгореть. Следует использовать полевые транзисторы, как это было описано в предыдущей статье.

Мне кажется, настало время рассказать о шифраторах и дешифраторах. Дешифраторами называются комбинационные устройства, преобразующие n-разрядный двоичный код на их входе в логический сигнал, появляющийся на том выходе, десятичный номер которого соответствует двоичному коду. Дешифраторы имеют как правило 3 или 4 входа и 8 или 16 выходов соответственно. Как работает дешифратор? Подадим на вход число в двоичном коде, например, 5, установив лог. 1 на первом и третьем выводах на входе. Тогда появится лог. 1 на пятом выходе. Шифраторы выполняют обратную операцию - если подать лог. 1 на один из входов, на выходе появится двоичный код номера этого входа. Но я не знаю, где их применяют.

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

В школах и особенно вузах часто на уроках информатики рисуют логическую схему работы памяти, где есть груда логических элементов "И" и/или "ИЛИ" для выборки ячейки памяти, какая-то шина данных, шина адреса, ячейки памяти... Короче, обычно преподаватель сам не может понять, что он нарисовал, как это все работает и не загибается. Оказывается, там стоит дешифратор и все работает очень просто. По шине адреса приходит адрес ячейки памяти в двоичном коде, в которую надо записать информацию (или прочитать) и поступает в дешифратор. Дешифратор подключает требуемую ячейку к цепи питания, ячейка начинает работать и сохраняет тот двоичный код, который установлен на шине данных (или выдает туда свое содержимое). После этого исчезает адрес на шине адреса и дешифратор отключает эту ячейку до следующего использования. При запуске компьютера в программе Setup можно установить напряжение на ЦПУ (там можно выбрать из нескольких значений). А как это происходит? Есть специальная шина, по которой двоичный код поступает в дешифратор. Дешифратор открывает один из нескольких транзисторов и через этот транзистор идет питание требуемого напряжения на ЦПУ.

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

Вернемся к нашим баранам. Схема очень проста. Я прицепил к порту А половинку панельки для широких микросхем, так чтобы подключенными оказались выводы 1, 2, 3, 4, 5, 7, 10, 11 вставленного в нее семисегментного индикатора BC56-12xxx. Другие три вывода подключены через уже знакомые нам транзисторы IRF7311 к выводам порта С (вывод 12 к РС5, 9 - к РС6, 8 - к РС7). Один из транзисторов (корпуса два, а их четыре) остался про запас.

Код программы приведен ниже. Поскольку в будущем может возникнуть необходимость некоторое трехзначное число, хранящееся в переменной, вывести на индикатор, неплохо было бы написать для этого какую-нибудь специальную функцию. Назовем ее Display(). Казалось бы, реализовать ее очень просто, нужно число поделить на 100, найти целое от деления и остаток и потом также поделить на 10. Но... Но МК не знает функций mod и div. Это во-первых. А во-вторых, у него нет математического сопроцессора для деления, и одна операция деления может занимать сотни и даже тысячи тактов процессора, в отличие от сложения/вычитания (1 такт для char) и умножения на целое(2 такта для char). Поэтому всегда старайтесь заменить деление чем-либо другим, если возможно. Иногда бывает даже рациональнее отправить некоторые данные через COM-порт в компьютер, там произвести вычисления и вернуть обратно результат. Как это реализовать, в следующей статье. А сейчас рассмотрим наглядный пример.

Предположим, Вы решили поставить у себя в ванной электронный регулятор температуры воды на МК, который постоянно измеряет температуру воды в душе специальным датчиком и с помощью мотора крутит кран так, чтобы температура стремилась к заданному значению. И Вы используете некий алгоритм, позволяющий с очень большой точностью управлять этим процессом. Но алгоритм содержит операции деления, извлечения корня, вычисления логарифма, косинуса и, несомненно, интеграла. И когда Вы пойдете мыться, после поворота ручки регулировки температуры, МК "зависнет" и будет на Вас несколько секунд будет лить воду температурой 70-80 °С, а потом, когда он все вычислит, с большой точностью выставит нужные Вам 28,32204°С. :)

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

#include "iom16.h"

#define a 1

#define b 4

#define c 16

#define d 64  //Меняем эти числа для другого индикатора

#define e 128

#define f 2

#define g 8

#define DP 32



short unsigned int i = 1;

short unsigned int Number = 0;

unsigned char      Dig[10];

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

char               Disp5, Disp6, Disp7;



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

void Display (short unsigned int Number)

{

  unsigned char Num1, Num2, Num3;

  Num1=Num2=0;

  while (Number >= 100)  

  {

    Number -= 100;  

    Num1++;  

  }

  while (Number >= 10) 

  {

    Number -= 10;  

    Num2++; 

  }

  Num3 = Number;

  Disp5 = Dig[Num1];

  Disp6 = Dig[Num2];

  Disp7 = Dig[Num3];

}



void io_init() //Инициализация портов ввода/вывода

{

  DDRA = 0xFF;

  PORTA = 0;

  DDRC |= (1 << PINC5) | (1 << PINC6) |(1 << PINC7);

  PORTC = 0;

}



void timer0_init()

{

  OCR0 = 15;

  TCCR0 |= (1 << WGM01) | (1 << CS00) | (1 << CS02);

  TIMSK |= (1 << OCIE0);

}



void Dig_init()

{

  Dig[0] = (a+b+c+d+e+f);   // Сейчас у нас схема с общим катодом

  Dig[1] = (b+c);

  Dig[2] = (a+b+g+e+d);

  Dig[3] = (a+b+g+c+d);

  Dig[4] = (f+g+b+c);

  Dig[5] = (a+f+g+c+d);

  Dig[6] = (a+f+g+c+d+e);

  Dig[7] = (a+b+c);

  Dig[8] = (a+b+c+d+e+f+g);

  Dig[9] = (a+b+c+d+f+g);

}



void main()

{

  unsigned char j, k = 0;

  Dig_init();

  Display(0);

  io_init();

  timer0_init();

  SREG |= (1 << 7);

  while(1)

  {

    for (j = 0; j <= 50; j++){} // Задержка для отображения цифры

    (k == 3) ? k = 0 : k++;

    PORTC &= 31;  //Очистка PC7, PC6, PC5

    for (j = 0; j<=30; j++){} // Задержка для выключения транзистора

    switch (k)

    {

      case 0: PORTC |= (1 << PINC7); // Единицы

              PORTA = Disp7;

        break;

      case 1: PORTC |= (1 << PINC6); // Десятки

              PORTA = Disp6;

        break;

      case 2: PORTC |= (1 << PINC5); // Сотни

              PORTA = Disp5;

    }

  }

}



#pragma vector = TIMER0_COMP_vect

__interrupt void Indic_change()

{

  if (i < 675)

  {

    i++;

  }

  else

  {

    i = 1;

    if (Number < 999)

      Number++;

    else

      Number = 0;

      PORTB++;

    Display(Number); // Увеличение отображаемого числа.

  }

}

Функция Display(Number) берет число Number и отнимает от него по сотне, пока Number не станет меньше 100. Количество отнятых сотен сохраняется в Num1. Аналогично потом отнимают десятки. Количество десятков - в переменной Num2. Остаток (единицы) сохраняется в Num3. Глобальным переменным Disp5, Disp6, Disp7 присваиваются значения, которые нужно отправить в порт A, чтобы отобразить исходное число Number. Как это выглядит в действии, увидите, когда прошьёте программу в МК.

USART. Сопряжение МК с компьютером через COM-порт. Теория.

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

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

• Datasheet на ATMEGA128 на русском языке.
  Большинство Datasheetов на электронные компоненты сделано на английском языке. Для одних это не проблема, а другим создает определенные трудности. Конечно, русский текст читать приятнее. Данный текст является полным качественным переводом английского варианта и подробно рассказывает обо всех возможностях этого МК. Поскольку все МК серии MEGA имеют сходное строение, при возникновении вопросов и проблем ищите решение в первую очередь здесь.
  
   
• Сайт о роботах, робототехнике и микроконтроллерах.
  Роботы и микроконтроллеры - неразлучные друзья. Практически любой робот содержит в себе электронный "мозг", состоящий из одного или нескольких МК. На сайте можно найти рекомендации по проектированию и изготовлению роботов и программированию МК для них.
  
   
• Статья об устройстве и архитектуре AVR
• Сайт "Железный Феликс" о робототехнике
• Сайт о программировании AVR

Итак, слово USART расшифровывается как "универсальный синхронный и асинхронный приемник и передатчик" (УСАПП) ("Universal Synchronous and Asynchronous Receiver and Transmitter"). Так называют устройство, умеющее работать с интерфейсом RS-232 (и его аналогами), на котором и построен СОМ-порт. Помимо этого, существуют еще устройства UART, которые могут работать только в асинхронном режиме. Мы будем использовать только асинхронный, т. к. современные компьютеры имеют 9-контактный СОМ порт без линии автоматических тактовых сигналов.

Напряжениями логического уровня в интерфейсе RS-232C (существуют еще RS-232A и RS-232B, но в компьютере и МК RS-232C) являются +12 В (лог. 0) и -12 В (лог. 1). Состояние 0 В не используется для передачи данных и существует только при отключении питания СОМ-порта. В СОМ порте (на рисунке ниже представлена вилка) 9 проводников.

Как работать с компьютера с линиями 5 и 7 уже рассказывалось в статьях по СОМ-порту. Нас теперь интересуют линии 2 (RXD) и 3 (TXD). Именно по ним и происходит передача данных. Рассмотрим, как это реализовано.

Оба провода передачи данных работают совершенно одинаково. При этом RXD одного устройства соединяется с TXD другого и наоборот, TXD первого устройсва цепляется к RXD второго устройства. Только не забудьте соединить 5-й провод (землю)! :)

Изначально на линии передачи данных установлена лог. 1 (-12 В). Передача данных осуществляется кадрами по 5-8 бит. Чтобы обозначить начало и конец кадра, используют "старт-бит" и "стоп-бит". Приемник и передатчик заранее должны быть настроены на работу с одинаковыми параметрами для гарантированной передачи данных. Когда нужно передать данные, передатчик меняет состояние линии с лог. 1 на лог. 0 (+12 В). Это стартовый бит. После него начинается передача информационных битов. Этот момент (появление стартового бита) фиксируется приемником и в нем начинают "тикать часы". Биты передаются через одинаковые фиксированные моменты времени с определенной скоростью, называемой битрейтом (baudrate). Например, пусть этот интервал составляет 100 мкс. Передатчик держит стартовый бит (всегда лог. 0) в течение 100 мкс, а затем выставляет на линии первый информационный бит. Еще через 100 мкс он устанавливает второй бит и т.д.. Приемник, в свою очередь, обнаружив стартовый бит, ждет 100 мкс, затем ждет половину этого времени, т.е. 50 мкс (чтобы попасть как раз в середину первого бита), после чего начинает запоминать состояние линии каждые 100 мкс.

За информационными битами следуют бит четности и стоповые биты. Стоповые биты всегда имеют уровень -12 В (лог. 1) и служат одновременно паузой между кадрами данных. Если стоповый бит один, то пауза между кадрами меньше и скорость передачи данных выше. Если их два, то пауза будет дольше. Бит четности (P) служит для контроля правильности передачи данных. Если выставлен параметр четность как Odd (Нечетный), то бит четности будет таким, чтобы сумма всех отправленных информационных битов вместе с ним была обязательно нечетной. Если приемник, приняв кадр, установил, что сумма нечетная, то все верно, если она оказалась четной, значит, была ошибка в одном бите (или в 3-х, 5-ти, 7-ми, 9-ти). Этот способ достаточно примитивен и не обнаружит ошибки в 2-х, 4-х, 6-ти или 8-ми битах. Но наиболее вероятной является ошибка именно в 1 бит, а не в 2 и больше. Если четность установлена как Even (Четная), то сумма всех отправленных битов будет всегда четной.

Как видим, часы, по которым происходит передача и прием данных, синхронизируются по стартовому биту. Если они идут синхронно, то все отлично, если же нет, то момент считывания будет смещаться от середины бита в ту или иную сторону, но, поскольку битов немного (5-9, до 10 с битом четности), небольшая ошибка погоду не испортит и момент считывания не успеет сместиться в соседний бит. К тому же, МК содержит модуль коррекции принятых данных. В качестве часов в МК, используется, естественно, кварцевый резонатор. Вот здесь и нужно будет вспомнить о том, что я говорил в первой статье.

Существуют стандартные битрейты для передачи данных через интерфейс RS-232C.

• 2400 bps (bps - бит в секунду)
• 4800 bps
• 9600 bps
• 14400 bps
• 19200 bps
• 28800 bps
• 38400 bps
• 57600 bps
• 76800 bps
• 115.2 kbps
• 230.4 kbps

Заметили связь между скоростями? Так вот, чаще всего используют 9600 бит/с. Для того, чтобы получить эти значения скоростей с высокой точностью, следует использовать резонаторы на те частоты, о которых говорилось в первой статье, например, 11,0592 МГц. Чем выше частота резонатора, тем выше и максимальная скорость. Для нашего МК с резонатором на 16 МГц возможна скорость до 2 Мбит/с. Но не надо забывать, что это скорость между битами в кадре, а в кадрах есть еще стоп-биты и биты четности. Поэтому реально скорость будет на 10-35% ниже. При использовании других резонаторов (4 МГц, 8 МГц и т. п.) будет возникать погрешность для первых 11 скоростей, скорости в 250 кбит/с и кратные будут без погрешностей. Чем больше погрешность, тем ниже устойчивость к помехам и выше вероятность ошибок. Наш МК может также передавать данные с двойной скоростью, что задается спецальным регистром. Ниже приведена схема модуля USART в МК AtMega16.

За работу USARTа отвечают несколько специальных регистров (они обозначены жирным шрифтом на рисунке выше). Во первых, следует выделить регистр UDR (USART Data Register). Он используется для хранения принятых/отправляемых данных. Сделан он особым образом, т.к. на самом деле регистров UDR 3 штуки. При записи значения в UDR происходит запись в тот, который изображен на рисунке верхним (UDR (transmit) или TXB). Это значение незамедлительно отправляется другому устройству через COM-порт и регистр очищается. Когда в МК приходит байт информации, он сохраняется в другом UDR-регистре (UDR (receive) или RXB), причем в верхнем RXB-регистре. Как только байт полностью принят, он автоматически копируется в нижний RXB-регистр, откуда его можно уже прочитать, а в верхний при этом принимается следующий байт (чтобы избежать пауз в работе и потери данных). Итак, при чтении данных из UDR берется принятый байт, а при записи в него данные сразу же отправляются через интерфейс приемнику. Если после приема двух байтов в оба RXB-регистра не произошло считывания из нижнего, то третий байт не будет принят USARTом и USART выставит флаг ошибки Data OverRun (DOR).

Существуют регистры управления и статуса USARTом: UCSRA, UCSRB и UCSRC. Рассмотрим в них подробно те биты, которые чаще всего используются.

UCSRA.

• Бит 7 - RXC (Receive Comlete). Бит завершения приема. Автоматически устанавливается, если принимаются данные. При чтении принятых данных сбрасывается.
  
   
• *Бит 6 - TXC (Transmit Comlete). Бит завершения передачи. Автоматически устанавливается после отправки кадра данных при отсутствии следующих данных для отправки.
  
   
• Бит 5 - UDRE (UDR Empty). Бит отсутствия данных для отправки. Если установлен, нет данных для отправки.
  
   
• Бит 4 - FE (Frame Error). Бит ошибки кадра. Равен единице, если была ошибка в формате принятого кадра.
  
   
• Бит 3 - DOR (Data OverRun). Бит ошибки переполнения буфера. Равен единице, если нет места для приема нового кадра данных.
  
   
• Бит 2 - PE (Parity Error). Бит ошибки четности. Равен единице, если была ошибка четности.
  
   
• *Бит 1 - U2X (Double speed). Бит двойной скорости USARTа. Если установлен, скорость работы и битрейт удваиваются.
  
   
• *Бит 0 - MPCM (Multi-Processor Communication Mode). Бит работы в многопроцессорном режиме. Если равен единице, включен многопроцессорный режим.
  
   

* Звездочку я поставил около тех битов, которые доступны для записи. Остальные биты доступны только для чтения. Некоторая информация, думаю, требует пояснения. Биты 7, 6, 5 могут использоваться для генерации прерываний. Обычно делают прерывание по приему данных. Многопроцессорный режим используется, когда к одному СОМ-порту цепляются сразу несколько МК. Например, Вы подключаете к компьютеру (или другому МК) устройство, в котором есть несколько МК, подключенных к одному интерфейсу RS-232C. Тогда обычно используют 9 битов данных, при этом первый бит сигнализирует о передаче адреса (если установлен) либо данных. МК, принимая остальные биты, если они являются адресом, сравнивает их со своим адресом. В случае совпадения он принимает кадры данных и отвечает на них, а все остальные МК "помалкывают". Если адрес не совпадает, МК реагирут только на первый бит, что уменьшает нагрузку на процессор.

UCSRB.

• Бит 7 - RXCIE (Receive Comlete Interrupt Enable). Бит генерации прерывания при приеме данных. Если установлен, происходит прерывание для немедленной обработки принятых данных.
  
   
• Бит 6 - TXCIE (Transmit Comlete Interrupt Enable). Бит генерации прерывания при завершении передачи. Если установлен, происходит прерывание после отправки данных.
  
   
• Бит 5 - UDRIE (UDR Empty Interrupt Enable). Бит генерации прерывания при отсутствии данных для передачи.
  
   
• Бит 4 - RXEN (Receiver Enable). Бит наличия приемника данных. Если установлен, МК будет принимать данные через RS-232C.
  
   
• Бит 3 - TXEN (Transmitter Enable). Бит наличия передатчика данных. Если установлен, МК будет передавать данные через RS-232C.
  
   
• Бит 2 - UCSZ2 (USART Character SiZe 2). Определяет количество бит в кадре. Работает вместе с битами UCSZ1 и UCSZ0 в UCSRC.
  
   
• #Бит 1 - RXB8 (Receive Data Bit 8). Девятый бит принятых данных (восьмой при нумерации с 0), использующийся в многопроцессорном режиме.
  
   
• Бит 0 - TXB8 (Transmit Data Bit 8). Девятый бит отправляемых данных, использующийся в многопроцессорном режиме.
  
   

# Решеткой отмечен бит, доступный только для чтения. Все остальные доступны для чтения/записи.
Наконец, самый "страшный" регистр.

UCSRC.

• Бит 7 - URSEL (USART Register SELect). Бит выбора регистра. 1 - UCSRC, 0 - UBRRH.
  
   
• Бит 6 - UMSEL (USART Mode SELect). Бит выбора режима работы. 1 - синхронный, 0 - асинхронный.
  
   
• Бит 5 - UPM1 (USART Parity Mode 0). Установка режима четности/нечетности. Оба сброшены - нет контроля.
• Бит 4 - UPM0 (USART Parity Mode 0). Оба установлены - нечетная сумма. UPM0 = 0 и UPM1 = 1 - четная сумма.
  
   
• Бит 3 - USBS (USART Stop Bit Select). Количество стоп-битов. Если сброшен, то 1 стоп-бит, иначе - 2.
  
   
• Бит 2 - UCSZ1 (USART Character Size 1). Размер кадра данных (вместе с UCSZ2 из UCSRB).
• #Бит 1 - UCSZ1 (USART Character Size 1). Таблицу возможных значений см. ниже
  
   
• Бит 0 - UCPOL (USART Clock POLarity). Используется в синхронном режиме. Если равен нулю, то тактирование отправляемых данных по переднему фронту импульса, принимаемых - по заднему. Если установлен, то наоборот.
  
   

Чем же так страшен этот регистр управления USARTом? Он имеет тот же адрес, что и верхний регистр битрейта (0x80). Это означает, что процессор не видит разницы между этими регистрами. Для того, чтобы их можно было отличать, сделан седьмой бит URSEL. Если он равен единице, процессор работает с UCSRC, иначе с UBRRH. Это, возможно, справедливо не для всех МК серии MEGA, так что читайте Datasheet. Ниже обещанная таблица установки размера кадра данных.

Остались два регистра. Это регистры установки битрейта - UBRRH и UBRRL. В регистре UBRRH доступны биты 0-3 (если в UCSRC URSEL = 0). Регистр UBRRL доступен весь для сохранения восьми младших битов числа. В этих двух регистрах может быть сохранено 12-битное число (От 0 до 4095). Это число вычисляется по следующей формуле:

UBRR = f_osc / (X * BAUD) - 1

Здесь X равно 16 при режиме с нормальной скоростью (бит U2X = 0) и 8 в режиме удвоенной скорости (бит U2X = 1), BAUD - нужный битрейт, f_osc - частота кварцевого резнонатора. По этой формуле легко вычислить значение регистра самостоятельно, но существуют также специальные таблицы наиболее типичных битрейтов и соответствующих значений UBRR. Такую таблицу из-за её громоздкости приводить не буду. Ее можно найти в Datasheetе к МК. Для AtMega16 таблица находится на стр. 169 его Datasheetа.

В заключение хотелось бы отметить, что COM-порт гарантированно будет работать на больших скоростях (0,5 - 2 Мбит/с) при длине кабеля до 8 метров. При небольших скоростях длину кабеля можно увеличить до 15 метров. При большей длине, возможно, будут ошибки. Хотя... хотя можно в случае надобности придумывать различные ухищрения и особые алгоритмы, позволяющие увеличить длину кабеля, возможно, в ущерб скорости. Тем не менее, помимо RS-232 есть еще и другие подобные интерфейсы, среди которых есть и низковольтные помехоустойчивые с дифференциальными линиями, где можно использовать провода длиной до километра.

USART. Пример практической реализации

файлы к статье (размер: 62.4 КБ)

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

Если Вы читали предыдущую статью (надеюсь на это), то, наверное, заметили, что рабочие напряжения в COM-порту +12 В и -12 В, а МК оперирует напряжениями +5 В и 0 В. Для того, чтобы все работало нормально, нужно установить преобразователь уровней. Рекомендую ставить MAX232. Потребуются, помимо микросхемы, 5 конденсаторов на 1 мкФ.

При работе с COM-портом именно эта микросхема находит наиболее частое применение. Если Вы купили макетную плату с разводкой под СОМ-порт, то там, скорее всего, будет и готовая разводка под установку MAX232 и конденсаторов. Правда, когда я купил свою плату, то сначала припаял МК и цепь питания, потом СОМ-порт. Долго не мог понять, как крепить преобразователь уровня. И тут вдруг выяснилось, что все компоненты я припаял не с той стороны к плате :-). Но не переделывать же все! Поэтому я прицепил СОМ-порт и МАХ232 к "правильной" стороне, а остальное оставил на "неправильной".

У меня в схеме задействованы выводы 11 (T1_in) и 12 (R1_out). Соответственно, вывод 13 (R1_in) подключен к 3-му выводу розетки СОМ-порта (RXD), а 14-й вывод МАХ-232 (T1_out) подсоединен ко 2-му выводу розетки СОМ-порта (TXD).

Теперь нужно МАХ232 подсоединить к МК. У ATMEGA16 USART использует 14-й вывод PB0 (RXD) для приема данных и PB1 (TXD) для отправки. Соответственно, PB0 нужно прикрепить к 12-му выводу МАХ232, а PB1 к 11-му. Ну и все. Не забудьте только соединить "земли" МК, МАХ232 и СОМ-порта между собой! :-)
 

Остается лишь написать программу для МК (для ПК тоже можно). В данном примере реализована работа с кварцем 11,0592 МГц, битрейт 115,2 кбит/с, 8 информационных бит, нет бита четности, 1 стоп-бит, скорость удвоенная. С большим, чем 115,2 кбит/с битрейтом мой компьютер работает с глюками.

Ниже приведен код программы для МК.

#include "iom16.h"

#define a 1

#define b 4

#define c 16

#define d 64  // Это для индикатора

#define e 128

#define f 2

#define g 8

#define DP 32



unsigned char      Dig[10];

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

char               Disp5, Disp6, Disp7;



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

void Display (unsigned char Number)

{

  unsigned char Num1, Num2, Num3;

  Num1=Num2=0;

  while (Number >= 100)  

  {

    Number -= 100;  

    Num1++;  

  }

  while (Number >= 10) 

  {

    Number -= 10;  

    Num2++; 

  }

  Num3 = Number;

  Disp5 = Dig[Num1];

  Disp6 = Dig[Num2];

  Disp7 = Dig[Num3];

}



void USART_init()

{

  UCSRA = (1 << 1); // Установка двойной скорости

  UCSRB |= (1 << 7) | (1 << 4) | (1 << 3); // Прерывание по приему данных, включены приемник и передатчик

  UCSRC |= (1 << 7); // Запись в UCSRC

  UCSRC |= (1 << 1) | (1 << 2); // Размер кадра данных 8 бит

  UCSRC -= 128; // Запись в UBRRH

  UBRRH = 0;

  UBRRL = 11; // Битрейт равет 115200 бит в секунду

}



void Dig_init()

{

  Dig[0] = (a+b+c+d+e+f);

  Dig[1] = (b+c);

  Dig[2] = (a+b+g+e+d);

  Dig[3] = (a+b+g+c+d);

  Dig[4] = (f+g+b+c);

  Dig[5] = (a+f+g+c+d);

  Dig[6] = (a+f+g+c+d+e);

  Dig[7] = (a+b+c);

  Dig[8] = (a+b+c+d+e+f+g);

  Dig[9] = (a+b+c+d+f+g);

}



void io_init() // Инициализация портов ввода/вывода

{

  DDRA = 0xFF;

  PORTA = 0;

  DDRC |= (1 << PINC5) | (1 << PINC6) |(1 << PINC7);

  PORTC = 0;

  DDRB = 1;

}



void main()

{

  unsigned char j, k = 0;

  USART_init();

  Dig_init();

  Display(0);

  SREG |= (1 << 7);

  io_init();

  while(1) // Отображение принятого байта

  {

    for (j = 0; j <= 50; j++){} // Задержка для отображения цифры

    (k == 3) ? k = 0 : k++;

    PORTC &= 31;  //Очистка PC7, PC6, PC5

    for (j = 0; j<=30; j++){} // Задержка для выключения транзистора

    switch (k)

    {

      case 0: PORTC |= (1 << PINC7); // Единицы

              PORTA = Disp7;

        break;

      case 1: PORTC |= (1 << PINC6); // Десятки

              PORTA = Disp6;

        break;

      case 2: PORTC |= (1 << PINC5); // Сотни

              PORTA = Disp5;

    }  

  }

}



#pragma vector = USART_RXC_vect

__interrupt void Recieve()

{

  unsigned char temp = 0;

  unsigned char* str = " Hello! My name is AtMega16! "; // Строка данных

  char t,l;

  temp = UDR; // Чтение принятых данных

  Display (temp); // Отображение числа на индикаторе

  PORTB = 1 - PORTB; // Зажигаем/гасим светодиод на PB0

  if (temp == 5) // Отправка строки, если принятый байт равен 5

  {

    for (t=0; t < 28; t++)

    {

      UDR = str[t]; // Отправка строки

      for (l=0; l < 200; l++) // Задержка (чтобы успел отправить число)

      { }

    }

  }

  else

  UDR = temp; // Отправка обратно принятого числа

}

Теперь нужно позаботиться о программе в компьютере, которая будет управлять СОМ-портом и работать с МК. Можно просто взять готовую программу из статей о СОМ-порте компьютера, основанную на библиотеке SerialGate.dll. Сделаю здесь ссылку на архив с этой программой (там лежит еще Terminal.exe, о нем чуть позже) Давайте посмотрим, что получится...

скачать SerialGateTest & Terminal (размер: 383 КБ)

Запускаем программу, подключаем наше устройство к СОМ-порту, подаем питание на него, в программе выбираем СОМ-порт и устанавливаем битрейт 115200 бит/с. Давайте отправим какой-нибудь символ, например, "&". МК отправит его обратно и отобразит на индикаторе его номер - 38. Отправив строку, получаем ее обратно. Заметьте, что при нечетном количестве символов меняется состояние светодиода, подключенного к PB0. При каждом прерывании он загорается либо гаснет.

Теперь давайте рассмотрим другую программу из этого архива - Terminal.exe. Не знаю, кто ее автор, но ему СПАСИБО!

Это очень мощная и удобная программа, позволяющая делать с СОМ-портом практически все, что угодно. Запустив программу, выберите номер порта, битрейт 115200, 8 битов данных, четность "none", 1 стоп бит. Нажимаем Connect и можем теперь отправлять данные МК. Символы передаются так же, как и в предыдущей программе, в виде их ASCII - значений, но если набрать "#xxx", где ххх-трехзначное число до 255, то можно передать любой символ, в т.ч. и непечатный. Если МК получает символ с номером 5, то он вместо него обратно отсылает строку " Hello! My name is AtMega16! ". 13-й символ - это переход на след. строчку. Кстати, ASCII таблица в программе тоже есть.