Avr на c – просто?

AVR на C – просто?

Материалы приведенные далее рассчитаны на пользователей знакомых с программированием в целом и языком C (не обязательно) в частности.

В основном излагаемый материал описывает использование микроконтроллеров AVR, особое внимание на ATmega328. Для изучения материалов понадобится Arduino Uno или Arduino Nano 3.

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

1. Подготовка к изучению

Для изучения нам понадобятся:

  • Среда разработки;
  • Стандартные библиотеки C для микроконтроллеров AVR;
  • Программа для загрузки микропрограмм в микроконтроллер;
  • Микроконтроллер.

1.1. Среда разработки

При выборе среды разработки можно натолкнутся на «не пробиваемую стену» множества программных оболочек для программирования на разных языках программирования. Но учитывая направление на микроконтроллеры круг поиска сужается до сред разработки адаптированных под конкретный вид микроконтроллеров семейства AVR фирмы Atmel. Кроме того среда разработки язык программирования C.

Из множества вариантов рассмотрим среду разработки СodeBlocks. Будем использовать оригинальную версию СodeBlocks с сайта разработчиков www.codeblocks.org последней версии, на момент написания это версия 16.01. Данная среда разработки интересна наличием версий под популярные операционные системы Linux, Windows и Mac OS.

Вкратце рассмотрим установку под Windows. Скачав файл codeblocks-16.01-setup.exe запускаем его.

Ознакомимся с лицензией и принимаем ее.

Устанавливаем все компоненты без изменений

Путь установки оставляем без изменений.

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

Получаем установленную среду разработки Code::Blocks.

1.2. Стандартные библиотеки C/C++ для микроконтроллеров AVR

Среда разработки установлена, но для работы необходимо подключить библиотеки для компиляции программ для микроконтроллера. Один из способов это поставить WinAVR. Только зачем, если среда разработки уже выбрана. Возьмем все необходимое с сайта производителя микроконтроллеров семейства AVR.

Скачиваем необходимое после простой регистрации по адресу: http://www.atmel.com/tools/ATMELAVRTOOLCHAINFORWINDOWS.aspx

Понадобится Atmel AVR 8-bit Toolchain так как использовать собираемся ATmega328 а он 8-bit. После скачивания запускаем полученный само распаковываемый архив и получаем папку (вида avr8-gnu-toolchain) со всем необходимым. Куда ее положить?

Запускаем ранее установленный Code::Blocks идем в меню Settings >> Compiler переходим во вкладку Toolchain executables выбираем интересующий нас компилятор из списка Selected compiler это будет GNU GCC Compiler for AVR. Далее смотрим путь по умолчанию для размещения ранее скачанной и распакованной папки.

Переименовываем нашу папку как в настройках Code::Blocks и перемещаем по указанному пути.

1.3. Программа для загрузки микропрограмм в микроконтроллер

Теперь все готово для программирования, но не хватает программы для облегчения прошивки микроконтроллера. Для изучения микроконтроллера ATmega328 будем использовать платформу Arduino UNO или Arduino Nano v3. Это дает возможность изучать микроконтроллер без паяльника и программатора.

Для Arduino есть хорошая программа ArduinoBuilder и оболочка из проекта CodeBlocks Arduino IDE (среда разработки Code::Blocks с добавлением библиотек ардуино). Использовать микроконтроллер без ардуино гораздо интересней поэтому скачиваем только ArduinoBuilder. Его будем использовать для экспериментов с микроконтроллером на плате Arduino.

Распаковываем архив, например в корень диска c: в папку ну скажем ArduinoBuilder, из нее делаем ссылку на рабочий стол и получаем два ярлыка:

Все программное обеспечение готово. Приступим к «железным» вопросам

1.4. Микроконтроллер

В своих изысканиях будем рассматривать микроконтроллер ATmega328 программы будем писать именно для него. «Знатоки» сразу нас пошлют к DataSheet но это не для нас. Мы пойдем своим путем и будем изучать его анатомию практически — методом «Тыка» :).

Первое что необходимо, это приобрести минимальное оборудование. Ограничимся для начала покупкой ардуины или аналога. Главное, чтобы на ней был установлен микроконтроллер ATmega328.

Нас интересуют:

Любой из перечисленных вариантов подойдет с теми или иными ограничениями или изменениями.

Рассмотрим подробнее вариант Arduino Nano v3. Здесь установлен микроконтроллер ATmega328P, есть возможность подключать через USB, а также существует несколько клонов по приемлемой цене. Описания в интернете можно найти массу, поэтому рассмотрим только схематичное описание найденное на просторах интернет.

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

Часть 2

Источник: http://cxem.net/mc/mc410.php

AVR. Учебный Курс. Программирование на Си. Часть 1

Я не раз и не два говорил, что изучение МК надо начинать с ассемблера. Этому был посвящен целый курс на сайте (правда он не очень последовательный, но постепенно я его причесываю до адекватного вида) .

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

Кроме того, Си намного проще натворить быдлокода, который вылезет вилами в самый неподходящий момент.

К сожалению все хотят результат немедленно. Поэтому я решил пойти с другой стороны — сделать обучалку по Си, но с показом его нижнего белья. Хороший программист-эмбеддер всегда крепко держит свою железку за шкварник, не давая ей ни шагу ступить без разрешения. Так что будет вначале Си код, потом то что родил компилятор и как все это работает на самом деле 🙂

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

Тогда для переноса алгоритма в другой МК достаточно будет переписать только интерфейсный слой, где прописано все обращение к железу, а весь рабочий код оставить как есть. И, конечно же, читаемость. Сишный исходник проще понять с первого взгляда (хотя..

мне, например, уже пофигу на что фтыкать — хоть си, хоть асм 🙂 ), но, опять же, если правильно все написать. Этим моментам я тоже буду уделять внимание.

В качестве подопытной железки на которой будет ставиться львинная доля всех примеров будет моя отладочная плата PinBoard.

Дальше все будет разжевано буквально по шагам для старта с полного нуля.<\p>

Выбор компилятора и установка среды Для AVR существует множество разных компиляторов Си:

В первую очередь это IAR AVR C — почти однозначно признается лучшим компилятором для AVR, т.к. сам контроллер создавался тесном сотрудничистве Atmel и спецов из IAR. Но за все приходится платить.

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

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

Вторым идет WinAVR GCC — мощный оптимизирующий компилятор. Полный опенсорц, кроссплатформенный, в общем, все радости жизни. Еще он отлично интегрируется в AVR Studio позволяя вести отладку прямо там, что адски удобно. В общем, я выбрал его.

