23 Сентября 2017, Суббота        57.65      Карта сайта » Главная » Исполнительные элементы » NF249 . . .

NF249 (10K)
NF249 (набор для самостоятельной сборки)
Оптореле 220 В/10 А
0 руб.
В наличии: 0 шт.

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

Технические характеристики NF249

ПараметрЗначение
Uупр. постоянное, В+5...15
Iупр., мА10
Uкоммутации. переменное, В~220
Iкоммутации., А10
Размер печатной платы, мм 52 x 38
Температура эксплуатации, °С0...+55
Относительная влажность эксплуатации, % ...55
ПроизводствоСамостоятельная сборка
Гарантийный срок эксплуатацииОтсутствует
Вес, г

Комплект поставки NF249

НаименованиеКоличество
Плата печатная1
Комплект деталей для самостоятельной сборки1
Инструкция пользователя 1

Описание NF249

Принцип работы твердотельного реле состоит в следующем: входной сигнал (управляющий ток) через диод D1 подается на светодиод. Излучение, пройдя некоторое расстояние в корпусе реле (МОС3041), попадает на фотодиодную матрицу (фотоэлектрический генератор). Падающее излучение создает в фотодиодной матрице фото-ЭДС. Наведенное напряжение подается на схему управления, которая в свою очередь формирует необходимый сигнал для управления выходным ключевым каскадом, обеспечивает защиту затвора выходного МОП-ключа, обеспечивает быстрое выключение ключа. Силовой ключ реализован на элементах С1, С2, R2, R3, и симисторе TR1. Резистор R1 ограничивает ток через светодиод оптореле.

Схема монтажная NF249

NF249_board (15K)

Схема электрическая принципиальная NF249

NF249_el (12K)

Схема замены ключа с реле на оптосимистор с силовым симистором

NF249_simple (16K)

Часто задаваемые вопросы

- Как программировать микроконтроллеры на Си?
- Программирование микроконтроллеров на Си подробно описано на сайте http://eugenemcu.ru, статья из которого приводится ниже.

