Привет, Хабр! Представляю вашему вниманию перевод статей Chris Svec, оригинал здесь. Публикуется с разрешения автора по лицензии CC-A-NC-ND.

Embedded software engineering 101: введение

Я запускаю цикл статей по обучению разработке встроенного программного обеспечения. Мы начнем с описания простого микроконтроллера, и после того, как Вы поймете, как он работает, разовьем это до понимания работы относительно сложных систем, таких как Fitbit или Nest.
Я назвал эту серию Embedded Software Engineering 101, и она начинается с этой недели прямо здесь в этом блоге.

Продолжайте читать для дальнейших объяснений и подробностей.


Одни строительные блоки на других строительных блоках.

Я работаю со встроенными системами и разрабатываю микросхемы уже более 14 лет. Мне нравятся встроенные системы — железо, софт и ограничения, которые связывают их вместе.
Любительская электроника и такие идеи, как Arduino, Adafruit и Sparkfun дали возможность легко накидать что-то из железа и софта за выходные (или месяц, или семестр), создав что новое, интересное и может быть даже полезное.

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

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

Я хочу учить людей, как писать встроенное ПО для такого рода систем. Я уже давно вынашивал эту идею курса/руководства/книги/блога «Embedded Software Engineering 101», и благодаря блогу Embedded.fm начинаю ее реализацию сейчас.

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

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

Embedded Software Engineering 101 предназначен для:

1. Выпускников вузов в сфере компьютерных наук, компьютерной инженерии или электроники, интересующихся встроенными системами.
2. Электронщиков-любителей, желающих более глубоко понять, как работает их система на Arduino, и узнать, как им двигаться дальше (и нужно ли!).
3. Профессиональных программистов без опыта со встроенными системами, желающих сместиться вниз по технологическому стеку и понимать, как они работают.
4. Инженеров, работающих со встроенными системами и желающих понять, чем занимаются их коллеги-программисты.

Что я имею в виду, говоря, что я «человек фундаментального типа»? Ричард Фейнман, физик-обладатель Нобелевской премии и отличный рассказчик, выразил это наилучшим образом: «Чего не могу воссоздать, того не понимаю».

Так вот, я не Фейнман, но я уверен, что лучший способ понять систему — это начать с основ. Вооруженные этим пониманием, вы сможете создавать простые встроенные системы с простым софтом. И поняв сначала очень простую программу, вы сможете развивать это, создавая более сложное ПО по мере роста опыта.

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

Конечно мы должны задаться вопросом — где правильный уровень чтобы начать с этих самых «основ»? Транзисторы и логические вентили? Нет, это слишком низкий уровень для старта со встроенным ПО. Подключение к распространенным датчикам? Нет, это слишком высокий уровень, требуется слишком много знаний чтобы начать с этого.

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

Так что с этого мы и начнем в следующей статье.

Предупреждение о предвзятости: в прошлой жизни я был архитектором/разработчиком процессоров. Начать этот цикл с понимания как работает ЦПУ может быть не лучшим способом для понимания встроенных систем, но именно так работает мой мозг. Обязательно попробуйте другие курсы/руководства и т.д., если не станете понимать этот после нескольких статей.

Embedded software engineering 101: основы микроконтроллера

Мы начнем наше путешествие Embedded Software Egineering 101 со скромного микроконтроллера. Микроконтроллер (или микропроцессор) это основной строительный блок всех вычислительных систем, встроенных и прочих.

МК кажется довольно сложным, но он состоит из трех простых вещей: инструкции, регистры и память. Инструкции это те штуки, которые микроконтроллер знает как выполнять. Простой МК умеет выполнять не так уж много — у него может быть например 20 или 30 инструкций. В дальнейшем в этом цикле я буду использовать микроконтроллер MSP430 от Texas Instruments, у которого только 27 инструкций.


Просто фотография МК (TI MSP430F5529)

Эти 27 инструкций — единственное, что MSP430 умеет делать. Он может сложить два числа, вычесть из одного числа другое, переместить числа с одного места в другое или выполнить 24 другие простые операции. 27 операций может показаться недостаточно чтобы сделать что-либо полезное, но на самом деле их хватит с избытком, чтобы выполнить любую мыслимую программу.

Хорошо, значит у микроконтроллера есть инструкции, которые делают что-то с числами. Но где находятся эти числа? Регистры и память! Инструкции оперируют числами, которые хранятся в регистрах и памяти.

Регистры это очень быстрое хранилище, содержащее числа, которыми оперируют инструкции. Можно думать о них, как об используемом инструкциями блокноте. МК содержит немного регистров, обычно 8-32. Например, у MSP430 16 регистров.

Память это тоже хранилище для чисел, но она гораздо объемнее и медленнее чем регистры. У микроконтроллера может быть 64 кБ, 256 кБ или даже более 1 МБ памяти. У MSP430F5529 около 128 кБ памяти; это более чем в 8000 раз превосходит количество его регистров!

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

