Встраиваемые системы. Проектирование приложений на микроконтроллерах семейства 68HC12/HCS12 с применением языка С

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

Для того чтобы начать программировать микроконтроллеры 68НС12 на Си, мы должны сначала изучить основные конструкции этого языка, которые и рассматриваются в следующих параграфах главы 3. Следует заметить, что в этих параграфах приведен лишь минимально необходимый набор сведений по Си. Для более полного знакомства с этим языком программирования читателю следует обратиться к специальной литературе. Список рекомендуемых авторами изданий приведен в конце главы.

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

3.1.1. Глобальные и локальные переменные

Каждая объявленная в начале программы переменная должна храниться в одной или нескольких ячейках памяти в течение времени исполнения программы. В микроконтроллерах переменные могут размещаться в ОЗУ, ПЗУ и регистрах центрального процессора.

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

Объявление различных идентификаторов в начале программы — особенность языка Си по сравнению с языком ассемблер. Служебные слова, которые будут сопровождать объявление идентификатора, определяют правила доступа к переменной, функции, макросу или структуре, которая именована этим идентификатором. Не все идентификаторы будут доступны из любого места программы на Си. Подробное описание служебных слов для объявления классов хранения переменных выходит за рамки этой главы. Вы можете найти его в [3].

В микроконтроллерах семейства 68НС12, переменные размещаются в ячейках памяти ПЗУ или ОЗУ. Переменная, которая не изменяет своего значения в течение выполнения программы, именуется константой и хранится в ПЗУ. Переменная, значение которой изменяется в процессе исполнения программы, должна храниться в ОЗУ. Например, предположим, что некоторый контроллер связан с датчиком температуры посредством аналого цифрового преобразователя. Прикладная программа должна постоянно обновлять значение температуры в памяти контроллера. Для этого объявим переменную с именем temp (от слова temperature — температура) и разместим ее в ОЗУ МК. Приведенный ниже фрагмент программы на Си демонстрирует, как обратиться к размещенной в ОЗУ переменной temp и отобразить ее значение на дисплее. Заметим, что номера строк в приводимых фрагментах программ не являются частью записи операторов языка Си и не должны присутствовать в исходном тексте программы, подлежащем компиляции. Они введены искусственно для ссылки на отдельные операторы при обсуждении конструкций языка Си.

1 while (1)

2 {

3  temp = *(unsigned char volatile*)(0х1000); 

4  printf(The current temperature is %d\n, temp); 

5 }

Данный фрагмент кода предполагает, что переменная с именем temp создана (объявлена) ранее, и также ранее реализован фрагмент кода на Си для опроса аналого цифрового преобразователя с целью обновления значения температуры. Для определенности в строке 3 мы сами присваиваем этой переменной значение $1000 в шестнадцатеричном коде (или 4096 в десятичной системе счисления). Префикс 0x служит в Си для обозначения шестнадцатеричной системы счисления. Не следует тревожиться, если не все записи в данном примере ясны для Вас. Пройдет немного времени, Вы закончите изучение материалов данной главы, и все рассмотренные примеры станут для Вас простыми и понятными.

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

В этом параграфе мы познакомимся с Вами с понятием «функция». Мы покажем Вам, как в языке Си определить функцию, как передать в функцию численные значения параметров и как получить после выполнения функции рассчитанные ею значения переменных.

3.4.1. Что такое функция?

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

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

В соответствии с приведенной стратегией составления большой программы, каждая функция должна обладать тремя свойствами: независимостью, гибкостью и переносимостью. Функция должна быть относительно независима от другого программного кода, поскольку эта функция в дальнейшем может быть использована различными программистами в данном проекте или даже в другом проекте. Возвращаясь к примеру, предположим, что Вам предложили написать функцию, которая устраняет шумовую составляющую входного аналогового сигнала (цифровой фильтр). Ваша программа цифрового фильтра будет использоваться многими соисполнителями проекта для устранения шума различных входных сигналов. Следовательно, Ваша программа, оформленная как функция, должна обеспечивать возможность ее вызова из любого места большой программы (свойство независимости) и должна легко настраиваться на прием сигнала с различных портов МК (свойство гибкости). Термин «относительно независима» в начале этого параграфа мы применили потому, что функция может получать от ранее исполненного программного кода некоторые численные значения, которые будет использовать при своей работе. Например, в Вашу функцию могут передаваться имя порта ввода и номер линии, на которой присутствует сигнал, который подлежит цифровой фильтрации. Вы значительно увеличите гибкость своего решения, если предусмотрите возможность изменения частотного диапазона шумовой составляющей сигнала, которая будет устранена после исполнения программного кода Вашей функции.

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

3.4.2. Основная программа

Основная программа — это особый тип функции, ее отличие от других функций заключается в том, что она исполняется, когда запускают программу с определенным именем. Корректно написанная основная программа работает как программа «управленец» (менеджер высшего звена). Текст основной функции main.c отражает структуру всей прикладной программы, при этом не затрагивая специфических особенностей отдельных задач по управлению объектом. Мы можем представить основную программу в роли управляющего, который контролирует выполнение отдельных «команд» управления путем запуска программ функций. Предположим, что мы хотим выполнить задачи с первой по n-ую. Для этого оформлены n функций. Тогда мы запишем основную программу, в которой будут последовательно вызываться эти функции:

1  void main(void)

2  {

3  function_one();

4  function_two();

5  function_three();

6  :

7  :

8  :

9  function_n(); 

10 }

Строка 1 содержит идентификатор функции main. Служебное слово void в круглых скобках информирует о том, что данная функция не требует входных аргументов. Строки с третьей по девятую содержат операторы вызова функций, причем каждая функция вызывается один раз. После завершения исполнения функции 1 начинается исполнение функции 2, затем функции 3 и так до конца программного фрагмента.

3.4.3. Прототипы функций

Любая функция перед тем, как в тексте программы будет записан ее программный код или оператор ее вызова, должна быть объявлена. Объявление функции в языке Си называют прототипом функции. Формат записи прототипа функции следующий:

тип возвращаемой переменной имя функции

 (<тип переменной1> <имя переменной1>,

 <тип переменной2> <имя переменной2>,

 :

 <тип переменной> <имя переменнойN>); 

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

Пример 1: int compute(int, int);

Пример 2: float change(char name, float number, int a);

Пример 3: double find(unsigned int, float, double);