Си для микроконтроллеров и чайников
(по материалам сайта http://eugenemcu.ru)
Часть 1. Программные переменные и регистры микроконтроллера.

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

par (1K)  1.1 Общие вопросы. Переменные объявляемые пользователем.

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

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

Зачем нужно объявлять переменные?

Хоть язык Си и абстрактный, используемый разработчиком микроконтроллер, как правило, вполне конкретный и имеет своё адресное пространство памяти с заданными свойствам, где и будет храниться объявляемая переменная. Объявление, помимо присвоения переменной имени, заставляет компилятор разместить её по конкретному адресу в памяти микроконтроллера (по какому именно нас в большинстве случаев совершенно не интересует).

Как нужно объявлять переменные?

Правило для объявления можно формулировать так: до того как мы впервые употребим имя переменной в тексте нашей программы, необходимо размесить её объявление в следующем формате:


  type name; // Переменная с именем "name" и типом "type"

Здесь: type - так называемый идентификатор типа переменной из определённого набора стандартных типов;
name - произвольное имя переменной, лишь бы оно не начиналось с цифры, состояло только из латинских символов, и не совпадало со служебными словами языка Си (список которых не так велик, чтобы столкнуться с такой ситуацией нужно на самом деле очень постараться).

Что такое идентификатор типа и зачем его упоминать?

Для хранения переменной микроконтроллер использует ячейки памяти, размер которых определяется его разрядностью. Так например, микроконтроллеры семейства AVR - 8-разрядные, а значит для хранения данных используют ячейки памяти размером в один байт, которые способны сохранять 256 различных числовых значений. Если ожидаемые значения переменной могут превысить это количество, то для её хранения понадобится две или более ячеек памяти. Поскольку Си, строго говоря, не представляет какие значения мы планируем присваивать переменной, то просит нас указать её тип, который как раз и определяет допустимый диапазон значений. Это необходимо чтобы не зарезервировать за ней избыточный или недопустимо малый объём памяти, а так же предупреждать нас при попытке присвоить слишком большое значение переменной, не способной его сохранить. Для 8-разрядных микроконтроллеров наиболее часто употребимые целочисленные типы данных следующие:

способные хранить только положительные значения (беззнаковые):
unsigned char - занимает один байт памяти, значения 0...255
unsigned int - два байта, значения 0...65535
unsigned long - четыре байта, от 0 до (2^32)-1.

способные хранить значения со знаком (знаковые):
signed char - занимает один байт памяти, от -128...127
signed int - два байта, значения -32768...32767
signed long - требует четыре байта, значения от -(2^31) до (2^31).

Ключевое слово "unsigned" (беззнаковое), вообще говоря, можно не употреблять, поскольку в Си по умолчанию тип, для которого не указан этот признак, считается беззнаковым. Для работы с дробными числами в Си предусмотрены типы с плавающей точкой:
float – 32 бита, значения от ±1.18E-38 до ±3.39E+38
double – 32 (±1.18E-38…±3.39E+38) или 64 бита (±2.23E-308…±1.79E+308) в зависимости от настроек компилятора.
Примечание: размер памяти для хранения переменных указанных типов и диапазон допустимых значений может незначительно меняться в зависимости от среды разработки или семейства микроконтроллеров. Для того чтобы перед началом использования переменной она уже имела конкретное значение, к объявлению часто дописывается инициализатор: знак равенства (в Си это оператор присваивания) и начальное значение переменной. Например:


  int A = 100; // Переменная с именем "А" типом int и начальным значением равным 100.

Практический пример: пусть планируется написать программу, мигающую светодиодом 5 раз. Для подсчёта числа миганий потребуется переменная, значение которой, очевидно никогда не будет отрицательным и не выйдет за пределы диапазона от 0 до 255, а значит в данном случае будет вполне достаточно использовать однобайтовый тип char:


  unsigned char ChisloMiganiy = 0; // Переменная с именем ChisloMiganiy типом int и начальным значением равным 0.

par (1K)  1.2 Область видимости переменной.

Источником многих затруднений для начинающих становится свойство языка, которое называется областью видимости объявленной переменной. Язык Си имеет возможность ограничить действие переменной конкретной областью программного кода, при этом в других частях программы она становится недоступной, благодаря чему высвобождается память, которая на других участках программы может использоваться другими переменными. Такие переменные называются локальными, а их использование - основной способ получения экономичного кода.

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

par (1K)  1.3 Область размещения переменной.

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

c_avr_memory (15K)

Для хранения пользовательских переменных может быть использована ОЗУ, энергонезависимая память EEPROM, а для хранения констант, значение которых не может быть изменено в процессе работы программы также и FLASH - память микроконтроллера.

Для начала полезно знать, что переменные, объявленные пользователем без использования специальных ключевых слов типа _eeprom или _flash, размещаются в ОЗУ микроконтроллера, в виде одной или нескольких ячеек статической памяти SRAM. В процессе работы они периодически копируются в быструю регистровую память РОН, которая непосредственно взаимодействует с арифметически-логическим блоком АЛУ микроконтроллера.

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

par (1K)  1.4 Регистры специального назначения микроконтроллера SFR.

Итак, мы кратко рассмотрели объявление переменных предназначенных для организации вычислительного процесса, которые мало связаны со спецификой аппаратной части МК. Управление и контроль работы микроконтроллера и его отдельных внутренних модулей осуществляется путём записи и чтения специальных ячеек-регистров в служебной области памяти ОЗУ - регистров специального назначения (Special Function Register, далее просто SFR). Основная идея, позволяющая использовать Си для программирования микроконтроллеров, такова: регистры специального значения являются такими же переменными языка Си, как и объявленные пользователем. Этим переменным можно присваивать значения, управляя работой микроконтроллера, или считывать их, получая таким образом информацию о его текущем состоянии. Объявлять регистры микроконтроллера подобно пользовательским переменным не нужно по нескольким причинам. Во-первых, их размер заранее известен: в Си для AVR это беззнаковые 8-разрядные переменные. Во-вторых, SFR имеют строго определённые имена и адреса в памяти, являясь так называемыми регистрами ввода-вывода. Тем не менее знакомить программу с регистрами спецназначения нужно, и делается это с помощью подключения так называемых заголовочных файлов. В начале любой программы на Си мы можем видеть строки типа:


  #include "file1.h" /* Включить в код содержимое файла file1.h. При этом препроцессор будет его искать в папке с проектом. */

#include - это директива (указание), заставляющая среду разработки поместить в данное место программы содержимое файла с именем file1.h. Файлы с расширением .h называются заголовочными или h-файлами. Разработчик может создавать собственные h-файлы и помещать их, учитывая содержимое, в любое место программы. Однако, чтобы познакомить программу с SFR для данного типа микроконтроллера, необходимо подключать вполне конкретные заголовочные файлы. Их имена и количество зависит от конкретной среды разработки и типа используемого микроконтроллера, так, например, в IAR для Atmega64 достаточно прописать строки:


  #include "iom64.h"
  #include "inavr.h"

После включения в текст необходимых h-файлов программа будет узнавать упоминаемые в ней имена SFR, например, регистр статуса микроконтроллера AVR с именем SREG, буфер приёма/передачи модуля UART - UDR и так далее.

Заготовка программы для IAR, которая ничего не делает, но уже не "ругается" на имена регистров специального назначения микроконтроллера Atmega16, должна выглядеть так:


  #include "iom16.h"
  #include "inavr.h"

  unsigned char ChisloMiganiy = 0;
  void main (void);
  {
  /* Здесь мы разместим программу, использующую переменную ChisloMiganiy и любые регистры Atmega16, имена которых прописаны в файле iom16.h. */
  }

Хочется надеяться, что читатель знаком с правилами оформления комментариев в тексте программы. Это заметки, которые игнорируются языком Си и не считаются частью программного кода, если записаны в одной и более строках, заключённых между символами /* и */, или в одной строке, начинающейся с последовательности //.

Часть 2. Операции с переменными и регистрами микроконтроллера.

par (1K)  2.1 Обзор стандартных операций с регистрами.

Настало время перейти к более серьёзным операциям над регистрами и программными переменными. Управление работой микроконтроллера в большинстве случаев сводится к следующему простому набору действий с его регистрами:
1. Запись в регистр необходимого значения.
2. Чтение значения регистра.
3. Установка в единицу нужных разрядов регистра.
4. Сброс разрядов регистра в ноль.
5. Проверка разряда на логическую единицу или логический ноль.
6. Изменение логического состояния разряда регистра на противоположное.
Во всех указанных действиях принимает участие оператор присваивания языка Си, записываемый в виде знака равенства. Принцип действия оператора примитивно прост - он записывает в регистр или переменную расположенную слева от него, значение того, что записано справа. Справа может находится константа, другой регистр, переменная либо состоящее из них выражение, например:


  A = 16; // Присвоить переменной A значение 16
  A = B; // Считать значение переменной B и присвоить это значение переменной A;
  A = B + 10; /* Считать значение переменной B, прибавить к считанному значению 10, результат присвоить переменной A (значение переменной B при этом не изменяется). */


par (1K)  2.2 Запись и чтение регистров. Установка битов в регистре.

Из рассмотренных примеров видно, что оператор присваивания сам по себе решает две первые задачи — запись и чтение значений регистров. Например для отправки микроконтроллером AVR байта по шине UART достаточно записать его в передающий регистр с именем UDR:


  UDR = 8; // Отправить по UART число 8

Чтобы получить принятый по UART байт достаточно считать его из регистра UDR:


  A = UDR; // Считать принятый байт из UART и переписать в переменную A.

Язык Си не имеет в своём составе команд непосредственного сброса или установки разрядов переменной, однако присутствуют побитовые логические операции И и ИЛИ, которые успешно используются для этих целей. Оператор побитовой логической операции ИЛИ записывается в виде вертикальной черты - | и может выполнятся между двумя переменными, а так же между переменной и константой. Напомню, что операция ИЛИ над двумя битами даёт в результате единичный бит, если хотя бы один из исходных битов находится с состоянии единицы. Таким образом для любого бита логическое ИЛИ с 1 даст в результате 1, независимо от состояния этого бита, а ИЛИ с логическим 0 оставит в результате состояние исходного бита без изменения. Это свойство позволяет использовать операцию ИЛИ для установки N-ого разряда в регистре. Для этого необходимо вычислить константу с единичным N-ным битом по формуле 2^N, которая называется битовой маской и выполнить логическое ИЛИ между ней и регистром, например для установки бита7 в регистре SREG: (SREG | 128) — это выражение считывает регистр SREG и устанавливает в считанном значении седьмой бит, далее достаточно изменённое значение снова поместить в регистр SREG:


  SREG = SREG | 128; // Установить бит7 в регистре SREG.

Такую работу с регистром принято называть чтение - модификация - запись. В отличие от простого присваивания она сохраняет состояние остальных битов без именения. Приведённый программный код, устанавливая седьмой бит в регистре SREG, выполняет вполне осмысленную работу - разрешает микроконтроллеру обработку программных прерываний. Единственный недостаток такой записи — в константе 128 не легко угадать установленный седьмой бит, поэтому чаще маску для N-ного бита записывают в следующем виде:
(1 << N) - это выражение на языке Си означает, число один, сдвинутое на N разрядов влево, это и есть маска с установленным N-ным битом. Тогда предыдущий код в более читабельном виде:


  SREG = SREG | (1 << 7); /* Установить бит7 в регистре SREG (полная форма записи).
Подробно: считать регистр SREG, установить бит7 в маске, выполнить логическое ИЛИ маски с регистром SREG, записать результат в регистр SREG */


Или ещё проще с использование краткой формы записи языка Си:


  SREG |= (1 << 7); /* Установить бит7 в регистре SREG (краткая форма записи).
Подробно: считать регистр SREG, установить бит7 в маске, выполнить логическое ИЛИ маски с регистром SREG, записать результат в регистр SREG */


которая означает - считать значение регистра, взять содержимое справа от знака равенства, выполнить между ним и регистром слева операцию, стоящую перед знаком равенства и записать результат в регистр или переменную слева.

par (1K)  2.3 Сброс битов в регистре.

Ещё одна логическая операция языка Си – побитовое И, записывается в виде символа & . Как известно, операция логического И, применительно к двум битам даёт единицу тогда и только тогда, когда оба исходных бита имеют единичное значение, это позволяет применять её для сброса разрядов в регистрах. При этом используется битовая маска, в которой все разряды единичные, кроме нулевого на позиции сбрасываемого. Её легко получить из маски с установленным N-ным битом, применив к ней операцию побитного инвертирования:
~(1 << N)
В этом выражении символ ~ означает смену логического состояния всех битов маски на противоположные. Так, например, если (1 << 3) в двоичном представлении – 00001000b, то ~(1 << 3) уже 11110111b.
Сброс седьмого бита в регистре SREG будет выглядеть так:


  SREG = SREG & (~ (1 << 7)); /* Сбросить седьмой бит в регистре SREG (полная запись).
Подробно: установить бит в седьмом разряде маски, инвертировать маску, выполнить логическое И маски с регистром SREG, записать результат в регистр SREG) */

  SREG &= ~ (1 << 7); /* Сбросить седьмой бит в регистре SREG (краткая запись).
Подробно: установить бит в седьмом разряде маски, инвертировать маску, выполнить логическое И маски с регистром SREG, записать результат в регистр SREG */


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


  #define OCIE0 1 // указание препроцессору заменить в тексте программы встречающуюся запись OCIE0 на 1

Здесь #define – указание компилятору заменять в тексте программы сочетание символов OCIE0 на число 1, то есть стандартное имя бита OCIE0, который входит в состав регистра TIMSK микроконтроллера Atmega64 на его порядковый номер в этом регистре. Благодаря этому установку бита OCIE0 в регистре TIMSK можно нагляднее записывать так:


  TIMSK |= (1 << OCIE0); //установить бит OCIE0 в регистре TIMSK.

Устанавливать или сбрасывать несколько разрядов регистра одновременно можно, объединяя битовые маски в выражениях оператором логического "ИЛИ":


  PORTA |= (1 << 1) | (1 << 4); /* Установить бит1 и бит4 регистра PORTA.
Подробно: установить бит1 маски, установить бит4 маски, выполнить логическое И между ними, инвертировать маску, выполнить логическое ИЛИ с регистром PORTA, записать результат в регистр PORTA. */

  PORTA &= ~( (1 << 2) | (1 << 3) ); /* Сбросить бит2 и бит3 регистра PORTA.
Подробно: установить бит2 маски, установить бит3 маски, выполнить логическое ИЛИ между ними, инвертировать маску, выполнить логическое И с регистром PORTA, записать результат в регистр PORTA. */


par (1K)  2.4 Проверка разрядов регистра на ноль и единицу.

Регистры специального назначения микроконтроллеров содержат в своём составе множество битов-признаков, так называемых "флагов”, уведомляющих программу о текущем состоянии микроконтроллера и его отдельных модулей. Проверка логического уровня флага сводится к подбору выражения, которое становится истинным или ложным в зависимости от того установлен или сброшен данный разряд в регистре. Таким выражением может служить логическое "И” между регистром и маской с установленным разрядом N на позиции проверяемого бита :

(REGISTR & (1 << N)) в этом выражении операция "И” во всех разрядах кроме N-ного даст нулевые значения, а проверяемый разряд оставит без изменения. Таким образом возможное значения выражения будут или 0 или 2^N, например для второго бита регистра SREG:

c_set_reset_test (23K)

Приведённое выражение можно использовать в условном операторе if (выражение) или операторе цикла while (выражение), которые относятся к группе логических, то есть воспринимают в качестве аргументов значения типа истина и ложь. Поскольку язык Си, приводя числовые значения к логическим, любые числа не равные нулю воспринимает как логическую истину, значение (REGISTR & (1 << N)) равное 2^N в случае установленного бита, будет воспринято как "истина".
Если появляется необходимость при установленном бите N получить для нашего выражения логическое значение «ложь», достаточно дополнить его оператором логической инверсии в виде восклицательного знака - !(REGISTR & (1 << N)).
Не следует путать его с похожим оператором побитовой инверсии ~, меняющим состояние битов разряда на противоположное. Логическая инверсия работает не с числовыми значениями, а с логическими, то есть преобразует истинное в ложное и наоборот.
Такая конструкция приводится в DataSheet на Atmega как пример для ожидания установки бита UDRE в регистре UCSRA, после которого можно отправлять данные в UART:


  while ( !( UCSRA & (1 << UDRE))) /* Ждать установки бита UDRE.
Подробно: Считать регистр UCSRA, установить бит UDRE в маске, выполнить логическое ИЛИ между регистром UCSRA и маской, выполнить логическую инверсию результата (пока UDRE = 0, ожидаем ничего не делая) */

  {
  }

Здесь при сброшенном бите UDRE выражение (UCSRA & (1 << UDRE)) даст значение ”ложь”,
инвертированное !( UCSRA & (1 << UDRE)) — ”истину”, и пока это так, программа будет выполнять действия внутри фигурных скобок, то есть не делать ничего (стоять на месте). Как только бит UDRE установится в единицу, программа перейдёт к выполнению действий следующих за конструкцией while(), например займётся отправкой данных в UART.

par (1K)  2.5 Изменение состояния бита регистра на противоположное.

Эту, с позволения сказать, проблему с успехом решает логическая операция побитного "ИСКЛЮЧАЮЩЕГО ИЛИ” и соответствующий ей оператор Си, записываемый в виде символа " ^ ”. Правило "исключающего или" с двумя битами даёт "истину” тогда и только тогда, когда один из битов установлен, а другой сброшен. Не трудно убедиться, что этот оператор, применённый между битовой маской и регистром, скопирует в результат биты стоящие напротив нулевых битов маски без изменения и инвертирует расположенные напротив единичных. Например, если:
                  reg = 0010 0110
            и mask = 0000 1111,
то reg ^ mask = 0010 1001.
Таким способом можно менять состояние светодиода, подключенного к пятому биту порта A:


  #define LED 5 /* указание препроцессору заменять в тексте программы сочетание символов LED на число 5 (вывод светодиода). */
...
PORTA ^= (1 << LED); /* Погасить светодиод, если он светится и наоборот.
Подробно: считать регистр PORTA, установить бит LED в маске, выполнить логическое ИСКЛЮЧАЮЩЕЕ ИЛИ между регистром PORTA и маской (если отличаются - единица, одинаковые - нуль), результат записать в PORTA. */


par (1K)  2.6 Арифметика и логика языка Си.

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

c_logic (57K)

Для более подробного знакомства с операциями над переменными и языком Си в целом, рекомендую книгу "Язык программирования Си" Б. Керниган, Д. Ритчи.

Часть 3. Преобразование типов - типичный источник ошибок

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

par (1K)  3.1 Преобразование типа выражения перед присвоением переменной.

В первом разделе мы обращали своё внимание на необходимость явного указания типа объявляемой переменной. Это позволяет компилятору зарезервировать за ней нужное количество адресного пространства и определить диапазон значений, которые она способна хранить. Тем не менее, мы не застрахованы он того, что в процессе выполнения программы произойдёт попытка записать в переменную значение свыше предельно допустимого. В самых грубых случаях компилятор выдаст нам сообщение о возможной ошибке. Например, при желании записать в переменную типа unsigned char (диапазон от 0 до 255) число 400:


  unsigned char a = 400; // выдаст сообщение типа "integer conversion resulted in truncation”

Kомпилятор предупреждает нас о том, что произошла попытка записать числовое значение, требующее для хранения два байта (400 это 1 в старшем байте и 144 в младшем) в однобайтовую переменную. Однако тех случаях, когда присваиваемое выражение содержит переменные, и компилятор мог бы заметить возможную потерю данных, он освобождает себя от этой обязанности, например:


  unsigned char x = 200,y = 200;
  x = x + y;

При таком варианте, не смотря на то, что значение выражение (x+y) так же равно 400, никаких предупреждений со стороны компилятора уже не последует. А в переменную x запишется только младший байт числа 400, то есть 144. И здесь компилятор трудно в чём-то упрекнуть, ведь вместо явно проинициализированной переменной в выражении может быть использован, например, приёмный регистр шины UART, в котором может оказаться любое значение, принятое от внешнего устройства. Другой пример в этом же духе – присвоение дробного значения переменной целого типа:


  float a = 1.5; // Объявлена переменная с плавающей точкой.
  char b = 3; // Объявлена целочисленная переменная.
  b = a * b; // Ожидается, что в переменную b будет записано значение 4,5.


В результате в переменной b сохранится только целая часть результата a * b – число 4.

par (1K)  3.2 Преобразование результата выражения к типу наиболее точной переменной в выражении.

При таком преобразовании компилятор руководствуется следующим правилом: прежде чем начнется вычисление выражения, операторы с "низшим” типом повышаются до "высших” при этом результат также приводится к ”высшему” типу. Какой тип нужно считать ”высшим”? Тот, который без потери точности может сохранить любое допустимое значение другого типа. Так, в предыдущем примере B выражении (a * b) переменная float a имеет более высокий тип, потому что может сохранять любое целое значение из диапазона 0...255 типа char. Результат выражения (a * b) будет иметь тип float.
Типичный пример неожиданности для этого случая – попытка получить дробное число делением двух целочисленных:


  char a = 3; // Объявлена целочисленная переменная.
  char b = 4; // Объявлена целочисленная переменная.
  float c; // Объявлена переменная "c" с плавающей точкой для сохранения результата.
  c = a / b; // Ожидается, что "c" будет равно 0,75

В отличие от предыдущего примера, результат записывается в переменную способную хранить числа с плавающей точкой, однако компилятор в соответствии с правилом приведения, получив в результате деления число 0,75 приводит его к типу целочисленных операндов, отбросив дробную часть. В результате в переменную "c” будет записан ноль.
Более реалистичный пример из жизни – расчёт измеряемого напряжения из выходного кода АЦП:


  int ADC; // Двухбайтовая целочисленная переменная для хранения кода АЦП.
  float U; // Переменная с плавающей точкой для сохранения значения напряжения.
  U = ADC * (5 / 1024); // Расчёт напряжения.

Здесь упущено из виду то, что константа в Си, как и любая переменная, тоже имеет свой тип. Его желательно указывать явно или, используя соответствующую форму записи. Константы 5 и 1024 записаны без десятичной точки и будут восприняты языком Си как целочисленные. Как следствие, результат выражения (5 / 1024) тоже будет приведён к целому – 0 вместо ожидаемого 0,00489. Это не случилось бы при записи выражения в формате (5.0 / 1024).
Приведённых ошибок также можно избежать, используя оператор явного приведения типов выражений языка Си, который записывается в виде названия типа, заключённого в круглые скобки и воздействует на выражение стоящее после него. Этот оператор приводит результат выражения к явно указанному типу, не взирая на типы его операндов:


  c = (float) a / b; // Ожидается, что "c" будет равно 0,75 (?);
  U = ADC * ( (float) 5 / 1024 ); // Расчёт напряжения.

Часть 4. Функции.

par (1K)  4.1 Назначение функций.

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

Другое назначение функции, полностью отражющее её название – это выделение в отдельную группу действий связанных одной общей целью, например, функция инициализации портов или функция опроса клавиатуры. Это и есть одно из дополнительных предназначений функции. Такие функции могут вызываться программой только один раз. Зачем же тогда они нужны? Для обоснования такого подхода в литературе часто приводится фраза неизвестного, но по всей видимости, очень авторитетного древнеримского программиста: " Разделяй и властвуй!”. И действительно, программа, оформленная в виде целевых функциональных блоков гораздо проще для понимания, отладки и последующей модификации, чем набор отдельных, разрозненных по назначению кусков кода.

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

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

par (1K)  4.2 Структура и оформление функций.

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


  Тип выходной переменной Имя функции (Типы входных переменных и их имена через запятую)

Временно опустим рассмотрение содержимого заголовка до и после имени и рассмотрим функции, которые не обрабатывают никаких данных. Они предназначены только для выполнения определённых действий. В заголовках таких функций нужно указать названия пустого типа – void (англ. вакуум, пустота):


  void имя функции (void)

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


  initialization ();

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


  void initialization (void);
  {
  DDRA = 0xFF; // PORTA на выход.
  DDRB |= (1 << 0) | (1 << 3) | (1 << 4); // PB0, PB3, PB4 на выход.
  DDRC = 0xF0; // Старшая тетрада PORTC на выход.
  }

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

par (1K)  4.3 Обработка параметров функцией.

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


  void initUart (char FrameLength, char StopBit);

Такое оформление заголовка будет означать, что функция способна принимать в качестве параметров два числа типа char с именами FrameLength и StopBit. Теперь при вызове функции компилятор не позволит оставить круглые скобки пустыми и потребует передачи конкретных значений, через запятую, например:


  initUart (8, 2);

После этого внутри функции переменным с именами FrameLength и StopBit присвоятся конкретные значении 8 и 2, которые можно использовать, например, для настройки длинны посылки модуля UART и количества его стоп-битов:


  void initUart (char FrameLength, char StopBit);
  {
    if (FrameLength == 8)
    {
      UCSR0C |= ((1 << 1) | (1 << 2));
    }
    if (StopBit==2)
    {
      UCSR0C |= (1 << 3);
    }
  }

par (1K)  4.4 Специализированные функции.

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

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

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

Часть 5. Структура программы: инициализация, фон, прерывания.

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

par (1K)  5.1 Общая структура простейшей программы. Инициализация, фон.

При рассмотрении программы на уровне языка Си можно сказать, что она начинает свою работу с первой строки функции main (строка 001 на рисунке):

c_while1 (5K)

Далее последовательно выполняются строки 002, 003, 004, объёдинённые одним общим свойством: программа проходит по ним только один раз, при запуске микроконтроллера. Эту часть программы принято называть инициализационной.  Инициализационная часть - законное место для размещения действий по подготовке периферии микроконтроллера к работе с заданными параметрами - настройки портов на вход или выход, начальной инициализации таймеров, задания скорости и формата кадра UART и так далее для всего, что планируется использовать в дальнейшем.

Поскольку любая программа предназначена для непрерывной работы, нормальный режим её функционирования - это безостановочное повторение по кругу содержимого бесконечного цикла. На практике такой цикл чаще всего реализуется с помощью конструкции while(1) { }, предназначенной для многократного выполнения действий, размещённых внутри её фигурных скобок. Содержимое бесконечного цикла программы называется фоном. Именно здесь происходит основная часть работы по проверке состояния аппаратной части и соответствующее воздействие на неё для получения нужного результата.

Рассмотрим описанную структуру программы на простейшем примере. Пусть необходимо: отправлять по шине UART символ *, пока кнопка на выводе PA0 находится в нажатом состоянии (нулевой уровень сигнала). Программа в данном случае (без лишних процедур по подавлению дребезга кнопки и прочего) может выглядеть так:


void main (void)
{
  PORTA |= (1 << 0); // Притянуть вход кнопки PORTA.0 внутренним pull-up резистором.
  UBRRL=51; // Скорость UART – 9600 bps.
  UCSRB = (1 << RXEN) | (1 << TXEN); // Разрешить выводы RX, TX.
  while (1)
  {
    if ( !(PINA & (1 << 0))) // Если кнопка нажата...
    {
      while( !(UCSRA & (1 << UDRE)) ) // Ждать освобождения UDR.
      {
      }
      UDR = ' * '; // Отправить *.
    } // fi
  // другие команды фона:
  00N
  00N+1
  ...
  } // elihw
} // niam

Здесь конструкция if (...), расположенная в фоне программы проводит бесконечные опросы входного регистра PINA и проверку вывода PA0 на наличие низкого уровня. Далее выполняются другие действия фонового процесса, обозначенные строками 00N, 00N+1 и так далее. Какие факторы, применительно к данной программе, определяют самые важные параметры её работы - надёжность и быстродействие?
Из примера видно, что частота опроса входа PA.0 определяется длительностью выполнения команд фона, ведь прежде чем в очередной раз опросить кнопку, микроконтроллер должен выполнить следующие за этим строки 00N, 00N+1 и т. д. Очевидно, что надёжность фиксации внешнего события (нажатия на кнопку) в данном случае будет зависеть от соотношения длительности воздействия этого события к периоду его детектирования. Длительность фона в данной программе наверняка будет во много раз меньше длительности удержания кнопки, которое на практике составляет несколько десятков миллисекунд. Однако при разрастании фоновой части программы и малом времени внешнего воздействия, надёжность его отслеживания в определённый момент резко снизится. Что бы этого не произошло, а также для снижения времени реакции программы на внешнее событие, используется система прерываний.

par (1K)  5.2 Прерывания.

Как работает механизм прерываний? Очень просто, особенно на уровне языка Си! В архитектуру микроконтроллеров AVR, впрочем как и любых других, на аппаратном уровне заложена способность отслеживать определённые "интересные состояния железа” и устанавливать при этом соответствующие биты-признаки. Такие состояния называются условиями возникновения прерываний, а устанавливаемые признаки - флагами прерываний. В процессе работы, микроконтроллер непрерывно отслеживает состояние этих флагов. При обнаружении любого установленного флага прерывания, при условии, что оно разрешено включением соответствующего бита, а также установлен бит глобального разрешения прерываний (№7 в регистре SREG для AVR), выполнение основной части программы будет временно приостановлено (прервано). Поскольку прерывание может возникнуть при выполнении любой произвольной команды фона, её адрес запоминается в так называемом программном стеке. После чего, выполнение предается на часть программы, специально написанную разработчиком для реакции на событие, вызвавшее данное прерывание. Эта небольшая часть программы называется обработчиком прерывания. Когда обработчик будет выполнен до конца, программа, воспользовавшись адресом, сохранённым в программном стеке, вернётся в то место, откуда была вызвана для обработки данного прерывания.

c_while1_interrupt (8K)

Какова роль программиста в этом процессе? При разработке на Си она сведена к минимуму. Часть действий, как то отслеживание флагов прерываний реализованы на аппаратном уровне. Другую часть, например, защиту от изменений в обработчике важного для программы регистра статуса SREG, сохранение адреса программы в стеке и многое другое компилятор берёт на себя. Единственное, в чём остаётся необходимость это:
1. Разрешить использование прерываний в программе.
2. Разрешить вызов интересующего нас прерывания специальным битом в соответствующем регистре. Каким именно и где подскажет описание на микроконтроллер.
3. Создать условия для возникновения прерывания, например, если это переполнение таймера, то банально запустить его. Если это прерывание по изменению состояния внешнего вывода то задать нужные условия для этого (фронт, срез или нулевой уровень).
4. Разместить в программе обработчик прерывания, оформив его в соответствии с требованиями компилятора.
Применительно к нашему примеру организовать отправку в UART по низкому уровню на входе кнопки, можно используя так называемое внешнее прерывание INT0. Данное прерывание вызывается по фронту, срезу или нулевому уровню на выводе INT0. Перенесем кнопку на вывод PD.2 с альтернативной функцией INT0. В инициализационной части программы разрешим прерывания глобально и INT0 конкретно. Микроконтроллер по-умолчанию настроен на формирование прерывания INT по низкому уровню входного сигнала, поэтому дополнительных настроек не потребуется. Остаётся объявить за пределами функции main обработчик INT0, отправляющий в UART символ *:


void main (void)
{
  PORTD |= (1 << 2); // Притянуть вход кнопки PORTD.2 внутренним pull-up.
  UBRRL = 51; // Скорость UART – 9600 bps.
  UCSRB = (1 << RXEN) | (1 << TXEN); // Разрешить RX,TX.
  SREG |= (1 << 7); // Разрешить прерывания.
  GICR |= (1 << INT0); // Разрешить прерывание INT0.
  while (1)
  {
  } // elihw
} // niam

#pragma vector = INT0_vect // Обработчик прерывания INT0
__interrupt void INT0_INTPT()
{
  if ( ! (PIND & (1 << 2)) )
  {
    while( ! (UCSRA & (1 << UDRE)) )
    {
    } // elihw
    UDR = '*';
  } // fi
} // end interrupt

Здесь обработчик прерывания объявлен в формате компилятора IAR. Принципиально в нём только имя вектора прерывания - INT0_vect, компилятор заменяет его на адрес памяти программ, на который передаётся выполнение программы при возникновении данного прерывания. Имя самого обработчика INT0_INTPT выбирается произвольно. Названия векторов всех возможных прерываний для данного МК описаны в h-файлах.
Теперь время реакции на нажатие кнопки не зависит от длительности фона программы и составляет несколько тактов микроконтроллера, а вероятность пропустить это событие равна нулю. Таким образом, прерывание – отличный способ реакции на событие, требующее немедленной обработки. Это и есть его главное предназначение.
Хочется сразу упомянуть одно негласное правило относительно обработчиков прерываний, хоть это и достаточно узкий вопрос. В них следует размещать только то, что на самом деле необходимо для быстрой реакции на прерывание. Все остальные действия, которые можно отложить, необходимо размещать в фоне. С чем это связано?
Если события, вызывающие прерывание, происходят достаточно часто, то на момент возникновения следующего прерывания слишком длинный обработчик может не успеть выполниться до конца. А это чревато неприятными последствиями в виде потери данных и нарушения нормальной последовательности действий. Например, если необходимо принять по UART некий массив байтов, то в обработчике, который вызывается после приёма каждого из них, не следует заниматься пристальным изучением принятых данных, а только переписывать их с заранее заготовленный массив. А уже после приёма последнего из них, в обработчике можно выставить соответствующий признак (мол, всё принято) и в фоне, обнаружив его, спокойно заняться исследованием всего принятого массива.

Яндекс.Метрика