Давайте рассмотрим вымышленный, но характерный пример микроконтроллера.

Пусть скажем у нашего МК 4 регистра и 8 ячеек памяти. Регистры обычно называют как-нибудь креативно, например «R0», «R1» и т.д., поступим и мы так же. На ячейки памяти обычно ссылаются по их номерам, также называемым адресами памяти, начиная нумерацию с 0. Вот так будут выглядеть наши регистры и память:



И теперь я помещу в них некоторые значения:



Теперь нашему вымышленному микроконтроллеру нужны какие-нибудь инструкции.
Совокупность инструкций, которые знает МК, называется его набором инструкций. Пусть скажем в наборе будет три инструкции: ADD (сложить), SUB (сокращение от «subtract» — вычесть) и MOVE (переместить). Инструкции должны получать откуда-то числа, которыми они оперируют, и также помещать куда-то свои результаты, так что некоторые из них содержат информацию о том, где находятся входные и выходные данные.

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

ADD регИст, регПрм
Инструкция ADD добавляет значение регистра «регИст» к значению регистра «регПрм» и сохраняет результат в регистре «регПрм»
Резюме: регПрм = регИст + регПрм
Пример: ADD R1, R2 выполняет операцию R2 = R1 + R2

Это общепринято в инструкциях — использовать один из источников также в роли приемника, как делает инструкция ADD, используя регПрм в качестве и источника и приемника данных.

«ADD R1, R2» — это язык ассемблер для микроконтроллера, это нативный язык программирования МК.

Давайте определим SUB в том же стиле:

SUB регИст, регПрм
Инструкция SUB вычитает значение регистра «регИст» из значения регистра «регПрм» и сохраняет результат в регистре «регПрм»
Резюме: регПрм = регПрм — регИст
Пример: SUB R3, R0 выполняет операцию R0 = R0 — R3

И наконец пусть у инструкции MOVE один источник и один приемник, и либо:

• оба аргумента регистры, либо
• один — регистр и один — ячейка памяти.

Руководство по набору инструкций будет гласить:

1. MOVE регИст, регПрм
2. MOVE памИст, регПрм
3. MOVE регИст, памПрм
Инструкция MOVE копирует данные из аргумента Ист в аргумент Прм.
Резюме: есть три типа инструкции MOVE
1. регПрм = регИст
2. регПрм = мемИст
3. мемПрм = регИст
Пример: я покажу примеры инструкции MOVE ниже в этом посте.

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

Название «move» может создать впечатление, что операнд-источник инструкции уничтожается или очищается, но на самом деле он остается в покое, модифицируется только приемник.
Давайте пройдемся по нескольким примерам используя наш вымышленный микроконтроллер.
На старте наши регистры и память выглядят так:



Теперь выполним на МК следующую инструкцию:

ADD R1, R2

Она берет значение R1, складывает его со значением R2 и сохраняет результат в R2. Процессор выполняет большую часть инструкций за одну операцию, но я разобью выполнение каждой инструкции ADD, SUB и MOVE на несколько шагов стрелкой "=>" ведущей через замены (регистр/память => значение):

R2 = R1 + R2 =>
R2 = 37 + 100 =>
R2 = 137

После выполнения этой инструкции память неизменна, но регистры теперь выглядят следующим образом, с изменившимся значением написанным красным:



Обратите внимание, что R1 неизменен; изменился только регистр-приемник R2.
Следующей давайте попробуем инструкцию SUB:

SUB R3, R0

Она берет значение R3, вычитает его из значения R0, и сохраняет результат в R0:

R0 = R0 - R3 =>
R0 = 42 - 2 =>
R0 = 40

После выполнения этой инструкции память неизменна, но регистры теперь выглядят таким образом:



И наконец давайте попробуем пару версий инструкции MOVE:

MOVE R2, R0

Эта инструкция MOVE копирует в R0 значение R2:

R0 = R2 =>
R0 = 137

И теперь регистры выглядят так:



Дальше мы скопируем регистр в память:

MOVE R3, [3]

Эта инструкция MOVE копирует в ячейку памяти 3 значение R3. Квадратными скобками в нашем наборе инструкций обозначаются ячейки памяти.

[3] = R3 =>
[3] = 2

Регистры неизменны, но память меняется:



И для нашего последнего примера мы скопируем значение из памяти в регистр:

MOVE [6], R0

Здесь значение ячейки памяти 6 копируется в регистр R0:

R0 = [6] =>
R0 = 1

Память неизменна, а регистры теперь выглядят следующим образом:



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

Конечно я опустил множество деталей. Например, как МК получает инструкции для выполнения?

Есть ли более интересные инструкции, чем только простые математические и инструкции копирования? Память это то же самое, что RAM или флэш, или нет?

Мы ответим на эти вопросы в следующей статье.