В примере 1 функция compute использует два аргумента. Аргументы функции — это те переменные, которые необходимы для ее корректного исполнения. Спецификация типа аргументов функции приведена в круглых скобках. В данном случае указано, что функция compute будет использовать два целочисленных аргумента, т.е. при вызове функции ей должны быть указаны для целочисленных значения. Результатом действия функции compute будет вычисление значения некоторой переменной. Спецификация типа возвращаемой переменной приведена перед именем функции. В данном случае это тоже целочисленный 16 разрядный формат.

В примере 2 записан прототип функции change. Эта функция предполагает наличие трех аргументов: однобайтового целочисленного name, числа с именем number в формате с плавающей запятой и двухбайтового целого числа с именем a. Функция change должна возвратить значение переменной в формате с плавающей запятой. В примере 3 объявляется функция find с тремя аргументами, для которых указан тип данных, но не указаны имена.

При знакомстве с программами на Си Вы можете встретить прототип функции, в котором на первом месте указано слово extern:

extern not_here(int a, int b, int c)

Подобная запись означает, что определение функции not_here не включено в текст данного программного модуля (текущего файла), а располагается во внешнем модуле (другом файле), который будут объединен с текущим модулем при составлении конечного исполняемого кода программы.

Если функция была объявлена в тексте какого либо программного модуля, то она должна быть определена в этом же модуле или другом модуле, например в файле библиотеки. Мы обсудим правила определения функции в следующем параграфе, а пока приведем примеры вызова каждой из трех объявленных функций:

compute(23, 12);

change('b', 7.825, 2);

find(25, 5.1524, 23.54721);

Обратите внимание, спецификация типа возвращаемой переменной в записи вызова функции исчезла, а в поле аргументов появились записи их численных значений.

3.4.4. Описание функций

Каждая объявленная в начале некоторого программного модуля функция должна быть определена в этом модуле или в тексте программы другого модуля, который в процессе генерации исполняемого кода программы будет присоединен к текущему модулю. Функция может быть также определена в подключаемом файле стандартной библиотеки. Текст определения функции может быть записан в любом месте программного модуля, однако принято определения всех используемых функций располагать сразу за текстом основной программы main.c. Например, предположим, что объявленная в предыдущем параграфе функция compute вычисляет модуль вектора двух ортогональных составляющих a и b и возвращает его в переменной с именем result. Прототип функции:

int compute(int a, int b);

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

/*Функция compute: вычисляет модуль вектора по двум его ортогональным */

/*составляющим                             */

1 int compute(int a, int b)

2 {

3  int sum, result;

4  sum = a*a + b*b;

5  result=(int) (sqrt(sum));

6  return(result);

7 }

В приведенном примере строка 1 открывает определение функции, информируя компилятор о том, что имя функции compute, она использует для своей работы две целочисленных переменных и возвращает одну целочисленную переменную. Фигурная скобка в строке 2 открывает область операторов определяемой функции. В строке 3 объявляются локальные переменные, т.е. те переменные, которые используются только внутри функции. Это переменные sum и result. Операторы, расположенные в строках 4 и 5 выполняют заявленные в описании функции вычисления. Причем в строке 5 используется функция извлечения квадратного корня sqrt, которая определена в библиотеке математических вычислений. При компиляции эта библиотека должна быть обязательно присоединена к файлу с рассматриваемой функцией посредством специальных директив компилятора, которые мы рассмотрим в следующем параграфе. В строке 5 следует обратить внимание на оператор (int) перед вызовом функции извлечения квадратного корня. Этот оператор осуществляет преобразование типа данных к заявленному в прототипе функции compute целочисленному формату int, поскольку функция извлечения квадратного корня возвращает данные в другом формате. В строке 6 применен оператор возврата return, которые позволяет использовать значение переменной result другими операторами основной программы. Фигурная скобка в строке 7 завершает определение функции. Любые операторы, записанные после скобки, уже не будут ассоциироваться с функцией compute.

На основании анализа примера Вам следует запомнить, что каждая функция должна быть определена в строго заданном формате исходного текста программы. Сначала следует строка прототипа функции, в которой указывается имя функции, используемые переменные и возвращаемые переменные. В отличие от строки объявления функции, точка с запятой в конце строки прототипа при определении функции не ставятся. Затем следуют операторы функции, заключенные в фигурные скобки. Если в поле возвращаемой переменной прототипа указан ее тип, то последним оператором функции должен быть оператор return. Если же в поле возвращаемой переменной прототипа стоит служебное слово void, то функция не возвращает данных. Назначение такой функции — выполнить определенный набор действий по управлению периферийными модулями МК или внешними устройствами. Соответственно и оператор return в последней строке отсутствует.

3.4.5. Вызов функций, передача параметров, возврат полученных значений

Если функция объявлена и определена, то она может быть вызвана из любой части программного модуля. Для вызова функции необходимо записать ее имя и в круглых скобках указать значения параметров, если таковые присутствовали в прототипе функции. Например, для вызова функции compute с двумя параметрами запишем выражение:

magnitude = compute(12, 24)

В этом примере мы предполагаем, что переменная magnitude ранее была объявлена как целочисленная. После того, как функция была вызвана и выполнена, переменной magnitude будет присвоено значение 26. Истинный результат вычисления равен 26,832816. Именно это значение будет вычислено функцией извлечения квадратного корня sqrt. Однако перед присвоением переменной result этого значения производится смена формата представления данных, и дробная часть результата отбрасывается.

Для того, чтобы функция могла произвести требуемые вычисления, ей должны были быть переданы два параметра, которые мы указали в круглых скобках. Число параметров и формат их представления указываются в прототипе функции. В прототипе функции compute было также заявлено, что функция возвращает одно целочисленное значение. А может ли функция вернуть сразу несколько значений? Да может, если Вы корректно запишете прототип и определение функции. Для этого необходимо познакомиться с понятиями указателя и структуры, которые мы рассмотрим несколько позже. А пока лишь заметим, что функция может возвратить некоторый набор вычисленных значений посредством возврата начального адреса этих данных в памяти. Такой подход предполагает, что следующие программные фрагменты должны «знать» последовательность расположения данных в строке с указанного адреса, т.е. знать структуру представления данных в строке.

Директивы компилятора — это инструкции для программы компилятора, которые указывают ему каким образом следует обрабатывать исходный текст программы. Достаточно часто эти инструкции называют директивами препроцессора компилятора, акцентируя внимание пользователей на том, что эти директивы выполняют обработку исходного текста программы перед тем, как компилятор начнет генерацию ассемблерного текста программы. Известно 11 директив компилятора Си: #if, #ifdef, #ifndef, #else, #elif, #include, #define, #undef, #line, #error, #pragma. Из приведенного списка понятно, что директивы отмечаются символом # в первом знаке имени. Далее мы рассмотрим наиболее часто используемые директивы.