Также есть CodeVision AVR C — очень популярный компилятор. Стал популярен в связи со своей простотой.

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

Честно говоря, я как то с подозрением к нему отношусь — как то раз приходилось дизасмить прогу написаную этим компилером, каша какая то а не код получалась.

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

Еще есть Image Craft AVR C и MicroC от микроэлектроники. Ни тем ни другим пользоваться не приходилось, но вот SWG очень уж нахваливает MicroPascal, мол жутко удобная среда программирования и библиотеки. Думаю MicroC не хуже будет, но тоже платный.

Как я уже сказал, я выбра WinAVR по трем причинам: халявный, интегрируется в AVR Studio и под него написана просто прорва готового кода на все случаи жизни.

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

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

Также не забудь поставить галочу Create Folder, чтобы у тебя все сложилось в одной директории. Ну и укажи место Location, где будет лежать проект. Указывай по короткому пути, что то вроде C:AVR Как показывает практика, чем короче путь тем лучше — меньше проблем при компиляции и линковке проектов.

Проц у меня в Pinboard по дефолту ATmega16, поэтому выбираю его. Те же у кого в PinBoard стоит Mega32 (по спец заказу ставил некторым 🙂 ) выбирают, соответственно ее.

Открывается рабочее поле с пустым *.c файлом.

Теперь не помешает настроить отображение путей в закладках студии. Для этого слазь по адресу:
Меню Tools — Options — General — FileTabs и выбираем в выпадающем списке «Filename Only». Иначе работать будет невозможно — на вкладке будет полный путь файла и на экране будет не более двух трех вкладок.

Настройка проекта
Вообще, классическим считается создание make файла в котором бы были описаны все зависимости. И это, наверное, правильно. Но мне, выросшему на полностью интегрированных IDE вроде uVision или AVR Studio этот подход является глубоко чуждым. Поэтому буду делать по своему, все средствами студии.

Тыкай в кнопку с шестеренкой.

Это настройки твоего проекта, а точнее настройки автоматической генерации make файла. На первой странице надо всего лишь вписать частоту на которой будет работать твой МК.

Это зависит от фьюз битов, так что считаем что частота у нас 8000000Гц.
Также обрати внимание на строку оптимизации. Сейчас там стоит -Os это оптимизация по размеру.

Пока оставь как есть, потом можешь попробовать поиграться с этим параметром. -O0 это отстутсвие оптимизации вообще.

Следующим шагом будет настройка путей. Первым делом добавь туда директорию твоего проекта — будешь туда подкладывать сторонние библиотеки. В списке появится путь «.»

Make файл сгенерирован, его ты можешь поглядеть в папке default в своем проекте, просто пробегись глазами, посмотри что там есть.

На этом пока все. Жми везде ОК и переходи в исходник.

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

Работать будет так:
При приходе по COM порту единички (код 0х31) будем зажигать диодик, а при приходе нуля (код 0х30) гасить. Причем сделано будет все на прерываниях, а фоновой задачей будет мигание другого диода. Простенько и со смыслом.

Собираем схему
Нам надо соединить модуль USB-USART конвертера с выводами USART микроконтроллера. Для этого берем перемычку из двух проводков и накидывам на штырьки крест накрест. То есть Rx контроллера соединяем с Tx конвертера, а Tx конвертера с Rx контроллера.

Кроме того, через USART мы теперь сможем достучаться до загрузчика (Pinboard идет с уже прошитым загрузчиком) и прошить наш контроллер не используя программатор.

Также накинем джамперы, соединяющие LED1 и LED2. Тем самым мы подключим светодиоды LED1 и LED2 к выводам PD4 и PD5 соотверственно.

Получится, в итоге вот такая схема:

Подключение остальных выводов, питания, сброса не рассматриваю, оно стандартное

Сразу оговорюсь, что я не буду углубляться конкретно в описание самого языка Си. Для этого существует просто колоссальное количество материала, начиная от классики «Язык программирования Си» от K&R и заканчивая разными методичками.

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

Посмотреть оглавление.

Там правда еще не все главы перенесены, но, думаю, это ненадолго.

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

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

#include<\p>

Этот файл находится в папке WinAVR и в нем содержится описание всех регистров и портов контроллера.

Причем там все хитро, с привязкой к конкретному контроллеру, который передается компилятором через make файл в параметре MCU и на основании этой переменной в твой проект подключается заголовочный файл с описанием адресов всех портов и регистров именно на этот контроллер.

Во как! Без него тоже можно, но тогда ты не сможешь использовать символические имена регистров вроде SREG или UDR и придется помнить адрес каждого вроде «0xC1», а это голову сломать.

Сама же команда #include позволяет добавить в твой проект содержимое любого текстового файла, например, файл с описанием функций или кусок другого кода. А чтобы директива могла этот файл найти мы и указывали пути к нашему проекту (директория WinAVR там уже по дефолту прописана).

Главная функция.
Программа на языке Си вся состоит из функций. Они могут быть вложенными и вызываться друг из друга в любом порядке и разными способами. Каждая функция имеет три обязательных параметра:

  • Возвращаемое значение, например, sin(x) возвращает значение синуса икс. Как в математике, короче.
  • Передаваемые параметры, тот самый икс.
  • Тело функции.

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

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

1
2
3
4
5		 int main(void)
{
 
return 0;
}

int main(void) { return 0; }

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

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

Конечно, в микроконтроллере main ничего вернуть в принципе не может и по идее должна быть void main(void), но GCC изначально заточен на PC и там программа может вернуть значение операционной системе по завершении. Поэтому GCC на void main(void) ругается Warning’ом.

Это не ошибка, работать будет, но я не люблю варнинги.

void это тип данных которые мы передаем в функцию, в данном случае main также не может ничего принять извне, поэтом void — пустышка. Заглушка, применяется тогда когда не надо ничего передавать или возвращать.

Вот такие вот { } фигурные скобочки это программный блок, в данном случае тело функции main, там будет распологаться код.

return — это возвращаемое значение, которое функция main отдаст при завершении, поскольку у нас int, то есть число то вернуть мы должны число. Хотя это все равно не имеет смысла, т.к. на микроконтроллере из main нам выходить разве что в никуда. Я возвращаю нуль. Ибо нефиг. А компилятор обычно умный и на этот случай код не генерит.

