Золотовский Д.В. Учебный курс для новичков по микроконтроллерам AVR. Часть 1
Подождите немного. Документ загружается.
AVR. Учебный курс.
Постановка задачи
Этот пост можно смело считать кратким описанием того безобразия, что я
называю AVR. Учебный Курс.
Сразу оговорюсь, что курс у меня краткий. Он не будет содержать в себе
исчерпывающий материал по теме. Я не буду делать упор на подробности,
потому что их все равно все не опишешь — полное описание на ту же
ATMega16 занимает порядка 400 страниц убористого текста.
Моя основная цель — дать понять, как это работает, как это использовать,
как это настроить, чтобы получить хоть что-то рабочее. Поэтому я много
уделяю алгоритмам, организации логики программ — классическим приемам
программирования. Стараюсь не забывать и про оптимизацию.
Это, возможно, будет неинтересно тем, кто учился на программистов, но вот
электронщикам, изучающим программирование, это редко дают даже в
ВУЗах.
Поэтому я дам лишь один-два самых ходовых примера по каждой теме,
которые пригодятся в первую очередь, а остальное тебе придется додумывать
по ходу пьесы самому. Впрочем, всегда можно будет спросить в
комментариях.
О комментариях
Их обычно много, их пишут адекватные люди и в них часто можно найти
массу дополнений и уточнений по моим статьям. А также ответы на многие
смежные вопросы . Так что прежде чем что то спрашивать, рекомендую
прочитать, хотя бы бегло, комменты. Возможно, в них уже будет ответ на
твой вопрос. Ну и отвечать я стараюсь на все комментарии к любому посту
журнала.
О структуре курса
Курс начинается с ассемблера. Так как я считаю, что без понимания работы
контроллера на уровне машинных инструкций невозможно научиться писать
надежные и быстрые программы. Знание ассемблера позволяет в разы
быстрей находить баги и ошибки в собственных программах. Да и вообще, на
самом деле, ассемблер куда проще изучать, чем тот же Си. Просто потому,
что там все действия видны как на ладони. Достаточно только прогнать по
ним отладчик AVR Studio.
В Си же есть ряд мощных проблем с оптимизатором да и вообще, будучи
более высокоуровневым, Си намного более сложен по структуре, чем
ассемблер. И изучать его с нуля сложней — т.к. в случае, когда очевидная
конструкция работает “не так” не знаешь куда бежать и за что хвататься. А
если знаешь ассемблер, то открываешь дизасм, прогоняешь мутный участок
и все баги выходят из сумрака.
После ассемблерной части сразу же начинается Сишный курс. Он написан
так, как если бы все изучать с самого нуля. Даже без ассемблера, но к асму я
там все равно постоянно обращаюсь. Так что рекомендую проходить все
последовательно.
Некоторый материал может попасться раньше или позже чем он реально
понадобиться, так что советую вдумчиво читать его по ходу обучения и
бегло проглядеть от начала и до конца.
О ошибках
Я их совершаю, более того, я их совершаю часто. Могут быть как опечатки и
технические неточности, так и откровенные ляпы. Так что не стоит все
написанное у меня рассматривать как истину в последней инстанции. Если
что-то не работает или работает не так как надо, то открывай даташит и
сравнивай параметры — я мог и ошибиться. Если это так, то сообщи мне в
комментариях — исправлю. Если в чём-то сомневаешься — спрашивай,
разберёмся.
В даташитах, кстати, тоже бывают ошибки. Более того, они бывают и в самих
контроллерах на аппаратном уровне. Особенно в первых ревизиях. Об
ошибках контроллеров и прошлых ревизий даташитов есть отдельный
раздел. Называется ERRATA, находится в конце каждого даташита на
контроллер. Советую внимательно его прочитать.
О языках.
Вся техническая документация написана на английском. Но незнание языка
— это не отмазка. Сейчас 21 век, а еще в конце 20го века, крошечная
программка Сократ’97 умела вполне сносно переводить с английского на
русский, не литературно, конечно, но понять суть можно было. За 13 лет
технологии машинного перевода продвинулись весьма значительно .Так что
читайте мануалы.
О примерах
Примеры я даю в первой половине курса на ассемблере, во второй на Си и,
если речь идет об алгоритме, в Си-подобном псевдокоде.
Однако, примеры просты и перегнать из Си в ассемблер и наоборот
несложно. Особенно когда речь идет о инициализации и запуске в работу
периферии.
Отмазки в стиле “Я знаю Си(ассемблер), а а вот ассемблер(си) не понимаю,
есть пример на Си(асме)?” идут от нежелания чуть-чуть подумать,
внимательно посмотреть на то что и куда записывается. Не важно на каком
языке что записано! Главное, что и в какие порты пихается, это понять
можно с первого взгляда, на чём бы не писалось — на асме, си, паскале или
бейсике.
Я, конечно, отвечаю и на такие вопросы. Но настроение мне это не
повышает.
О телепатии
Я ей не владею. Так что если что-то не работает, то не надо мне пытаться
съесть мозг вопросами. Куда лучше приложить тот код, который не
работает. Причем не стоит его копировать и вставлять в форму ввода
комментариев — его весь перекосит, половина символов закосит под хтмл
тэги, а читать все это вовсе будет невозможно. Да и проблема может быть
вовсе и не там где тебе кажется.
Возьми и пихни в архив весь проект из AVR Studio и залей на какой-нибудь
файлхостинг (их миллион сейчас. Тот же narod.yandex.ru), а мне в комменты
скинь ссылочку на архив и описание проблемы. Быстрей будет.
А раньше было же не так! Что случилось с старыми статьями?
А как собачки — сдохли и все. Старый курс был весьма коряв, в нем
содержались мощные дыры, а также не было единой отладочной платформы.
Сейчас, с появлением демоплатыPinboard эта проблема решена.
Плюс, за два года его существования, под градом вопросов и комментариев,
была заново переосмыслена структура курса. Посему старые статьи были
подвергнуты жесткой редактуре под новые реалии. Думаю, так стало лучше и
логичней.
Чего не будет в курсе.
У меня гарантированно не будет ботвы вида “смотрите как легко и просто
мигнуть диодиком”, “скопируйте эту строку в свою программу и на LCD
увидите текст. Это просто”. Я не буду показывать, как писать программы для
AVR на примере какого-нибудь, тебе не нужного устройства, вроде
частотомера или музыкального звонка. Захочешь частотомер — сам потом
сделаешь, уже без моей помощи.
Что будет в курсе.
В курсе будут куски типовых решений, ассемблерные и сишные процедуры.
Будет подробный разбор, как работает и как сделать ту или иную
конструкцию, такие, как цикл, флаговый автомат, табличный переход. Как
организовать многопоточное выполнение кода и псевдомногозадачность. Как
оседлать прерывания и всякие извраты с кодом. Как запрятать два-три байта
и как выиграть два три такта. Как взорвать мозг тому, кто захочет
разобраться в твоем коде и как сделать так, чтобы все было логично и просто.
Разумеется, я покажу и как мигнуть, и как на LCD экран вывести что-то. А
также множество других не менее интересных приемов. Но будет это далеко
не сразу, а лишь тогда, когда выданной тебе информации будет достаточно
для представления себе полной картины происходящего действа.
Вплоть до того как и в каком порядке перемещаются байты по регистрам.
Поэтому первым делом будет разобрана работа ядра контроллера. Как и в
каком порядке он щелкает байты, а уж потом как дрыгает ножками.
И ты удивишься тому, какой же простой и логичный язык Ассемблера. А
потом, без проблем, пересядешь на Си. Освоив, тем самым надфиль и
кувалду микроконтроллерного программирования. Я в этом уверен.
А если что, то я всегда рядом, стоит только оставить комментарий.
P.S. Курс находится в стадии непрерывного развития и усовершенствования,
статьи дополняются и перетасовываются для получения более логичной и
последовательной структуры. Причем делается это втихую, без уведомления.
Рекомендую периодически проглядывать курс с начала и до конца, возможны
изменения.
C vs Assembler
Если ты впервые столкнулся с микроконтроллерами, то наверняка у тебя стал
выбор – на чем писать.
На Си или на Ассемблере. Выбор не прост, не зря программисты
однокристальщики раскололись на два непримиримых лагеря. Одни с пеной
у рта доказывают, что те, кто пишут на Си лохи изнеженные, а настоящий
брутальный кодер должен воспринимать только ассемблер. Другие же,
упираясь, доказывают, что на ассемблере разве что лампочками помигать
можно, а какой либо серьёзный проект делать на низком уровне невозможно.
Но, истина, как всегда, находится посредине. Каждый уважающий себя
программер должен знать ассемблер, а вот писать должен на том, что
более подходит под масштаб задачи. Особенно это касается
микроконтроллеров.
Assembler+
Парадоксально, но под микроконтроллеры писать на ассемблере ничуть не
сложней чем на Си. В самом деле, программирование контроллера
неотделимо от его железа. А когда пишешь на ассемблере, то обращаешься
со всей периферией контроллера напрямую, видишь, что происходит и как
это происходит. Главное, что при этом ты четко понимаешь что, как и
зачем ты делаешь. Очень легко отлаживать и работа программы как на
ладони.
Да и сам ассемблер изучается очень быстро, за считанные дни. Достаточно
постоянно иметь перед глазами систему команд и навык программирования
алгоритмов. А соответствующее состояние мозга, когда начинаешь мыслить
ассемблерными конструкциями наступает очень быстро.
C-
А вот с высокими языками, например с Си, ситуация уже куда хуже. Да,
повторить какой нибудь пример из обучалки, вроде вывода строки на
дисплей, Сях куда проще, подключил нужную библиотеку, набрал
стандартную команду и вот тебе результат. Но это только так кажется. На
самом деле, стоит чуть вильнуть в сторону, как начинается темный лес.
Особенно когда дело начинает касаться адресации разных видов памяти,
Напомню, что у AVR, как и подавляющего числа МК, память разделена на
код и данные и адреса у них в разных адресных пространствах, о которых
стандарт Си ничего не знает, ведь он расчитан на некий универсальный
вычислитель. А тут приходится вводить всякие модификаторы,
квалификаторы и без яростного курения мануалов разобраться в этих
примочках бывает очень сложно. Особенно работа с памятью осложняется
тем, что программа то работает в том и другом случае, но вот если
неправильно указать тип памяти, то оперативка забьется константами и в
дальнейшем программу скрючит в самый неподходящий момент. Вот и
найди такой глюк при работе на прерываниях, использованию
многопоточных процессов, использующих одни и те же ресурсы.
Вот и получается, что программа вроде компилится, но работает совершенно
не так как тебе нужно, а почему непонятно. Или мусор начинает вываливать
вместо данных, или перезагружается невпопад. Или работает, но иногда
чудит. Пытаешься смотреть, что происходит в системных регистрах и
переменных, а там каша какая то. Пытаешься понять, как это получилось и
тупо загниваешь, т.к. не можешь найти концы.
В таких случаях обычно открывают листинг и смотрят, что там происходит в
коде на уровне команд процессора, но вот засада — без знания ассемблера
там делать нечего! Зато, если понимаешь, как работает программа на уровне
команд, то найти багу вроде срыва стека или нарушения атомарного доступа
проще простого.
Ну и такие гадкие вещи как overhead. Программа на Си требует значительно
больше оперативной памяти, значительно больше места во flash памяти,
работает куда медленней, чем ассемблерная программа. И если на обычном
компьютере с его гигагерцами частот, гигабайтами оперативки и дисковой
памяти это не столь критично, то вот для контроллера с жалкими
килобайтами флеша, у которого частота порой не превышает 16 мегагерц, а
оперативки и килобайта не наберется, такой расход ресурсов более чем
критичен.
Кроме того существуют такие контроллеры как ATTiny 1x у которых либо
вообще нет оперативки, либо она такая мизерная, что даже стек там сделан
аппаратным. Так что на Си там ничего написать в принципе нельзя.
Assembler+
Представь, что ты прораб, а компилятор это банда джамшутов. И вот надо
проделать дырку в стене. Даёшь ты джамшутам отвертку и говоришь —
ковыряйте. Проковыряют они отверткой бетонную стену? Конечно
проковыряют, вопрос лишь времени и прочности отвёртки. Отвёртка
сточится (читай памяти процессора или быстродействия не хватит)? Не беда
— дадим джамшутам отвёртку побольше, благо разница в цене между
большой отверткой и маленькой копеечная. В самом деле, зачем прорабу,
руководителю, знать такие низкоуровневые тонкости, как прочность и
толщина бетонной стены, типы инструмента. Главное дать задание и
проконтроллировать выполнение, а джамшуты все сделают сами.
Задача решается? Да! Эффективно это решение? Совершенно нет! А почему?
А потому что прораб не знал, что бетон твердый и отверткой его
проковырять сложно. А будь прораб сам когда- то рабочим, пусть даже не
профи, но своими руками положил плитку, посверлил дырки, то впредь таких
идиотских заданий не давал. Конечно, нашего прораба можно и в шараге
выучить, дав ему всю теорию строения стен, инструмента, материалов. Но ты
представь, сколько это сухой теории придется перелопатить, чтобы чутье
было интуитивным, на уровне спинного мозга? Проще дать в руки
инструмент и отправить сверлить стены. Практика — лучший учитель.
Также и с ассемблером. Хочешь писать эффективные программы на
высокоуровневом языке — изучи хотя бы один ассемблер, попиши на нем
немного. Чтобы потом, глядя на любую Сишную строку, представлять себе,
во что это в итоге компилируется и как обрабатывается контроллером. Очень
помогает в отладке и написании, а уж про ревесирование чужих программ я
вообще не говорю.
Assembler-
Но засиживаться в ассемблерщиках и стараться все сделать на нем далеко не
обязательно. Ассемблерный код тяжелей переносить с контроллера на
контроллер, в нем при переносе можно наделать много незначительных, но
тем не менее фатальных ошибок. Отладка которых занимает много времени.
Большие проекты писать на ассемблере то еще развлечение. На ассемблере
трудно сделать полноценную библиотеку, подключаемую куда угодно.
Ассемблер жестко привязан к конкретному семейству контроллеров.
С+
Си хорош за счет огромного числа готового кода, который можно очень
легко и удобно подключать и использовать в своих нуждах. За большую
читабельность алгоритмов. За возможность взять и перетащить код,
например, с AVR на ARM без особых проблем. Или с AVR на PIC.
Разумеется, для этого надо уметь правильно писать на Си, выделяя все
аппаратно зависимые части в HAL.
Общий расклад примерно таков, что использование высокоуровневого языка
на контроллерах с обьемом памяти меньше 8 килобайт является избыточным.
Тут эффективней писать все на Ассемблере. Особенно если проект
подразумевает не просто мигание светодиодом.
8-16 килобайт тут уже зависит от задачи, а вот пытаться писать на
ассемблере прошивку более 16 килобайт можно, но это напоминает
прокладку тоннеля под Ла-Маншем с помощью зубила.
В общем, знать надо и то и другое. Настоятельно тебе рекомендую начать
изучать МК с ассемблера. А как только поймешь, что на асме можешь
реализовать все что угодно, любой алгоритм. Когда досконально
прочувствуешь работу стека, прерываний, организацию переходов и
ветвлений. Когда разные трюки и хитрости, вроде игр с адресами возврата из
прерываний и процедур, переходами и конечными автоматами на таблицах и
всякие извраты будут вызывать лишь интерес, но никак не взрыв мозга из
серии “Аааа как это работает??? Не понимаю?!!”
Вот тогда и можно изучать Си. Причем, изучать его с дебагером в руках. Не
просто изучить синтаксис (там то как раз все элементарно), а понять,что и
как делает компилятор из твоего исходника. Поржать над его тупостью или
наоборот поудивляться извратам искуственного интелекта. Понять, как
компилятор делает ветвления, как организует циклы, как идет работа с
разными типами данных, как ведется оптимизация. Где ему лучше помочь,
написав в ассемблерном стиле, а где не критично и можно во всю ширь
использовать языковые возможности Си.
А вот начать изучение ассемблера после Си, мало кому удается. Си
расслабляет, становится лень и впадлу. Скомпилировалось? Работает? Ну и
ладно. А то, что там быдловский код, так на то наплевать.
А как же бейсик, паскаль и прочие языки? Они тоже есть на AVR?
Конечно есть, например BascomAVR или MicroPASCAL и во многих
случаях там все проще и приятней. Не стоит прельщаться видимой
простотой. Она же обернется тем, что потом все равно придется переходить
на Си.
Дело в том, что мир микроконтроллеров далеко не ограничивается одним
семейством. Постоянно появляются новые виды контроллеров, развиваются