3.6.1. Директивы условной компиляции

Директивы #if, #ifdef, #ifndef, #else, #elif и #endif относятся к группе директив условной компиляции. Эти директивы используются для того, чтобы обозначенный фрагмент исходного текста программы можно было бы включать или не включать в компилируемый код в зависимости от выполнения некоторого наперед заданного условия. Такое действие может быть полезным, например, в процессе отладки программы. Тогда в отладочной версии программы промежуточные результаты вычислений будут выводиться на экран дисплея, в рабочей версии эти действия выполняться не будут.

Директивы #if и #endif обязательно используются вместе, чтобы обозначить начало и конец условно компилируемого текста программы. В строке с директивой #if записывается условие компиляции. Если это условие выполняется, то выражения, записанные в программе между директивами #if и #endif включаются в компилируемый текст программы. В противном случае эти выражения исключаются из генерированного кода программы. Например, в процессе отладки мы хотим вывести на экран указанную в тексте программы фразу:

1  #include 

2  #define DEBUG 1

3  void main(void)

4.  {

   :

   :

m  #if DEBUG

m+l  printf{"The program reached this point in the program\n"};

m+2 #endif

   :

   :

n  }

Для этого в строке 2 мы присвоили переменной DEBUG значение 1, используя директиву препроцессора #define. Эту директиву мы обсудим несколько позже, а пока констатируем, что единичное значение переменной DEBUG соответствует условию «истина» в строке m с директорией #if. Поэтому вызов функции prinf, записанный в строке m+1, будет включен в компилируемый текст программы. При ее исполнении мы увидим строку «The program reached this point in the program» на экране монитора. Обратите внимание, что точка с запятой в конце строки с директивой не ставится.

В рассмотренном выше примере предполагалось только две возможности: включать или не включать в исполняемый код программы определенный фрагмент. Директивы #else и #elif расширяют возможности условной компиляции и позволяют выбрать для компиляции один из нескольких фрагментов текста. Например:

1  #define М68НС11 0

2  #define М68НС12 1

3  #define М8051 2

4  #define Processor 1

5  void main(void)

6  {

7  #if Processor == М68НС11

8  Instruction(s) А

9  #elif processor == М68НС12

10  Instruction(s) В

11 #elif processor == М8051

12  Instruction(s) С

13 #else 

14  Instruction(s) D

15 #endif

16 }

В этом примере исходный текст программы написан таким образом, что он может быть компилирован для исполнения различными микроконтроллерами: Motorola HC11, Motorola HC12 и Intel 8051. Директивы #if, #elif и #else позволяют для данного сеанса компиляции выбрать конкретный тип МК. Для этого в строках 1…3 программы каждому символьному имени МК присвоено определенное численное значение. Далее в зависимости от выбранного типа МК переменной Processor присваивается желаемое значение. В примере мы собираемся компилировать программу для МК HC12, поэтому присвоили переменной Processor значение 1. В строке 7 компилятор проверяет истинность выражения, записанного в качестве условия директивы #if. Это условие не выполняется, поскольку Processor = 1 ≠ М68НС11 = 0. Поэтому группа инструкций Instruction(s) A не будет включена в программу. Далее в строке 9 компилятор обнаружит выполнение условия директивы #elif, и выражения Instruction(s) B будут присутствовать в конечном варианте программы. Условие строки 11 не выполняется, и группа инструкций Instruction(s) C в исполняемом коде программы присутствовать не будет. Если ни одно из условий для директив #elif не выполнено, то выражения, следующие за директивой #else, будут включены в программу автоматически.

Воспользуемся приведенной конструкцией условной компиляции. Допустим, мы предполагаем исполнение некоторого программного кода как на МК семейства Motorola HC11, так и на МК семейства Motorola 68HC12. Эти МК имеют различные карты памяти, и, соответственно, их порты ввода/вывода расположены по различным адресам. Для возможной адаптации текста программы к одному из типов МК воспользуемся директивами условной компиляции:

1 #if (Processor == 68НС11)

2 #define PORTA *(unsigned char volatile *) (0х1000)

3 #elsif (processor == 68НС12)

4 #define PORTA *(unsigned char volatile *) (0х0000)

5 #endif

В строках 1 и 3 располагаются директивы, которые проверяют условия компиляции. Значение переменной Processor должно быть определено выше по тексту программы директивой #define, или в подключаемом заголовочном файле. Строки 2 и 4 содержат директивы определения адреса для порта PORTA для двух различных типов МК. Директива #endif в строке 5 отмечает окончание фрагмента текста, который подлежит условной компиляции.

Директивы #ifdef и #ifndef используются для организации процесса компиляции при условии, что некоторая переменная с указанным именем была определена (#ifdef) или не определена (#ifndef) в тексте программы. Например:

1 #ifdef OUTPUT

2  Instruction(s) А

3 #else

4  Instruction(s) B

5 #endif

Если переменная с именем OUTPUT была определена в тексте программы до строки 1 с директивой #ifdef, то группа инструкций Instruction(s) А будет включена исполняемый код программы. В противном случае в конечный вариант программы будет включена группа инструкций Instruction(s) B.

Другой пример:

1 #ifndef OUTPUT

2  Instruction(s) А

3 #else

4  Instruction(s) B

5 #endif

Если переменная с именем OUTPUT не была определена в тексте программы до строки 1 с директивой #ifndef, то в конечный вариант программы будет включена группа инструкций Instruction(s) А. Если же эта переменная была определена ранее, то исполняемый код программы будет включена группа инструкций Instruction(s) B.

Директива #define используется в двух случаях. Во первых, она позволяет задать численные значения для символьных констант. Например, константе с именем HIGH необходимо присвоить значение 98:

#define HIGH 98

После записи этого выражения, если в тексте программы будет использовано имя HIGH, то при компиляции оно будет заменяться числом 98. Это удобно, поскольку в тексте программы имя HIGH может быть упомянуто сколь угодно большое число раз. Но для изменения его численного значения понадобится внести изменения только в одну строку с директивой #define.

Во вторых, директива #define используется для определения макросов. Макрос — это набор выражений языка Си, которому поставлено в соответствие определенное имя. При записи этого имени в программе, компилятор произведет замену этого имени обозначенным набором выражений. Например, Вам необходимо разрешить прерывания в МК. Для этого в МК 68HC12 используется команда ассемблера CLI. Для ее записи в тексте программы на Си определяют макрос:

#define CLI() asm("cli\n"); //разрешить маскируемые прерывания

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

CLI();

Кроме директивы определения символа или макроса #define, существует директива обратного действия #undef. Приведем пример ее использования:

#define VALUE 10

int number[VALUE]; 

#undef VALUE

В этом примере мы сначала назначили переменной VALUE значение 10. Далее в строке 2 мы воспользовались этим значением, чтобы определить массив целых чисел из 10 элементов. Далее переменная VALUE нам не нужна. И мы отменили ее определение директивой #undef.

Следующая рассматриваемая нами директива — это директива #include. Ранее мы установили, что эта директива используется для присоединения к разрабатываемому программному модулю другого файла. При этом у программиста появляется возможность использовать в тексте программы ранее объявленные переменные или вызывать функции, которые были определены в другом файле. Присоединяемые файлы называют заголовочными файлами. Например, следующая запись необходима для присоединения к разрабатываемой программе файла стандартных функций ввода/вывода:

#include 

Символы <> указывают на определенное место расположение файла stdio.h в папках директории компилятора.

Назначение директивы #error — упрощение процесса отладки разрабатываемой программы. Вы можете записать следующее выражение:

#error Programm made a logic error

Если в процессе выполнения программа достигнет приведенной строки, то на экран будет выведено приведенное сообщение.

Также для целей отладки используется директива #line. Эта директива отмечает номерами те инструкции программы, которые следуют за директивой. В результате, в процессе отладки можно идентифицировать тот фрагмент программы, который исполняется в текущий момент отладки.

Функции директивы #pragma определяются конкретным типом используемого компилятора. Для компилятора ICC12 эта директива определения сегментов данных и программы в исходном тексте программы на Си, для объявления подпрограмм прерывания, а также для присвоения желаемых значений ячейкам памяти с фиксированными адресами. Последнее позволяет инициализировать таблицу векторов прерываний в микроконтроллерах. Приведенный ниже пример демонстрирует использование директивы #pragma для объявления подпрограммы с именем TOISR в качестве подпрограммы прерывания:

#pragma interrupt_handler TOISR()

void TOISR(void);

Объявление подпрограммы TOISR как подпрограммы прерывания информирует компилятор о том, что в конце этой подпрограммы он должен расположить ассемблерную инструкцию возврата из прерывания rti. В конце обычной функции компилятор подставляет инструкцию возврата из подпрограммы rts.

Директива #pragma также используется для задания начального адреса расположения в памяти сегментов программного кода или кодов данных. Запишем вектор прерывания для подпрограммы TOISR в таблицу векторов прерывания МК. Мы знаем, что в соответствие с картой памяти МК, вектор прерывания по переполнению таймера должен располагаться по адресу 0x0B1E. Следующая запись помещает адрес начала подпрограммы TOISR в две ячейки памяти, начиная с адреса 0x0B1E:

#pragma abs_adress:0xB1E

void (*Timer_Overflow_interrupt_vector[])() = {TOISR}; 

#pragma end _abs_adress

Более подробно оформление подпрограмм прерывания мы обсудим в главе 4.

В языке Си существует несколько операторов, которые позволяют реализовать циклические вычисления (итерации). В этом параграфе мы рассмотрим программные конструкции циклов с операторами for, while, do while.

3.8.1. Оператор FOR

Оператор for предназначен для реализации циклов со счетчиком. В операторе for могут автоматически реализоваться сразу три операции: инициализация счётчика цикла, проверка его значения и модификация. Синтаксис оператора for:

for (<выражение1>; <выражение2>; <выражение3>)

 <операторы тела цикла>

Рассмотрим типичный пример реализации цикла с оператором for:

1 for(i = 0; i < 10; i = i++)

2 {

3  inst 1;

4  inst 2;

5  :

6  :

7  inst n;

8 }

В строке 1 записывается сам оператор for, за которым обязательно следуют три выражения, заключенные в круглые скобки. Выражение 1 вычисляется один и только один раз перед проверкой условия цикла. В нашем примере выражение 1 присваивает начальное значение переменной i. Выражения два и три могут иметь произвольный характер, но обычно их используют для проверки и модификации условия продолжения цикла. Выражение 2 задаёт условие продолжения цикла. Если его значение отлично от нуля (истина), будут выполнены операторы 3…7, составляющие тело цикла. После этого вычисляется выражение 3, указанное в скобках первой строки. В нашем примере выражение i = i++ = i + 1 осуществляет увеличение на 1 внутреннего счетчика циклов оператора for. Поэтому операторы тела цикла 3…7 будут выполняться 10 раз при значениях переменной цикла i от 0 до 9. В конце первого цикла значение i будет равно 1, в конце второго — i=2, и т.д. В конце десятого цикла переменная i примет значение 10. Далее начнется исполнение 11-ого цикла оператора for, но, проанализировав условие выражения 2 оператора for, программа выйдет из цикла, не исполняя операторов тела цикла.

Достаточно часто переменная счетчика циклов оператора for используется также в теле цикла этого оператора. Например, следующий программный фрагмент вычисляет таблицу соответствия значений температуры, записанных по шкале Цельсия и по шкале Фаренгейта, и последовательно выводит эти значения на экран монитора. Диапазон исходных значений температуры составляет от –10°C до +40°C.

1 for(k = –10; k <= 40; k++)

2 {

  //преобразовать значения температуры, измеренные по шкале Цельсия

  // к численному значению по шкале Фаренгейта

3  Temperature = k*9/5+32;

4  printf("Current temperature is \%f\n", Temperature);

5 }

Как видите, значение переменной k используется как параметр для вычисления новых значений температуры в теле цикла.

3.8.2. Оператор WHILE

Второй способ организации циклов использует оператор while. Применение оператора while иллюстрирует следующий программный фрагмент:

1 k = -10;

2 while(k < 40)

3 {

4  Temperature = k*9/5+32;

5  k++;

6  printf("Current temperature is \%f\n", Temperature);

7 }

В отличие от оператора for, переменная k, используемая в качестве счетчика циклов, должна быть инициализирована перед оператором while, например, в строке 1. Обратите внимание, что в строке 2 в скобках оператора while записано всего лишь одно выражение, которое называется условием цикла. Выполнение оператора while начинается с вычисления этого выражения. Если значение выражения отлично от нуля («истина»), то выполняются операторы 4…6 тела цикла. После выполнения операторов тела цикла снова вычисляется выражение условия и процесс повторяется. Таким образом, выполнение тела цикла происходит пока значение выражения условия цикла отлично от нуля («истина»).

