Руководство по встроенному языку

You’re surrounded by hundreds of electronic devices today that would have looked out of place even a few decades ago, from the TV and the DVD player to the microwave and digital camera. Most of us think these to be ordinary devices that perform simple functions. But have you ever wondered how they work? As simple as these devices seem on the surface, they each have complex microprocessors (or microcontrollers) running inside their body. These microprocessors perform operations when requested. Like when you press the button on your digital camera to take a photo, the microprocessor will perform the functions necessary to capture the image and store it. The microprocessor’s functions are controlled, guided and overseen by the embedded system software. Just like your computer is controlled by the Operating System (like Windows), your camera is controlled by the embedded software. The embedded software and embedded hardware form an embedded system.

Embedded C is the most popular embedded software language in the world. Most embedded software is written in Embedded C. Embedded C is very similar to C- if you know C, you won’t have a problem learning Embedded C. This course can help you learn about the microprocessor environment. You’ll learn how to write embedded software programs, in low level assembly language. Embedded C takes it a step further and lets you write C like programs, suitable for the microprocessor environment. You can take this introductory course on C to learn more about high level programming.

In this basic Embedded C tutorial, we’re going to give you some info on the important embedded programming concepts. We’ll also demonstrate how Embedded C is different from ordinary C.

Basic Concepts of Embedded C and Embedded Programming

Embedded C, even if it’s similar to C, and embedded languages in general requires a different kind of thought process to use. Embedded systems, like cameras or TV boxes, are simple computers that are designed to perform a single specific task. They are also designed to be efficient and cheap when performing their task. For example, they aren’t supposed to use a lot of power to operate and they are supposed to be as cheap as possible. As an embedded system programmer, you will have simple hardware to work with. You will have very little RAM, ROM and very little processing power and stack space. Your goal is to write programs that are able to leverage this limited processing power for maximum effect. As an ordinary C programmer, you don’t have as many constraints.

The reason why most embedded systems use Embedded C as a programming language is because Embedded C lies somewhere between being a high level language and a low level language. Embedded C, unlike low level assembly languages, is portable. It can run on a wide variety of processors, regardless of their architecture. Unlike high level languages, Embedded C requires less resources to run and isn’t as complex. Some experts estimate that C is 20% more efficient than a modern language like C++. Another advantage of Embedded C is that it is comparatively easy to debug.

Embedded C Compilers

There are a variety of different compilers on the market, manufactured by different companies, that use Embedded C. One of the more popular ones is the Keil compiler. Because of this, Embedded C is also sometimes known as Keil C.

Embedded C has several keywords that are not present in C (learn more about the concept of keywords in this course). These keywords are associated with operations needed by microprocessors. You will need to be familiar with all of them to be able to write Embedded C programs. In this tutorial, we’ll show you some of the common ones, like data or idata, bdata and using:

idata/data: The data keyword will store a declared variable in the internal (i) memory of your microprocessor. Take a look at the example below:

unsigned char data a;

Here, the unsigned char declaration is like a normal C declaration. We just added the data keyword, which tells the microcontroller to store the unsigned char a in the internal data memory.

bdata: The bdata keyword lets you store a declared variable in the bit addressable memory. Take a look at this example:

unsigned char bdata a;

This is similar to the data declaration we showed you above. You have to access bdata variables in a different way, however.

Using: This keyword lets you execute a function by letting it access a register bank. There are three possible values: 1, 2 and 3.

void yourfunction () using 1
{
//statement
}

Here, your function called yourfunction will using the register bank at 1. Register banks are a part of the bank-switching technique used by microprocessors. This is an advanced concept, which we cover in more detail in our course.

Embedded C vs. Regular C

While we have discussed the main differences between Embedded C and Regular C, there is another major difference that drastically affects the structure of an Embedded C program and sets it apart from an ordinary C program. When you write a regular C program, you access it from within your operating system software, run it and then, when you’re done, you exit back into your operating system (learn more about writing your own C program with this course). With an Embedded C program, you have no operating system to fall back on! Your program will, for all intents and purposes, act like the operating system for the embedded device.

Obviously, your program can never stop running, as this will cause the device it’s supposed to be operating to crash. Therefore, every Embedded C program must have a structured loop that keeps it running constantly. You can use a simple for loop or a while loop to do that. A normal Embedded C program will follow this format, for example:

void main ()
{
//initialize
while (condition) {
//keep doing this
}
}

As you know, every C program starts with a main declaration. It’s the same with Embedded C. The only difference is that an infinite loop will have to be included, and it will contain the most important parts of the code.

Now that you’re familiar with the basics of embedded system programming and Embedded C go ahead and try it out for yourself!

Разработка встроенного ПО: введение

Привет, Хабр! Представляю вашему вниманию перевод статей 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 или флэш, или нет?

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

Теги:

Похожие темы (5)

Главная фишка языка 1С — весь программный код пишется на русском языке! Цветовое оформление в примерах полностью соответствует раскраске программного кода в среде 1С: Предприятие 8.