Хотя, если извратиться, то из main на МК выйти можно — например вывалиться в секцию бутлоадера и исполнить ее, но тут уже потребуется низкоуровневое ковыряние прошивки, чтобы подправить адреса перехода. Ниже ты сам увидишь и поймешь как это сделать. Зачем? Вот это уже другой вопрос, в 99.

999% случаев это нафиг не надо 🙂

Сделали, поехали дальше. Добавим переменную, она нам не особо нужна и без нужны вводить переменные не стоит, но мы же учимся.

Если переменные добавляются внутри тела функции — то они локальные и существуют только в этой функции. Когда из функции выходишь эти переменные удаляются, а память ОЗУ отдается под более важные нужды.

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

1
2
3
4
5
6		 int main(void)
{
unsigned char i;  
return 0;
}

int main(void) { unsigned char i; return 0; }

unsigned значит беззнаковый. Дело в том, что в двоичном представлении у нас старший бит отводится под знак, а значит в один байт (char) влазит число +127/-128, но если знак отбросить то влезет уже от 0 до 255. Обычно знак не нужен. Так что unsigned.
i — это всего лишь имя переменной. Не более того.

Теперь надо проинициализировать порты и UART. Конечно, можно взять и подключить библиотеку и вызвать какой нибудь UartInit(9600); но тогда ты не узнаешь что же произошло на самом деле.