Следует заметить, что если условие цикла не выполнится на первой итерации, то тело цикла не будет выполнено ни разу. Для того чтобы тело цикла выполнялось хотя бы один раз, в языке Си предусмотрен оператор do while, который рассматривается далее. Одним из результатов выполнения тела цикла, как правило, является изменение условия цикла, иначе цикл будет бесконечным. Но, естественно, возможны случаи, когда условие цикла зависит от результата работы вызываемой из выражения функции, или условие цикла меняется в функции обработки прерывания, которая активизируется во время выполнения тела цикла.

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

1 while (1)

2 {

3  Instructions //выполнение блока операторов

4 }

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

3.8.3. Оператор DO-WHILE

Третий способ организации циклов в Си использует оператор do-while. Синтаксис оператора do-while:

do {

 <операторы тела цикла>

} while (выражение 1); 

Пример записи вычисления таблицы соответствия температур с использованием оператора do while приведен ниже:

1 k = -10;

2 do

3 {

4  Temperature = k*9/5+32;

5  k++;

6  printf("Current temperature is \%f\n", Temperature);

7 }

8 while (k < 40)

Оператор do продолжает циклическое исполнение операторов тела цикла 4…6 до тех пор, пока значение выражения 1 не станет равным нулю («ложным»). Оператор do while похож на оператор while, но условие цикла в нём вычисляется и проверяется после очередного исполнения операторов тела цикла. Таким образом, операторы тела цикла выполняются, по крайней мере, один раз, даже если условие цикла заведомо ложно.

В этом параграфе мы обсудим примеры применения операторов if-then-else. Анализируя в главе 2 различные блок схемы алгоритмов управления, Вы часто наблюдали ситуацию, при которой некоторые действия должны были быть произведены только в том случае, если выполняется определенное условие. Мы рассмотрим четыре способа записи программного кода на Си, реализующего выполнение отдельных фрагментов программы при соблюдении заданного условия.

3.9.1. Оператор IF

Оператор if — это оператор выбора. Синтаксис оператора if:

if (<выражение>) {

 <оператор 1>

} else {

 <оператор 2>

}

Работа оператора if заключается в следующем. Сначала вычисляется заключенное в скобки выражение. Если его значение оказалось отличным от нуля («истина»), то выполняется оператор 1. Если используется служебное слово else и значение выражения равно нулю («ложь»), то выполняется оператор 2, указанный после else. Если значение выражения равно нулю («ложь»), а служебное слово else не указано, управление передаётся следующему за if оператору программы.

1 if (input == 0x00)

2 {

3  output = 0x0F;

4 }

5 …………………

В этом примере переменная input проверяется на равенство 0. Если текущее значение этой переменной действительно равно 0, то выполняется оператор, записанный в строке 3. Служебное слово else в данном примере отсутствует, поэтому, если текущее значение переменной input не равно 0, то программа осуществляет переход к строке 5. В качестве первого и второго операторов в условном операторе if можно применять блоки операторов. Приведенный выше пример может быть записан в сокращенной форме, без выделения фигурными скобками блока операторов условно выполняемых операторов:

1 if (input == 0x00)

2  output = 0x0F;

Применяя конструкции с оператором if, полезно знать, что программа принимает решение о выполнении того или иного блока операторов по значению внутренней логической переменной, которая устанавливается в 0 или в 1 по результату анализа заключенного в скобки условного выражения. Поэтому в качестве выражения условия программист может записать некоторую логическую формулу. В ходе исполнения конструкции if ее значение будет вычислено, по результату вычисления (0 или 1) будет принято решение о выполнении той или иной группы операторов. Частным случаем логического выражения условия является запись:

1 if (1)

2  output = 0x0F; 

Понятно, что действие output = 0x0F будет выполняться всегда, что иногда полезно на этапе отладки программы.

3.9.2. Оператор IF-ELSE

Многие алгоритмы управления требуют применения оператора if-else, который позволяет выполнить ту или иную группу операторов, в зависимости от результата анализа условия, следующего в скобках за оператором if. Допустим, встраиваемая система должна осуществлять управление кондиционером, анализируя текущее значение температуры воздуха. Эта задача может быть решена посредством записи следующего фрагмента программы:

1 if (input > 78) // если температура по шкале Фаренгейта

          //больше 78

2  air_condision = on; // то включить кондиционер

3 else

4  air_condision = off; //иначе выключить кондиционер

В этом примере переменная input содержит в себе код температуры окружающей среды, который программа должна подвергнуть сравнению с пороговым значением 78. Учитывая, что в процессе вычисления условия оператора if, программа возвращает значение внутренней логической переменной, то же действие можно записать, используя обратную логику:

1 if (input <= 78) //если температура меньше или равна 78

2  air_condision = off; //то выключить кондиционер

3 else 

4  air_condision = on; //иначе включить кондиционер

3.9.3. Оператор IF-ELSE IF-ELSE

Операторы if могут быть вложенными. В этом случае служебное слово else (если оно используется) связывается с последним оператором if, с которым ещё не было связано else. Во избежание путаницы с вложенными операторами, лучше пользоваться фигурными скобками или структурировать текст отступами для явного указания того, к какому из операторов if принадлежит слово else. Примеры применения вложенных операторов if– else приведены ниже:

1 if (input > 78)

2  air_condision = on; //включить кондиционер, если жарко

3 else

4  if (input > 58)

5  fan = on; //включить вентилятор,если душно, но

        //не жарко

6  else

7  heater = on; //включить обогреватель, если прохладно

8 …………

В этом примере программа должна различить, к какому из трех диапазонов принадлежит текущее значение температуры окружающей среды. Если температура превышает 78 градусов по Фаренгейту, то должен быть включен кондиционер. Если температура меньше 79 градусов, но больше 58, то следует оставить включенным только вентилятор, а если температура равна или ниже 58 градусов, то следует включить обогреватель.

Те же управляющие действия могут быть записаны с применением другой конструкции операторов if-else:

1 if (input > 78)

2  air_condision = on; //включить кондиционер, если жарко

3 if (input > 58)

5  fan = on; //включить вентилятор,если душно и жарко

6 else

7  heater = on; //включить обогреватель, если прохладно

Отличие этого варианта программы от предыдущего состоит в том, что оба оператора if–else стали независимыми друг от друга. А в предыдущем примере второй оператор if– else был вложен в первый. Это конструктивное изменение программы внесло коррективы в реализуемый ею алгоритм управления. Так в первом варианте при значении переменной input=80 выражение первого оператора if окажется истинным и будет включен кондиционер. И далее управление будет передано строке 8, т.е. вторая конструкция if будет пропущена из рассмотрения. Во втором случае при том же значении переменной input=80 после проверки первого условия будет также включен кондиционер, но затем управление будет передано второму оператору if. Поскольку второе условие также выполняется, то вентилятор будет также включен.