Делаем так:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16		 int main(void)
{
unsigned char i;
 
#define XTAL 8000000L
#define baudrate 9600L
#define bauddivider (XTAL/(16*baudrate)-1)
#define HI(x) ((x)>>8)
#define LO(x) ((x)& 0xFF)
 
UBRRL = LO(bauddivider);
UBRRH = HI(bauddivider);
UCSRA = 0;
UCSRB = 1

Источник: http://easyelectronics.ru/avr-uchebnyj-kurs-programmirovanie-na-si-chast-1.html

Программирование микроконтроллеров AVR на языке C / C++ (Си) в Atmel Studio

Программирование на Си для микроконтроллеров немного отличается от обычного программирования тем, что приходится работать с битами и оперировать ими, я тут я приведу примеры часто используемых приемов программирования на языке C++ в Atmel Studio.

Представление чисел:

Например десятичное число 15 можно представить так:

0b00001111 – двоичное

017 – восьмеричное
0x0f – шестнадцатеричное

Математические оператры:

Сложение: +
Вычитание: –
Деление: /
Умножение: *
Остаток: %

Логические операции:

Логическое “И” (AND) && Пример: && – возвращает истина(единица) в том случае, когда истинны оба условия 1 и 2, в противном случае возвращает ложь(ноль)
Логическое “ИЛИ” (OR) || Пример: || – возвращает ложь(ноль) в том случае, когда ложны оба условия 1 и 2, в противном случае возвращает истина(единица)
Логическое “НЕТ” (NOT) ! Пример: int k=5; if (!k) {…} Оператор NOT инвертирует условие наоборот, вместо истины(единица) возвратит ложь(ноль) и наоборот. В примере есть переменная которой присвоено число 5, условие if будет выполнятся если переменная k будет равна чему угодно, но только не 5

Побитовые операции:

Отрицание –
Побитовое “И” (AND) &
Побитовое “ИЛИ” (OR) |
Побитовое “XOR” ^
Сдвиг битов вправо(эквивалентно делению на 2) >>
Сдвиг битов влево(эквивалентно умножению на 2) 1, не затрагивая другие битыПример: PORTB = 0b00000010, необходимо на 2 контакт PORTB установить низкий уровень, а потом высокий и т.д.:PORTB ^= 0b00000010; //Результат: PORTB = 0b00000000, т.к. PORTB был равен 0b00000010PORTB ^= 0b00000010; //Результат: PORTB = 0b00000010, т.к. PORTB был равен 0b00000000PORTB ^= 0b00000010; //Результат: PORTB = 0b00000000, т.к. PORTB был равен 0b00000010PORTB ^= 0b00000010; //Результат: PORTB = 0b00000010, т.к. PORTB был равен 0b00000000и т.д., т.е. при каждом выполнении этой команды “PORTB ^= 0b00000010”, изменяется только второй бит на противоположное значение, так можно сделать например мигание светодиодом.Другие манипуляции с битами, каждое выражение не зависит от предыдущего, просто как примеры и результат этого выраженияPORTB = 0; //Результат: PORTB = 0b00000000, обнуляемPORTB = 255; //Результат: PORTB = 0b11111111, установим все биты в единицуPORTB = 0xff; //Результат: PORTB = 0b11111111, установим все биты в единицуPORTB = 1; //Результат: PORTB = 0b00000001, просто присваиваем единицуPORTB = 128; //Результат: PORTB = 0b10000000, просто присваиваем 128 в десятичной, а в двоичной будет такой результатPORTB = 17; //Результат: PORTB = 0b00000001, сдвигаем десятичное число 128 на 7 позиций вправоИсточник: https://www.iprg.ruОбсудить на форумеС точки зрения программирования, ПЛК Wecon серии LX3V является клоном ПЛК Mitsubishi Melsec FX2N. Поэтому программировать LX3V можно как в родной среде программирования Wecon PLC Editor, так и в среде GX Works2 для Перед использованием контроллер необходимо запрограммировать, т.е. создать пользовательскую программу. После создания пользовательская программа может быть сохранена в энергонезависимой Flash-памяти контроллера и запускаться на выполнение H – безгалогеновый ПВХ изоляция жилы/внешняя оболочка   SL – кабель контрольный Li – многожильный проводник по VDE Уходящая в прошлое линейка контроллеров Step5, продолжает все-таки кое где встречаться. Приведенные здесь материалы от автора ставшим классиком в написании мануалов по Сименсу – Ганса Бергера, помогут, при необходимости, разобраться с этим вопросом. Работа с даными блоками управления осуществляется вкладкой MIKAS 11/M73A или J72+/M73I. MIKAS 11/M73A – только блоки управления M73 производства АВТЕЛ с ПО А308ХХХХ, А317ХХХХ, А373ХХХХ(далее ЭБУ M73A). Для загрузки программ в программируемое реле Lovato LRD20RD024  используется кабель программирования LRXC00 для COM-порта:

Источник: https://ingeneryi.info/radio-kom/rd-kom/ms-kom/779-programmirovanie-mikrokontrollerov-avr-na-yazyke-c-c-si-v-atmel-studio.html

Доступ к портам I/O AVR на языке C (GCC, WinAVR) | avr | programming

Оценка статьи:
1 звезда2 звезды3 звезды4 звезды5 звезд (нет голосов)
Загрузка...
Поделиться с друзьями:
Ссылка на основную публикацию
Похожие публикации
Adblock
detector
",css:{backgroundColor:"#000",opacity:.6}},container:{block:void 0,tpl:"
"},wrap:void 0,body:void 0,errors:{tpl:"
",autoclose_delay:2e3,ajax_unsuccessful_load:"Error"},openEffect:{type:"fade",speed:400},closeEffect:{type:"fade",speed:400},beforeOpen:n.noop,afterOpen:n.noop,beforeClose:n.noop,afterClose:n.noop,afterLoading:n.noop,afterLoadingOnShow:n.noop,errorLoading:n.noop},o=0,p=n([]),h={isEventOut:function(a,b){var c=!0;return n(a).each(function(){n(b.target).get(0)==n(this).get(0)&&(c=!1),0==n(b.target).closest("HTML",n(this).get(0)).length&&(c=!1)}),c}},q={getParentEl:function(a){var b=n(a);return b.data("arcticmodal")?b:(b=n(a).closest(".arcticmodal-container").data("arcticmodalParentEl"),!!b&&b)},transition:function(a,b,c,d){switch(d=null==d?n.noop:d,c.type){case"fade":"show"==b?a.fadeIn(c.speed,d):a.fadeOut(c.speed,d);break;case"none":"show"==b?a.show():a.hide(),d();}},prepare_body:function(a,b){n(".arcticmodal-close",a.body).unbind("click.arcticmodal").bind("click.arcticmodal",function(){return b.arcticmodal("close"),!1})},init_el:function(d,a){var b=d.data("arcticmodal");if(!b){if(b=a,o++,b.modalID=o,b.overlay.block=n(b.overlay.tpl),b.overlay.block.css(b.overlay.css),b.container.block=n(b.container.tpl),b.body=n(".arcticmodal-container_i2",b.container.block),a.clone?b.body.html(d.clone(!0)):(d.before("
"),b.body.html(d)),q.prepare_body(b,d),b.closeOnOverlayClick&&b.overlay.block.add(b.container.block).click(function(a){h.isEventOut(n(">*",b.body),a)&&d.arcticmodal("close")}),b.container.block.data("arcticmodalParentEl",d),d.data("arcticmodal",b),p=n.merge(p,d),n.proxy(e.show,d)(),"html"==b.type)return d;if(null!=b.ajax.beforeSend){var c=b.ajax.beforeSend;delete b.ajax.beforeSend}if(null!=b.ajax.success){var f=b.ajax.success;delete b.ajax.success}if(null!=b.ajax.error){var g=b.ajax.error;delete b.ajax.error}var j=n.extend(!0,{url:b.url,beforeSend:function(){null==c?b.body.html("
"):c(b,d)},success:function(c){d.trigger("afterLoading"),b.afterLoading(b,d,c),null==f?b.body.html(c):f(b,d,c),q.prepare_body(b,d),d.trigger("afterLoadingOnShow"),b.afterLoadingOnShow(b,d,c)},error:function(){d.trigger("errorLoading"),b.errorLoading(b,d),null==g?(b.body.html(b.errors.tpl),n(".arcticmodal-error",b.body).html(b.errors.ajax_unsuccessful_load),n(".arcticmodal-close",b.body).click(function(){return d.arcticmodal("close"),!1}),b.errors.autoclose_delay&&setTimeout(function(){d.arcticmodal("close")},b.errors.autoclose_delay)):g(b,d)}},b.ajax);b.ajax_request=n.ajax(j),d.data("arcticmodal",b)}},init:function(b){if(b=n.extend(!0,{},a,b),!n.isFunction(this))return this.each(function(){q.init_el(n(this),n.extend(!0,{},b))});if(null==b)return void n.error("jquery.arcticmodal: Uncorrect parameters");if(""==b.type)return void n.error("jquery.arcticmodal: Don't set parameter \"type\"");switch(b.type){case"html":if(""==b.content)return void n.error("jquery.arcticmodal: Don't set parameter \"content\"");var e=b.content;return b.content="",q.init_el(n(e),b);case"ajax":return""==b.url?void n.error("jquery.arcticmodal: Don't set parameter \"url\""):q.init_el(n("
"),b);}}},e={show:function(){var a=q.getParentEl(this);if(!1===a)return void n.error("jquery.arcticmodal: Uncorrect call");var b=a.data("arcticmodal");if(b.overlay.block.hide(),b.container.block.hide(),n("BODY").append(b.overlay.block),n("BODY").append(b.container.block),b.beforeOpen(b,a),a.trigger("beforeOpen"),"hidden"!=b.wrap.css("overflow")){b.wrap.data("arcticmodalOverflow",b.wrap.css("overflow"));var c=b.wrap.outerWidth(!0);b.wrap.css("overflow","hidden");var d=b.wrap.outerWidth(!0);d!=c&&b.wrap.css("marginRight",d-c+"px")}return p.not(a).each(function(){var a=n(this).data("arcticmodal");a.overlay.block.hide()}),q.transition(b.overlay.block,"show",1*")),b.overlay.block.remove(),b.container.block.remove(),a.data("arcticmodal",null),n(".arcticmodal-container").length||(b.wrap.data("arcticmodalOverflow")&&b.wrap.css("overflow",b.wrap.data("arcticmodalOverflow")),b.wrap.css("marginRight",0))}),"ajax"==b.type&&b.ajax_request.abort(),p=p.not(a))})},setDefault:function(b){n.extend(!0,a,b)}};n(function(){a.wrap=n(document.all&&!document.querySelector?"html":"body")}),n(document).bind("keyup.arcticmodal",function(d){var a=p.last();if(a.length){var b=a.data("arcticmodal");b.closeOnEsc&&27===d.keyCode&&a.arcticmodal("close")}}),n.arcticmodal=n.fn.arcticmodal=function(a){return e[a]?e[a].apply(this,Array.prototype.slice.call(arguments,1)):"object"!=typeof a&&a?void n.error("jquery.arcticmodal: Method "+a+" does not exist"):q.init.apply(this,arguments)}}(jQuery)}var debugMode="undefined"!=typeof debugFlatPM&&debugFlatPM,duplicateMode="undefined"!=typeof duplicateFlatPM&&duplicateFlatPM,countMode="undefined"!=typeof countFlatPM&&countFlatPM;document["wri"+"te"]=function(a){let b=document.createElement("div");jQuery(document.currentScript).after(b),flatPM_setHTML(b,a),jQuery(b).contents().unwrap()};function flatPM_sticky(c,d,e=0){function f(){if(null==a){let b=getComputedStyle(g,""),c="";for(let a=0;a=b.top-h?b.top-h{const d=c.split("=");return d[0]===a?decodeURIComponent(d[1]):b},""),c=""==b?void 0:b;return c}function flatPM_testCookie(){let a="test_56445";try{return localStorage.setItem(a,a),localStorage.removeItem(a),!0}catch(a){return!1}}function flatPM_grep(a,b,c){return jQuery.grep(a,(a,d)=>c?d==b:0==(d+1)%b)}function flatPM_random(a,b){return Math.floor(Math.random()*(b-a+1))+a}
");let k=document.querySelector(".flat_pm_modal[data-id-modal=\""+a.ID+"\"]");if(-1===d.indexOf("go"+"oglesyndication")?flatPM_setHTML(k,d):jQuery(k).html(b+d),"px"==a.how.popup.px_s)e.bind(h,()=>{e.scrollTop()>a.how.popup.after&&(e.unbind(h),f.unbind(i),j())}),void 0!==a.how.popup.close_window&&"true"==a.how.popup.close_window&&f.bind(i,()=>{e.unbind(h),f.unbind(i),j()});else{let b=setTimeout(()=>{f.unbind(i),j()},1e3*a.how.popup.after);void 0!==a.how.popup.close_window&&"true"==a.how.popup.close_window&&f.bind(i,()=>{clearTimeout(b),f.unbind(i),j()})}f.on("click",".flat_pm_modal .flat_pm_crs",()=>{jQuery.arcticmodal("close")})}if(void 0!==a.how.outgoing){let b,c="0"==a.how.outgoing.indent?"":" style=\"bottom:"+a.how.outgoing.indent+"px\"",e="true"==a.how.outgoing.cross?"":"",f=jQuery(window),g="scroll.out"+a.ID,h=void 0===flatPM_getCookie("flat_out_"+a.ID+"_mb")||"false"!=flatPM_getCookie("flat_out_"+a.ID+"_mb"),i=document.createElement("div"),j=jQuery("body"),k=()=>{void 0!==a.how.outgoing.cookie&&"false"==a.how.outgoing.cookie&&h&&(jQuery(".flat_pm_out[data-id-out=\""+a.ID+"\"]").addClass("show"),j.on("click",".flat_pm_out[data-id-out=\""+a.ID+"\"] .flat_pm_crs",function(){flatPM_setCookie("flat_out_"+a.ID+"_mb",!1)})),(void 0===a.how.outgoing.cookie||"false"!=a.how.outgoing.cookie)&&jQuery(".flat_pm_out[data-id-out=\""+a.ID+"\"]").addClass("show")};switch(a.how.outgoing.whence){case"1":b="top";break;case"2":b="bottom";break;case"3":b="left";break;case"4":b="right";}jQuery("body > *").eq(0).before("
"+e+"
");let m=document.querySelector(".flat_pm_out[data-id-out=\""+a.ID+"\"]");-1===d.indexOf("go"+"oglesyndication")?flatPM_setHTML(m,d):jQuery(m).html(e+d),"px"==a.how.outgoing.px_s?f.bind(g,()=>{f.scrollTop()>a.how.outgoing.after&&(f.unbind(g),k())}):setTimeout(()=>{k()},1e3*a.how.outgoing.after),j.on("click",".flat_pm_out .flat_pm_crs",function(){jQuery(this).parent().removeClass("show").addClass("closed")})}countMode&&(flat_count["block_"+a.ID]={},flat_count["block_"+a.ID].count=1,flat_count["block_"+a.ID].click=0,flat_count["block_"+a.ID].id=a.ID)}catch(a){console.warn(a)}}function flatPM_start(){let a=flat_pm_arr.length;if(0==a)return flat_pm_arr=[],void jQuery(".flat_pm_start, .flat_pm_end").remove();flat_body=flat_body||jQuery("body"),!flat_counter&&countMode&&(flat_counter=!0,flat_body.on("click","[data-flat-id]",function(){let a=jQuery(this),b=a.attr("data-flat-id");flat_count["block_"+b].click++}),flat_body.on("mouseenter","[data-flat-id] iframe",function(){let a=jQuery(this),b=a.closest("[data-flat-id]").attr("data-flat-id");flat_iframe=b}).on("mouseleave","[data-flat-id] iframe",function(){flat_iframe=-1}),jQuery(window).on("beforeunload",()=>{jQuery.isEmptyObject(flat_count)||jQuery.ajax({async:!1,type:"POST",url:ajaxUrlFlatPM,dataType:"json",data:{action:"flat_pm_ajax",data_me:{method:"flat_pm_block_counter",arr:flat_count}}})}).on("blur",()=>{-1!=flat_iframe&&flat_count["block_"+flat_iframe].click++})),flat_userVars.init();for(let b=0;bflat_userVars.textlen||void 0!==a.chapter_sub&&a.chapter_subflat_userVars.titlelen||void 0!==a.title_sub&&a.title_subc&&cc&&c>d&&(b=flatPM_addDays(b,-1)),b>e||cd||c-1!=flat_userVars.referer.indexOf(a))||void 0!==a.referer.referer_disabled&&-1!=a.referer.referer_disabled.findIndex(a=>-1!=flat_userVars.referer.indexOf(a)))&&(c=!0),c||void 0===a.browser||(void 0===a.browser.browser_enabled||-1!=a.browser.browser_enabled.indexOf(flat_userVars.browser))&&(void 0===a.browser.browser_disabled||-1==a.browser.browser_disabled.indexOf(flat_userVars.browser)))){if(c&&void 0!==a.browser&&void 0!==a.browser.browser_enabled&&-1!=a.browser.browser_enabled.indexOf(flat_userVars.browser)&&(c=!1),!c&&(void 0!==a.geo||void 0!==a.role)&&(""==flat_userVars.ccode||""==flat_userVars.country||""==flat_userVars.city||""==flat_userVars.role)){flat_pm_then.push(a),flatPM_setWrap(a),flat_body.hasClass("flat_pm_block_geo_role")||(flat_body.addClass("flat_pm_block_geo_role"),flatPM_ajax("flat_pm_block_geo_role")),c=!0}c||(flatPM_setWrap(a),flatPM_next(a))}}}let b=jQuery(".flatPM_sticky");b.each(function(){let a=jQuery(this),b=a.data("height")||350,c=a.data("top");a.wrap("
");let d=a.parent()[0];flatPM_sticky(this,d,c)}),debugMode||countMode||jQuery("[data-flat-id]:not([data-id-out]):not([data-id-modal])").contents().unwrap(),flat_pm_arr=[],jQuery(".flat_pm_start, .flat_pm_end").remove()}

Меня часто спрашивают, как управлять ножками GPIO микроконтроллера AVR, и как читать их состояние. Несмотря на то, что это довольно просто, описано не только в даташите, но и во многих статьях, например [1], поток вопросов не уменьшается.

Все порты AVR (под AVR обычно подразумеваются микроконтроллеры популярных серий megaAVR и tinyAVR компании Atmel, например ATmega32A, примененный в макетной плате AVR-USB-MEGA16) обладают функционалом чтение-модификация-запись (read-modify-write) при работе с выводами микроконтроллера как обычными портами ввода вывода (general purpose I/O ports, GPIO). При этом можно поменять направление (задать что это – вход или выход) для каждой отдельной ножки GPIO (вывода порта AVR). Каждая ножка также имеет симметричный выходной буфер (два CMOS-ключа, один на +, другой на -), который может выдавать выходной ток от плюса питания (VCC, обычно +5V, drive source), или от земли (GND, минус источника питания, sink source). Мощность выходного драйвера более чем достаточна для прямого управления светодиодом (LED). Также для всех выводов портов, настроенных как вход, можно селективно подключить внутренний верхний нагрузочный резистор (pull-up), встроенный прямо в кристалл микроконтроллера. Все выводы имеют защищающие от перенапряжения диоды, подключенные к VCC и GND.

Упрощенная схема порта AVR, настроенного как вход (состояние по умолчанию, DDRxn == 0).

Упрощенная схема порта AVR, настроенного как выход (DDRxn == 1).

Примечания к рисункам:

Pxn – имя ножки порта микроконтроллера, где x буква порта (A, B, C или D), n номер разряда порта (7 .. 0).
Cpin – паразитная емкость порта.
VCC – напряжение питания.

Rpu – отключаемый нагрузочный верхний резистор (pull-up).
PORTxn – бит n регистра PORTx.
PINxn – бит n регистра PINx.
DDRxn – бит n регистра DDRx.

Каждый порт микроконтроллера AVR (обычно имеют имена A, B и иногда C или даже D) имеет 8 разрядов, каждый из которых привязан к определенной ножке корпуса. Каждый порт имеет три специальных регистра DDRx, PORTx и PINx (где x соответствует букве порта A, B, C или D). Назначение регистров:

DDRx Настройка разрядов порта x на вход или выход.
PORTx Управление состоянием выходов порта x (если соответствующий разряд настроен как выход), или подключением внутреннего pull-up резистора (если соответствующий разряд настроен как вход).
PINx Чтение логических уровней разрядов порта x.

Регистр DDRx выбирает направление работы каждой отдельной ножки порта. Если в разряд регистра DDRx записана лог. 1, то соответствующая ножка будет сконфигурирована как выход.

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

Если в разряд DDRx записан 0, и в соответствующий разряд PORTx записана 1, то порт не только сконфигурирован как вход, но к нему также еще и подключен внутренний верхний нагрузочный резистор (input pull-up).

Если в разряд DDRx записан 0, и в соответствующий разряд PORTx также записан 0, то порт сконфигурирован как вход с высоким входным сопротивлением, что соответствует отключенному выходному состоянию (третье состояние), при этом можно для искусственного создания логических уровней подключать внешние нагрузочные резисторы (pull-up верхний на VCC или pull-down нижний на GND).

Если в разряд PORTx записана лог. 1, и в соответствующий разряд DDRx записана лог. 1, то порт сконфигурирован как выход, и на выходе будет лог. 1. Если в разряд PORTx записана лог.

0, и в соответствующий разряд DDRx записана лог. 1, то порт сконфигурирован как выход, и на выходе будет лог. 0. Т. е.

биты PORTx управляют состоянием выходного порта, при условии что в соответствующий порту разряд DDRx записана лог. 1.

Логическая схема организации порта ввода/вывода (GPIO) микроконтроллера ATmega32A.

[Предварительная настройка проекта для доступа к GPIO]

Теперь перейдем к языку C – как можно управлять ножками микроконтроллера AVR? Когда Вы используете WinAVR GCC (или соответствующий GCC-тулчейн от Atmel, который устанавливается вместе с AVR Studio или Atmel Studio), то нужно правильно настроить проект, чтобы нормально распознавались имена регистров AVR (имена DDRA, DDRB, PORTA, PORTB, PINA, PINB и другие), и преобразовывались в нужные адреса. Для этого имеется специальный файл заголовка io.h, который находится в папках инсталляции WinAVR (к примеру, это может быть папка c: WinAVR-20100110 avr include avr) или соответствующего тулчейна Atmel (для Atmel Studio это может быть папка c: Program Files Atmel Atmel Studio 6.0 extensions Atmel AVRGCC 3.3.2.31 AVRToolchain avr include avr). Для того, чтобы подключить заголовок io.h, нужно в код модуля (например файл main.c) добавить строку с директивой #include, и в настройках проекта правильно указать тип микроконтроллера. Вот как указывается директива #include:

Имя (модель) процессора AVR может быть указано либо прямо в файле Makefile определением переменной DEVICE, или просто в настройках проекта (AVR Studio или Atmel Studio). Вот пример куска Makefile, где задан тип микроконтроллера ATmega32:

F_CPU = 12000000 DEVICE = atmega32 BOOTLOADER_ADDRESS = 0x7000 ..

Вот так настраивается тип микроконтроллера в свойствах проекта AVR Studio 4.19 (меню Project -> Configuration Options):

Вот так настраивается тип микроконтроллера в свойствах проекта Atmel Studio 6.0 (меню Project -> Properties):

После того, как подключен файл io.h и задан тип микроконтроллера для проекта, можно в коде программы на языке C использовать имена регистров AVR. Через имена регистров осуществляется доступ к портам GPIO микроконтроллера.

[Как работать с портами AVR как с выходами]

1 2 DDRD = 0xFF; //настройка всех выводов порта D как выходов PORTD = 0x0F; //вывод в разряды порта D значений 00001111

Если у нас есть 8-битная переменная i, то мы можем присвоить её значение регистру PORTx, и тем самым установить ножки микроконтроллера в состояние, соответствующее значению переменной i:

1 2 3 uint8_t i=0x54; PORTD = i;

Здесь показана работа с портом D, но Вы точно так же можете работать и с портами A, B, C, если будете использовать соответствующие имена регистров (DDRA, PORTA, DDRB, PORTB и т. п.).

[Как работать с портами AVR как со входами]

Вот как можно прочитать логические уровни из порта D в переменную i:

1 2 DDRD = 0; //настройка всех выводов порта D как входов i = PIND; //прочитать все 8 ножек порта D и сохранить значение в i

[Как работать с отдельными ножками порта AVR как с выходами]

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

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

Например, нам нужно, чтобы у порта D разряды 0, 2, 4, 6 (PD0, PD2, PD4, PD6) работали как входы (input), и разряды 1, 3, 5, 7 (PD1, PD3, PD5, PD7) работали как выходы (output). Тогда мы можем использовать код наподобие следующего:

1 2 3 4 5 6 DDRD=0; // Сброс всех битов в 0 (00000000). DDRD |= (1

Источник: http://microsin.net/programming/avr/accessing-avr-ports-with-winavr-gcc.html

Программирование Arduino на C в AVR Studio

Arduino — это готовая отладочная плата и очень простой язык для программирования, упрощающая начало работы с микроконтроллерами ценой размера и быстродействия программ. С недавних пор Atmel добавила поддержку бутлоадера Arduino в AVR Studio, то есть можно писать загружать без программатора программы написанные хоть на C, хоть на C++, хоть на Assembler.

Более того — можно в AVR Studio писать код на языке Processing/Wiring.
Рекомендую начать чтение статьи с update’а в конце!
В этой статье мы предлагаем пошаговую инструкцию по установке ПО для программирования Arduino с использованием AVR Studio. За основу мы брали обзор расширений AVR Studio с сайта easyelectronics.ru.

Все примеры мы будем запускать на нашей плате EduBoard.

Установка Arduino IDE

Мы используем версию Arduino 1.5.2. Скачать ее можно на официальном сайте. Последняя версия (1.6.2-r2 на момент написания статьи) по каким-то причинам не работает с микроконтроллером Atmega8.
Вы скачаете zip-архив с уже развернутой средой. Останется только распаковать ее в директорию с программами.

Установка Atmel Studio

Скачать среду можно на официальном сайте Atmel. Для этого вам потребуется регистрация на сайте. Обязательно пройдите ее — это понадобится и при установке расширений. Обратите внимание, что она работает только под Windows! Подойдут для нашей задачи только версии выше 6.0, то есть 6.1, либо 6.2!

Установка расширения Arduino для AVR Studio

Выберите пункт меню Tools -> Extension Manager. Перед вами откроется окно:

Extension Manager

Выберите пункт меню «Arduino IDE for Atmel Studio 6.1 & 6.2″ и нажмите кнопку «Download». Вам предложат ввести логин/пароль. Сделайте это и не забудьте поставить галочку «Remeber me». После этого через браузер начнется загрузка файла ArduinoForAtmelStudio.msi. После загрузки установите его и перезапустите AVR Studio.

Настройка AVR Studio

После перезапуска вы увидите окно первоначальной настройки расширения. В этом окне необходимо указать директорию в которой установлена среда Arduino.

Configuring Visual Micro

Вы увидите, что вас появилась новая панель инструментов:

Панель Visual Micro

На ней необходимо выбрать плату, которую вы используете (в нашем случае Arduino NG or older w/ ATmega8) и номер COM-порта к которому она подключена. Больше настроек доступно в меню Tools -> Visual Micro.

Инструменты Visual Micro

Начало работы

В AVR Stuidio запустите менеджер проектов «New Project». Выберите сценарий Arduino Sketch:

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

В файле проекта с расширением .ino вы увидите стандартный формат Arduino-скетча. На плате к выводу d13 подключен светодиод. Это вывод микроконтроллера PB5. Для примера помигаем этим светодиодом. Удалите весь код и введите вот это:

#include #define F_CPU 16000000UL //16MHz #include int main(void) { DDRB |= 1

Источник: http://www.customelectronics.ru/programmirovanie-arduino-na-c-v-avr-studio/

Переходим от Arduino к программированию ATtiny13 на C

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

Поэтому, если чувствуется, что Arduino становится тесноват — можно не только перейти на 32-битные контроллеры (например, STM32), но и попробовать более низкоуровневое программирование контроллеров.

Уходя ближе «к железу» — программировать придётся на более близком к железу уровне — и если это не ассемблер, то уж язык программирования Си — точно.

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

У такого стандартного программирования микроконтроллеров есть существенное преимущество перед использованием Arduino-вских скетчей. Однако, за низкоуровневый полный контроль и возможность использовать все ресурсы микроконтроллера, приходится расплачиваться долгим и внимательным изучением документации (datasheet-а) на микроконтроллер. Т.е.

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

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

Для примера, возьмём меленький, простой и дешёвый контроллер ATtiny13.

8-битный AVR микроконтроллер с 1 КБ программируемой Flash памяти — RISC архитектура — 120 команд, (большинство выполняется за один такт) — 32 8-битных регистра общего применения — 1 КБ программируемой Flash памяти программы — 64 байта EEPROM памяти данных, (до 100 000 циклов записи/стирания) — 64 байта SRAM памяти (статическое ОЗУ) — Один 8-разрядный таймер/счётчик с отдельным предделителем и два ШИМ канала — 4-канальный 10-битный АЦП со встроенным ИОН — Программируемый сторожевой таймер (watchdog) со встроенным генератором — Встроенный аналоговый компаратор — Внутрисистемное программирование через SPI порт — Внешние и внутренние источники прерывания Корпусное исполнение: — 8-выводные PDIP и SOIC корпуса: 6 программируемых линий ввода-вывода Диапазон напряжения питания, частота: 1.8 – 5.5В (для ATtiny13V) — до 10МГц 2.7 – 5.5В (для ATtiny13) — до 20МГц

Выводы микроконтроллера ATtiny13:

Как видим, микросхема микроконтроллера — маленькая — всего 8 ножек. Чтобы заставить её работать — нужно просто воткнуть её в макетную плату, подтянуть RESET (первый пин — на схеме обозначается — PB5) к шине питания через 10-килоомный резистор и подать питание — например, 5V снятые с пинов питания контроллера Arduino / CraftDuino.
В статье , уже подробно расписано как нужно подключить микроконтроллер ATtiny13 к контроллеру Arduino или CraftDuino, чтобы его можно было программировать через выводы микросхемы FT232RL используя режим bit-bang (режим управления отдельными выводам микросхемы). Поэтому сразу переходим к софтовой части. Раз решили программировать «по-взрослому», то и среда разработки нужна «взрослая».

Идём на сайт -a, и скачиваем свежую версию .

Atmel Studio — (наследница AVR Studio) — это бесплатная среда разработки для микроконтроллеров Atmel.

Сама IDE должна быть знакома, т.к. используется оболочка от Microsoft Visual Studio, однако следует обратить внимание, что в качестве компилятора используется GCC. После установки, на рабочем столе появится ярлык с симпатичной красной божьей коровкой. Запускаем IDE и привычным образом, быстренько создаём проект.

File -> New -> Project…

Выбираем С/С++ и GCC C Executable Project, пишем имя проекта, например, blink 🙂

Затем, среда предложит выбрать тип используемого микроконтроллера — выбираем ATtiny13.

Всё — шаблонный файл уже создан и можно начинать программировать:

Предлагаемый шаблон программы — напоминает что-то :

#include int main(void) { while(1) { //TODO:: Please write your application code } }
Описание работы портов микроконтроллера и используемых для насткройки и работы регистров, очень подробно приводится в документации на микроконтроллер — . Как увидим далее, конфигурирование и работа с портами сводится к установке соответствующих битов в нужных регистрах микроконтроллера. Если вы уже имели дело с установкой/проверкой/очисткой битов (работа с битовыми масками), то вам будет проще разобраться в происходящем. Но, на всякий случай, напомню: чтобы установить бит N — нужно выполнить побитовое ИЛИ с числом, где этот бит установлен (чтобы получить такое число — мы побитово сдвигаем влево единицу на заданное число позиций). Соответственно, чтобы сбросить бит N — нужно выполнить побитовое И с числом в котором установлены все биты кроме заданного (чтобы получить такое «интвертированное число» — мы сначала получаем число в котором бит установлен, а потом применяем к нему операцию побитового НЕ). value |= 1

Источник: http://robocraft.ru/blog/arduino/3423.html

Литература и программы для AVR. Шаг №1

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

Например от простого термометра в статье №6 до более сложного устройства –  фазосдвигателя на ATmega8 и другое. Выбор языка для дальнейшего программирования, это дело вкуса.

Я лично склонился к Си, и если кто-то захочет его осваивать то могу сказать, что первым делом необходимо прочитать классику:
–  Язык программирования Си. Керниган Б. Ритчи Д. Стандарт ANSI.
Хочется сказать о стандартах языка, всего их пять.

Предпоследний это С99, но хочется отметить что книга описанная стандартами С90 и ANSI, если не обращать на тонкости внимания, то они особо не отличаются, и для начального уровня подойдут просто идеально.

Что касается последнего стандарта 2011 года С11, то он сильно приближен к объектно-ориентированному языку и это уже совсем отдельный разговор. Итак с момента появления языка Си было пять стандартов «K&R» C (1978), ANSI C (1989), C90 (1990), C99 (1999), C11 (2011). Смело можно начинать изучение предпоследних трех. Для закрепления материала, и рассмотрение стандартов С90 и С99  могу порекомендовать:

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

В дальнейшем в программах, кое-где будут фрагменты кода ассемблера. Литературу я не привожу, т.к. сам особо не читал, да и то что используется можно “подглядеть” в интернете. Конечно же  знание данного языка приветствуется.

Но тут, как говорится – дело вкуса.

Для освоения выше приведенной литературы нам необходима программа, для консольного программирования. Лично я выбрал CodeBlocks -это кроссплатформенная интегрированная среда разработки (IDE), а главное бесплатная. Информацию можно взять прямо с родного сайта http://www.codeblocks.

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

В архиве с графической оболочкой идет бесплатный компилятор minGW (Minimalist GNU for Windows).

Теперь перейдем к литературе для освоения микроконтроллеров AVR. Осмелюсь посоветовать следующую книгу:  — программирование на языке Си для AVR и PIC микроконтроллеров Шпак Ю.А. 2-е издание, 2011 г.   Есть более ранние издание, выбор за вами. Данная книга описывает архитектуру микроконтроллеров как AVR так и PIC, начальное описание языков Си, ассемблер и примеры.

Следующая книга и последняя и наверное самая основная это справочник: –  Микроконтроллеры AVR семейств Tiny и Mega фирмы Atmel Евстифеев А.В. Где описываются все тонкости и режимы работы с регистрами.

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

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

Ниже перечислены программы для работы непосредственно с микроконтроллерами:
– WinAVR – это набор инструментальных средств для программирования RISC-микроконтроллеров семейства AVR на языке Си.

В комплект входит компилятор GNU GCC, а также программа Notepad. В этой среде создаются рабочие файлы с расширением .hex.

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

– AVR Studio – среда которая используется для загрузки созданных программ в программатор, а также эмуляция выполнения программ на том или ином микроконтроллере.

  Данная среда разработана непосредственно самой компанией Atmel. Является бесплатной и довольно неплохой. По этой ссылке http://www.atmel.com вы всегда сможете скачать данную программу.

А также более детально ознакомится c контроллерами и разработками.

По программам в принципе все. Работу с ними детально описывает, все тот же Шпак.

Хочется сказать пару слов о программаторе — это устройство с помощью которого Вы «заливаете» непосредственно вашу программу в микроконтроллер а также изменяете регистры.  Самый простой stk200 либо “программатор пять проводков”, (рис. слева) т.е.

работа непосредственно с портом lpt. Для начинающих, данная возможность — это способ попробовать свои силы не производя затраты на аппаратный программатор. Конечно стоит отметить что здесь присутствует риск “прожечь” данный порт. Благо есть интернет и куча решений.

Я приобрел последовательный USB программатор ISP  (рис. слева) для внутрисхемного программирования. Также существуют параллельные программаторы, где имеется два уровня напряжений 5 и 12 В. Они более функциональные и дорогие))). Выбор за Вами.

Ну и последнее, можно попробовать свои силы не имея контроллеров вообще под рукой или перед их прошивкой, да и сборкой проекта вообще, используя PROTEUS (например подключение ЖКИ к МК статья №27), что представляет собой пакет программ для автоматизированного проектирования (САПР) электронных схем.

На этом и остановимся. Выше были перечислены литература а также программы, которые мы будем использовать в дальнейшем для написания кода и разработки устройств. В следующей статье (№2) перейдем к рассмотрению настроечного файла Makefile программы WinAVR, перед тем как мы с Вами напишем первую программу и зальем в наш «камень». На этом Все. Всем пока.

Просмотрено 6086 раз.

Источник: http://www.ap-impulse.ru/literatura-i-programmy/