Еще один вариант реализации того же задачи:

1 if (input > 78)

2  air_condision = on; //включить кондиционер, если жарко

3 if ((input > 58) && (input < 79))

5  fan = on; //включить вентилятор,если душно, но не жарко

6 if (input < 59)

7  heater = on; //включить обогреватель, если прохладно

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

1 if (condition 1)

2  (instruction set 1);

3 if (condition 2)

5  (instruction set 2);

6 if (condition 3)

7  (instruction set 3);

Если число различных значений переменной условия condition превышает 4 или 5, то для выполнения подобной задачи следует использовать оператор switch.

3.9.4. Оператор SWITCH

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

1  switch(<выражение>)

2  {

3  case <константное_выражение_1>:

4  <оператор_1>;

5  break;

6  case <константное_выражение_2>:

7  <оператор_2>;

8  break;

9  :

10  :

11 case <константное_выражение_n>:

12  <оператор_n>;

13  break;

14 default :

15  <оператор_n+1>;

16 }

Выполнение оператора switch начинается с вычисления выражения в скобках. Результат вычисления должен быть целочисленным в одно или двухбайтовом формате. Затем последовательно просматриваются префиксы case, указанные после них константные выражения вычисляются и их результаты сравниваются с результатом вычисления выражения в скобках после слова switch. Если результаты совпадают, то управление передаётся оператору, следующему за соответствующим префиксом case. Если ни одного совпадения не произошло и при этом указано служебное слово default (его указание необязательно), то управление передаётся оператору, следующему за этим служебным словом. Если совпадения не обнаружилось, а служебное слово default не указано, то ни один из операторов блока не выполняется. Заметим, что в константных выражениях после префиксов case не допускается применения переменных, выражение должно состоять из константных величин.

Приведем пример использования конструкции с оператором switch:

1  switch (a) {

2  case 1:

3  printf("Correct value%d was chosen\n", a);

4  break;

5  case 2:

6  printf("Close but try again\n");

7  break;

8  case 3:

9  printf("Value %d is two away from the answer\n", a);

10  break;

11 default:

12  printf("Your chosen value is way off\n");

13 }

В примере текущее значение переменной a сравнивается со значениями 1, 2 и 3. Желаемое сообщение о правильном выборе появится на экране монитора в том случае, если переменная равна 1. Если же переменная равна 2 или 3, то будут выведены соответствующие сообщения об ошибках. Если ни одно из трех возможных значений не выбрано, то отобразится сообщение, записанное в строке 12. Обратите внимание, в примере мы не должны записывать слово break в строке 13, т.к. после выполнения оператора строки 12 программа автоматически продолжит исполнение следующих за конструкцией switch операторов.

А как будет вести себя программа, если мы пропустим слово break где то в середине конструкции switch, например, в строке 4? После отображения сообщения строки 3 программа перейдет к исполнению следующих операторов, пока не встретит следующее слово break или не дойдет до конца конструкции switch. В нашем случае программа отобразит сообщение строки 6, а затем предаст управление строке 13. Зная подобную особенность оператора switch, Вы можете пропустить несколько break в своей программе.

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

3.13.1. Технология создания программного кода

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

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

Напомнив Вам основные моменты структурного подхода к процессу написания исходного кода и его отладке, рассмотрим процесс превращения файла исходного кода на Си в файл исполняемого кода для определенного типа микроконтроллера. Мы рассмотрим эту технологию с использованием интегрированной среды разработки ICC12 версии 6.12B от компании ImageCraft. Если Вы используете программную среду разработки от другого производителя, то этот материал не будет для Вас бесполезным, поскольку принципы преобразования кодов в процессе создания исполняемого модуля прикладной программы одинаковы для всех аналогичных программных продуктов.

Рис. 3.1. Интерфейс пользователя интегрированной среды разработки ICC12

На рис. 3.1 представлен интерфейс пользователя (картинка на экране монитора), возникающая при запуске среды ICC12. Большое пустое окно в центре экрана предназначено для ввода и редактирования исходного текста программы на Си. Окно меньшего размера в правой части экрана — окно менеджера проектов. Оно предназначено для отображения списка всех используемых в текущем проекте файлов. Окно состояния в нижней части экрана предназначено для отображения текущей информации о режимах работы и состоянии обрабатываемых в среде файлов. В этом окне будут выводиться сообщения об ошибках, возникающих при работе программ компилятора, Ассемблера, линковщика и загрузчика/программатора в процессе обработки файлов текущего проекта. Теоретически, для ввода и редактирования файлов исходного текста программ могут быть использованы любые текстовые редакторы, однако программные продукты класса «интегрированная среда разработки» обязательно содержат собственный редактор текста, которым и следует воспользоваться. Пакет ICC12, как и любая другая интегрированная среда разработки, предоставляет программисту удобный интерфейс пользователя для работы с встроенными в среду программами компилятора, Ассемблера, линковщика, загрузчика и программатора. Каждая из программ может быть запущена на исполнение, как из контекстного меню, так и с помощью кнопок на панели управления. На рис. 3.2 показан интерфейс пользователя среды ICC12 с текстом программы в окне редактирования и сообщениями о результатах ее компиляции в окне состояния.

Рис. 3.2. Интерфейс пользователя интегрированной среды разработки ICC12

В окне редактирования загружен файл исходного текста программы на Си.

В окне состояния сообщение об успешной компиляции этого файла.

После того, как исходный текст программы написан и находится в окне редактирования, файл программы должен быть обработан препроцессором компилятора Си. Препроцессор – это часть программы компилятора, которая анализирует выражения в исходном тексте, которые начинаются с символа «#». Вспомните, с этого символа начинаются директивы подключения заголовочных файлов, директивы условной компиляции и директивы для объявления подпрограмм прерывания. Если препроцессор не зафиксировал синтаксических ошибок, то вступает в работу синтаксический анализатор и генератор ассемблерного текста компилятора Си. В результате, после обработки компилятором исходного текста программы на Си, будет получен текст исходной программы на языке Ассемблера для данного типа МК. В нашем случае это МК семейства 68HC12. Сгенерированный компилятором текст будет содержать как мнемоники команд ассемблера МК данного семейства, так и псевдокоманды и директивы для программы Ассемблер в составе пакета ICC12. Смысловые названия и шаблоны имен входных и выходных файлов компилятора Си для среды ICC12 приведены на рис. 3.3. Программы компиляторов, которые способны генерировать инструкции языка ассемблера для процессорного ядра, отличающегося (т.е. программно несовместимо) от ядра, на котором программа компилятора исполняется, называют кросс-компилятора ми. Так в нашем случае программа кросс-компилятора, исполняемая на персональном компьютере, генерирует ассемблерный текст для МК 68HC12.

Рис. 3.3. Последовательность работы программ в процессе генерации файла исполняемого кода прикладной программы

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

Полученный после обработки программой компилятора файл прикладной программы далее обрабатывается программой Ассемблер. Эта программа преобразует файл программы в файл объектного кода с расширением «o» (см. рис. 3.3).

В соответствие с методом системного проектирования, разрабатываемая прикладная программа должна состоять из нескольких файлов, каждый из которых содержит отдельный модуль программы. Часть этих модулей может быть разработана и отлажена в составе другого проекта, и поэтому не требует повторной компиляции. В этом случае для создания конечного варианта разрабатываемой программы необходимо объединить в один файл ранее полученные объектные файлы модулей и вновь разработанные, прошедшие обработку компилятором и Ассемблером файлы. Для объединения нескольких объектных модулей в один файл исполняемого кода используется программа линковщика. Линковщик генерирует три типа файлов с расширениями «s19», «map» и «lst». Файл карты памяти «xxx.map» содержит в себе информацию о расположении кодов прикладной программы в адресном пространстве МК. Файл листинга «xxx.lst» отражает процесс перевода мнемоник команд ассемблера в машинные коды. Файл в формате «s19» именуют файлом исполняемого кода или загрузочным модулем, поскольку именно этот файл заносится в постоянную память МК и исполняется им в процессе управления проектируемым устройством. Таким образом, в результате работы специальных программ в составе пакета интегрированной среды разработки, один или несколько файлов на Си были обработаны программами компилятора, Ассемблера и линковщика с целью получения одного исполняемого на выбранном типе МК файла машинных кодов прикладной программы.

Процесс разбиения задачи для программирования на множество программных модулей, каждый из которых функционально завершен и предназначен для реализации отдельной функции управления, называется структурным программированием. Для объединения отдельных программных модулей в одну программу управления с возможностью независимой модификации и отладки каждого модуля недостаточно располагать только исходными текстами или объектными файлами этих модулей. Необходим также достаточно большой набор служебных файлов, которые вместе с файлами модулей составляют так называемый проект задачи. Поэтому программа в составе интегрированной среды разработки, которая осуществляет управление процессом компиляции, ассемблирования, объединения модулей программой линковщика и загружает полученный исполняемый код в память микроконтроллера на отладочной плате, называется менеджером проектов (Project Manager или Project Builder). Это еще одна программа в составе пакета интегрированной среды разработки типа ICC12.

Программа менеджера проектов считается основной в составе IDE, поскольку она управляет доступом пользователя и взаимодействием с обрабатываемыми файлами всех остальных программ пакета интегрированной среды разработки и отладки программного обеспечения (ПО) микропроцессорных систем. Кроме используемого в книге пакета ICC12, для создания прикладного ПО микроконтроллеров семейства 68HC12 могут также использоваться другие аналогичные пакеты, например CodeWarrior компании Metrowerks.

В параграфе 3.14 на примере простой программы управления светодиодами мы рассмотрим особенности генерации всех промежуточных файлов при работе комплекта программ в составе интегрированной среды ICC12. В настоящем параграфе на рис. 3.4 мы демонстрируем лишь смысловые преобразования исходного текста на Си в процессе получения исполняемого кода прикладной программы.

Рис. 3.4. Форматы представления прикладной программы на разных этапах создания файла исполняемого кода

3.13.2. Режим отладки BDM

В отличие от МК предыдущего поколения, например, 68HC11, аппаратные средства МК семейства 68HC12 позволяют вести отладку без остановки выполнения прикладной программы. В микроконтроллерах семейства 68HC11 наблюдение за состоянием внутренних ресурсов МК в процессе отладки осуществлялось с использованием специальной программы монитора отладки, которая загружалась в память МК сразу после включения питания. Эта программа передавала в персональный компьютер содержимое регистров центрального процессора и ячеек памяти каждый раз, когда этого пожелает оператор. Однако каждое обращение к программе монитора для нового просмотра вызывало генерацию программного прерывания с последующим остановом отлаживаемой прикладной программы и запуском программы монитора отладки. Такой принцип организации отладки не позволял наблюдать в реальном времени функционирование прикладных программ с множеством аппаратных прерываний.

В МК семейства 68HC12 реализован иной, более совершенный режим отладки BDM (Background Debug Mode), что в переводе означает «фоновый режим отладки». Этот режим позволяет выполнить основные процедуры отладки — просмотр и модификацию содержимого регистров и ячеек памяти без останова выполнения прикладной программы.

В процессе отладки МК обменивается данными с персональным компьютером, используя последовательный интерфейс с оригинальным протоколом. Для подключения микроконтроллера, который установлен на плате проектируемого устройства, к персональному компьютеру разработан унифицированный интерфейс, который носит название «BDM порт» (рис. 3.5). Стандартизация линий связи и типа разъема интерфейса отладки BDM позволяет разрабатывать универсальные программные пакеты и аппаратные средства отладки так, что любая аппаратная платформа на основе МК семейства 68HC12, в том числе и плата собственной разработки, способна работать под управлением любой интегрированной среды разработки для 68HC12/HCS12.

Рис. 3.5. Цоколевка разъема BDM порта

Используя порт BDM, встроенный в МК блок отладки принимает от персонального компьютера команды отладки и возвращает в персональный компьютер запрашиваемые данные. Часть команд отладки может выполняться только аппаратными средствами блока BDM, без остановки выполнения прикладной программы. При этом используются «холостые» машинные циклы внутренних магистралей, когда исполняемая прикладная программа не производит обращения к памяти. Если такие «холостые» циклы не возникают в течение 128 машинных циклов, то блок BDM захватывает последующие циклы для выполнения поступившей команды отладки. При этом выполнение прикладной программы слегка притормаживается. Обсуждаемые так называемые аппаратные команды отладки могут поступать в блок BDM от персонального компьютера не чаще, чем 1 раз в 150 машинных циклов. Перечень аппаратных команд отладки представлен в табл. 3.3. В табл. 3.4. дано описание этих команд.

Табл. 3.3. Команды отладки, исполняемые аппаратными средствами модуля отладки BDM

Табл. 3.4. Описание аппаратных команд модуля отладки BDM

Другая часть команд отладки исполняется под управлением программы монитора отладки, которая хранится в ПЗУ модуля BDM. Это ПЗУ располагается в общем адресном пространстве МК по адресам 0xFF00…0xFFFF. Память блока BDM доступна только в режиме отладки. В рабочем режиме ячейки памяти с этими адресами используются для других целей, в частности для размещения векторов прерываний. Перечень команд, исполняемых монитором отладки, представлен в табл. 3.5.

Табл. 3.5. Команды отладки, исполняемые монитором BDM

Для того, чтобы использование команд монитора отладки стало возможным, необходимо сначала установить бит ENBDM в регистре состояния STATUS (0xFF01), а затем выполнить команду BACKGROUND. Формат регистра состояния STATUS представлен на рис. 3.6.

Рис. 3.6. Формат регистра состояния модуля отладки ВDМ

Запись бита разрешения работы монитора отладки ENBDM осуществляется командой ENABLE_FIRMWARE из перечня аппаратных команд BDM (табл. 3.3). Отметим, что если МК 68HC12B32 сконфигурирован для работы в однокристальном режиме, то во время сброса бит ENBDM устанавливается в 1. Аппаратная команда отладки BACKGROUND также передается из персонального компьютера. Эта команда переводит МК в режим работы под управлением монитора отладки, когда центральный процессор на время прекращает выполнение основной программы и реализует команды монитора отладки. Для выполнения команд монитора отладки модуль BDM анализирует состояние внутренних магистралей МК. Если команда монитора требует для реализации только один машинный цикл, то работа прикладной программы не нарушается. Если же монитору необходимо несколько циклов, то работа процессора приостанавливается до завершения выполнения отладочной команды.

В области памяти модуля BDM расположены пять служебных регистров (табл. 3.6). Регистр INSTRUCTION хранит переданный из персонального компьютера код исполняемой команды отладки.

Табл. 3.6. Регистры модуля отладки BDM

Регистр состояния STATUS (рис. 3.6) отражает текущий режим работы модуля BDM. Бит ENBDM установлен, если работа программы монитора отладки разрешена, т.е. могут реализовываться не только аппаратные, но и программно исполняемые команды отладки. Установленный в 1 бит BDMACT показывает, что МК прекратил выполнение прикладной программы и ожидает поступления команды отладки. Бит ENTAG отражает перевод МК в специальный режим тегирования команд. Этот режим устанавливается после исполнения команды TAGGO монитора отладки (табл. 3.5). Бит SDV является служебным битом монитора отладки, он отражает наличие данных в регистре SHIFTER блока BDM. И, наконец, бит TRACE — это признак работы МК в режиме трассировки, который назначается после исполнения инструкции TRACE1 из списка табл. 3.5.

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

Регистр ADDRESS хранит принятый в команде отладки адрес регистра или ячейки памяти. В регистре CCRSAV сохраняется состояние регистра признаков CCR центрального процессора во время исполнения команд монитора отладки.

Режим тегирования используется для автоматического перевода МК в режим отладки при исполнении команды, которая ранее была отмечена программистом для более подробного рассмотрения результатов ее исполнения.

Обсудив принципы организации режима отладки для МК семейства 68HC12, мы перейдем к рассмотрению программно аппаратных средств отладки, которые используют режим BDM и обеспечивают простой и удобный интерфейс пользователя.

3.13.3. Аппаратные и программные средства отладчика P&E от компании PEMICRO

В данном параграфе представлены краткие сведения об аппаратных и программных средствах отладки для МК семейства 68HC12, которые используют порт модуля BDM для связи с микроконтроллером. Мы остановимся на описании возможных режимов отладки с использованием пакета внутрисхемного отладчика ICD12Z в составе интегрированной среды разработки WinIDE Pemicro HC12. Отладчики от других производителей работают схожим образом. Используя набок предоставляемых команд отладки, пользователь может обнаружить и зафиксировать ошибки в исполнении программы. Набор команд отладки приведен в табл. 3.7 и 3.8.

Табл.3.7. Команды интерфейса пользователя отладчика P&E

Табл.3.8. Команды интерфейса пользователя отладчика P&E

На рис. 3.7. представлен необходимый для организации процесса отладки набор аппаратных средств. На рис. 3.8. показан вид экрана монитора компьютера в процессе использования пакета отладчика ICD12Z. Как показано на рис., пользователь имеет доступ к регистрам центрального процессора (левое верхнее окно), может наблюдать за изменением используемых в программе символьных переменных (среднее верхнее окно), следить за состоянием и изменять по желанию коды в ячейках памяти (правое верхнее окно), исходный текст отлаживаемой программы (два средних окна), осуществлять ввод команд отладки и наблюдать за их исполнением в окне состояния (нижнее окно).

Рис. 3.7. Система отладки на основе интерфейса BDM и платы микроконтроллером 68HC12B32

Рис. 3.8. Интерфейс пользователя отладчика P&E ICD12Z компании PEMICRO

Вы можете также организовать процесс отладки, используя другие аппаратные средства, например две платы MC68HC912B32EVB. На рис. 3.9. показана инсталляция аппаратных средств для этого случая. Одна из отладочных плат используется в качестве отладочного интерфейса BDM между персональным компьютером и платой, которая подлежит отладке. К плате MC68HC912B32EVB прилагается программное обеспечение — Motorola D-Bug12 монитор, который и будет использован для управления процессом отладки. Для того, чтобы воспользоваться таким режимом работы платы MC68HC912B32EVB, следует установить переключатели W3 и W4 платы в состояние 0 и 1 соответственно. Далее подсоединить кабель BDM от платы интерфейса к оставшейся плате MC68HC912B32EVB. Эта вторая плата будет платой целевой системы. Подключите источник питания к целевой системе. При этом плата интерфейса отладки будет питаться от этого же источника, используя BDM кабель. Теперь Вы можете использовать команды монитора отладки Motorola D-Bug12 для управления исполнением испытуемой прикладной программой.

Рис. 3.9. Система отладки на основе двух отладочных плат с микроконтроллером 68HC12B32

3.13.4. Эмуляторы

Другой способ отладки прикладной программы — использование программного пакета класса эмулятор, который изображает ход исполнения прикладной программы и при этом генерирует все аппаратные сигналы, которые были бы на выходе реального МК. Такие эмуляторы выпускают компании Noral и Hitex.

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

3.13.5. Логические анализаторы

Логический анализатор — это интеллектуальный электронный измерительный прибор, который используется для запоминания, отображения на экране и измерения временных параметров нескольких существующих одновременно логических сигналов. Функции логического анализатора по исследованию и наладке цифровых систем аналогичны функциям осциллографа для аналоговых систем. На рис. 3.10 представлена фотография логического анализатора компании Hewlett Packard, в настоящее время аналогичные приборы выпускаются под маркой Agilent.

Рис. 3.10. Логический анализатор фирмы Agilent Technologies

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

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