Site Language

Translate

Danish Dutch English French German

CashBack Реальный возврат при покупках в интернете

Основные версии плат Arduino

Due — плата на базе 32-битного ARM микропроцессора Cortex-M3 ARM SAM3U4E;

Leonardo — плата на микроконтроллере ATmega32U4;

Uno — самая популярная версия базовой платформы Arduino;

Duemilanove — плата на микроконтроллере ATmega168 или ATmega328;

Diecimila — версия базовой платформы Arduino USB;

Nano — компактная платформа, используемая как макет. Nano подключается к компьютеру при помощи кабеля USB Mini-B;

Mega ADK — версия платы Mega 2560 с поддержкой интерфейса USB-host для связи с телефонами на Android и другими устройствами с интерфейсом USB;

Mega2560 — плата на базе микроконтроллера ATmega2560 с использованием чипа ATMega8U2 для последовательного соединения по USB-порту;

Mega — версия серии Mega на базе микроконтроллера ATmega1280;

Arduino BT — платформа с модулем Bluetooth для беспроводной связи и программирования;

LilyPad — платформа, разработанная для переноски, может зашиваться в ткань;

Fio — платформа разработана для беспроводных применений. Fio содержит разъем для радио XBee, разъем для батареи LiPo и встроенную схему подзарядки;

Mini — самая маленькая платформа Arduino;

Pro — платформа, разработанная для опытных пользователей, может являться частью большего проекта;

Pro Mini — как и платформа Pro, разработана для опытных пользователей, которым требуется низкая цена, меньшие размеры и дополнительная функциональность.

Это информационный ресурс с лучшими инструкциями и туториалами по использованию контроллеров Arduino

Карта сайта Arduino, Mega ADK, Cubietech, Arduino Uno, Arduino Mega2560, Карта сайта, Arduino Fio, Cubietruck, Arduino Ethernet, Esplora, Arduino Robot, Raspberry, Arduino Leonardo, Arduino Due, Arduino Micro, Banana, Intel Galileo Gen 2, Arduino Duemilanove, Beaglebone, BananaPro, Arduino Usb, Intel, Intel Galileo, Intel, Intel Galileo, Intel Edison, Intel Edison, Intel Galileo Gen 2, Карта сайта, Arduino Duemilanove, Mega ADK, Arduino Duemilanove, Arduino Nano, Arduino Leonardo, Arduino Due, Arduino Micro, Arduino Lilypad, Arduino Uno, Arduino Uno, Arduino Mega2560, Cubietruck, Raspberry, Banana, Arduino Leonardo, Arduino Due, Lilypad Arduino Simple, Lilypad, Arduino Usb, Arduino Micro, Lilypad, Arduino Simple Snap, Lilypad Arduino Simple, Intel, Lilypad, Arduino Cubieboard, Arduino Usb, BananaPro, Arduino Gemma, Arduino Ethernet, Arduino Yin, Arduino Zero, Mega ADK, Arduino 101 Genuino 101, Arduino mini, Lilypad Arduino Simple, Lilypad, Arduino Pro, Intel, Arduino Fio, Arduino Gemma, Arduino BT, Arduino Fio, Arduino Mega, Arduino Nano, Mega ADK, Arduino Uno, Arduino Diecimila, BananaPro, Intel, Intel Galileo, Arduino Ethernet, Arduino BT, Arduino Mega, Arduino Duemilanove, Arduino Nano, Esplora, Raspberry, Banana, Arduino Robot

Базовые знания

Цифровые выводы

Выводы платформы Arduino могут работать как входы или как выходы. Также аналоговые входы Arduino (ATmega) могут конфигурироваться и работать так же, как и цифровые порты ввода/вывода.

Выводы Arduino настроены как порты ввода, поэтому не требуется декларации в функции pinMode(). Сконфигурированные порты ввода находятся в высокоимпедансном состоянии. Это означает, что порт ввода дает слишком малую нагрузку на схему, в которую он включен. Для перевода порта ввода из одного состояния в другое требуется маленькое значение тока. Если к выводу ничего не подключено, то значения на нем будут принимать случайные величины, наводимые электрическими помехами.

Если на порт ввода не поступает сигнал, то рекомендуется задать порту известное состояние. Это делается добавлением подтягивающих резисторов 10 кОм, подключающих вход либо к питанию +5 В, либо к земле.

Микроконтроллер ATmega имеет программируемые встроенные подтягивающие резисторы 20 кОм. Программирование данных резисторов осуществляется так:

pinMode(pin, INPUT); // назначить выводу порт ввода

digitalWrite(pin, HIGH); // включить подтягивающий резистор

Выводы, сконфигурированные как порты вывода находятся в низкоимпедансном состоянии. Данные выводы могут пропускать через себя достаточно большой ток. Выводы микросхемы ATmega могут быть источником тока до 40 мА. Такого значения тока недостаточно для большинства реле, соленоидов и двигателей.

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

Аналоговые входы

Микроконтроллеры ATmega, используемые в Arduino, содержат шестиканальный аналого-цифровой преобразователь (АЦП). Разрешение преобразователя составляет 10 битов, что позволяет на выходе получать значения от 0 до 1023. Аналоговые входы могут использоваться как цифровые выводы портов ввода/вывода, при этом они имеют номера от 14 до 19:

pinMode(14,OUTPUT);

digitalWrite(14, HIGH);

Для вывода, работавшего ранее как цифровой порт вывода, команда analogRead будет работать некорректно. В этом случае рекомендуется сконфигурировать его как аналоговый вход.

Широтно-импульсная модуляция

Широтно-импульсная модуляция (ШИМ) — это операция получения изменяющегося аналогового значения посредством цифровых устройств. Подавая на выход сигнал, состоящий из высоких и низких уровней, мы моделируем напряжение между максимальным значением (5 В) и минимальным (0 В). Длительность включения максимального значения называется шириной импульса. Для получения различных аналоговых величин изменяется ширина импульса. В результате на выходе будет величина напряжения, равная площади под импульсами (рис. 5.1).

Вызов функции analogWrite() с масштабом 0–255 означает, что значение analogWrite(255) будет соответствовать 5 В (100 % рабочий цикл — постоянное включение 5 В), а значение analogWrite(127) — 2,5 В (50 % рабочий цикл).

Память в Arduino

В микроконтроллерах ATmega168, ATmega328, ATmega1280, ATmega2560, используемых на платформах Arduino, существует три вида памяти:

 флеш-память — используется для хранения скетчей;

 ОЗУ (статическая оперативная память) — служит для хранения и работы переменных;

 EEPROM (энергонезависимая память) — применяется для хранения постоянной информации.

Флеш-память и EEPROM являются энергонезависимыми видами памяти (данные сохраняются при отключении питания). ОЗУ является энергозависимой памятью.

Рис. Широтно-импульсная модуляция

Микроконтроллер ATmega168 имеет:

16 Кбайт флеш-памяти (2 Кбайт используется для хранения загрузчика);

1024 байта ОЗУ;

512 байт EEPROM.

 

Для ATmega328 эти показатели следующие:

 32 Кбайт флеш-памяти (2 Кбайт используется для хранения загрузчика);

 2 Кбайт ОЗУ;

 1024 байт EEPROM.

 

Для ATmega1280 эти показатели следующие:

 128 Кбайт флеш-памяти (2 Кбайт используется для хранения загрузчика);

8 Кбайт ОЗУ;

4096 байт EEPROM.

 

Для ATmega2560 эти показатели следующие:

 256 Кбайт флеш-памяти (2 Кбайт используется для хранения загрузчика);

16 Кбайт ОЗУ;

9182 байт EEPROM.

При отсутствии свободного места в ОЗУ могут произойти сбои программы.

 

Структура программы

Arduino программируется на языке Wiring, которого на самом деле не существует, как не существует и компилятора Wiring — написанные на Wiring программы преобразуются в программу на языке C/C++ и затем компилируются компилятором AVR-GCC. Фактически используется специализированный для микроконтроллеров AVR вариант C/C++.

 

Функции setup() и loop()

Функции setup() и loop()

Базовая структура программы для Arduino состоит, по меньшей мере, из двух обязательных частей: функций setup() и loop(). Перед функцией setup() идет объявление переменных, подключение библиотек. Функция setup() запускается один раз после каждого включения питания или сброса платы Arduino. Она используется для инициализации переменных, установки режима работы портов и прочих подготовительных для основного цикла программы действий. Она обязательно должна быть включена в программу, даже если не выполняет никаких действий.

Функция loop() в бесконечном цикле последовательно исполняет команды, которые описаны в ее теле. Эта функция выполняется циклически, она выполняет основную работу.

Пример простейшей программы

void setup()

{

Serial.begin(9600);

}

void loop()

{

Serial.println(millis());

delay(1000);

}

 

Синтаксис и операторы

Управляющие операторы

 

Оператор if (условие) и операторы сравнения ==, !=, < , >

 

Оператор if используется в сочетании с операторами сравнения, он проверяет, достигнута ли истинность условия — например, превышает ли входное значение заданное число. Формат оператора if следующий:

if (someVariable > 50){

// выполнять действия

}

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

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

Операторы сравнения:

 x == y (x равно y);

 x != y (x не равно y);

 x < y (x меньше чем y);

 x > y (x больше чем y);

 x <= y (x меньше чем или равно y);

 x >= y (x больше чем или равно y).

 

Оператор if..else

 

Конструкция if..else предоставляет больший контроль над процессом выполнения кода, чем базовый оператор if, позволяет сделать выбор "либо, либо". Например:

if (pinInput==HIGH)

{doFun1();}

else

{doFun2();}

Else позволяет делать отличную от указанной в if проверку, чтобы можно было осуществлять сразу несколько взаимоисключающих проверок. Каждая проверка позволяет переходить к следующему за ней оператору не раньше, чем получит логический результат ИСТИНА. Когда проверка с результатом ИСТИНА найдена, запускается вложенный в нее блок операторов, и затем программа игнорирует все следующие строки в конструкции if..else. Если ни одна из проверок не получила результат ИСТИНА, по умолчанию выполняется блок операторов в else, если последний присутствует, и устанавливается действие по умолчанию. Конструкция else if может быть использована с или без заключительного else и наоборот. Допускается неограниченное число таких переходов else if.

if (pinAnalogInput < 100)

{doFun1();}

else if (pinAnalogInput >= 150)

{doFun2();}

else

{doFun3();}

Другой способ создания переходов со взаимоисключающими проверками использует оператор switch case.

 

Оператор for

 

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

Заголовок цикла for состоит из трех частей:

for (initialization; condition; increment) {операторы, выполняющиеся в цикле}

Инициализация (initialization) выполняется самой первой и один раз. Каждый раз в цикле проверяется условие (condition), если оно верно, выполняется блок операторов и приращение (increment), затем условие проверяется вновь. Когда логическое значение условия становится ложным, цикл завершается. приведен пример затемнения светодиода с использованием ШИМ-вывода.

// Затемнение светодиода с использованием ШИМ-вывода

int PWMpin = 10; // Светодиод последовательно с R=470 Ом на 10 выводе void setup()

{;}

void loop()

{

for (int i=0; i <= 255; i++)

{

analogWrite(PWMpin, i);

delay(10);

}

}

Оператор switch

Конструкция switch...case управляет процессом выполнения программы, позволяя программисту задавать альтернативный код, который будет выполняться при разных условиях. Оператор switch сравнивает значение переменной со значением, определенном в операторах case. Когда найден оператор case, значение которого равно значению переменной, выполняется программный код в этом операторе. Ключевое слово break является командой выхода из оператора case и обычно используется в конце каждого case. Без оператора break оператор switch будет продолжать вычислять следующие выражения, пока не достигнет break или конец опе- ратора switch. Синтаксис команды switch...case представлен .

switch (var)

{

case label1:

// код для выполнения break;

case label2:

// код для выполнения break;

case label3:

// код для выполнения break;

default:

// код для выполнения break;

}

Параметры:

? var — переменная, которая вычисляется для сравнения с вариантами в case;

? label — значение, с которым сравнивается значение переменной.

 

Оператор while

Оператор while будет вычислять в цикле непрерывно и бесконечно до тех пор, пока выражение в круглых скобках не станет равно логическому ЛОЖНО. Что-то должно изменять значение проверяемой переменной, иначе выход из цикла while никогда не будет достигнут. Это изменение может происходить как в программном коде, например, при увеличении переменной, так и во внешних условиях, например, при тестировании датчика. Синтаксис команды следующий:

while(выражение)

{

// операторы

}

Пример использования оператора while .

var i=0; while($i<100)

{

// операторы i++;

}

Оператор do ... while

 

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

do {

delay(50); // подождать, пока датчики стабилизируются

x = readSensors(); // проверить датчики

} while (x < 100);

Оператор break

 

Оператор break используется для принудительного выхода из циклов do, for или while, не дожидаясь завершения цикла по условию. Он также используется для выхода из оператора switch. Пример приведен.

for (x = 0; x < 255; x ++)

{

digitalWrite(PWMpin, x);

sens = analogRead(sensorPin);

if (sens > threshold)

{ // выходим из цикла, если есть сигнал с датчика x = 0;

break;

}

delay(50);

}

 

Оператор continue

Оператор continue пропускает оставшиеся операторы в текущем шаге цикла. Вместо них выполняется проверка условного выражения цикла, которая происходит при каждой следующей итерации.

Пример.

for (x = 0; x < 255; x ++)

{

if (x > 40 && x < 120)

{ // если истина то прыгаем сразу на следующую итерацию цикла continue;

}

digitalWrite(PWMpin, x);

delay(50);

}

 

Оператор return

 

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

int checkSensor()

{

if (analogRead(0) > 200) return 1;

else{ return 0;

}

 

 

Синтаксис

 

; (точка с запятой) ; (semicolon)

 

; (точка с запятой) используется для обозначения конца оператора.

int a = 13;

 

{} (фигурные скобки) {} (curly braces)


Фигурные скобки {} — важный элемент языка программирования С. Открывающая скобка { должна всегда сопровождаться закрывающей скобкой }. Это условие, известное как парность (симметричность) фигурных скобок.

Основные способы использования фигурных скобок:

 функции:

• void НазваниеФункции (тип данных аргумента) { оператор(ы) };

 циклы:

• while (логическое выражение){ оператор(ы)};

• do { оператор(ы)} while (логическое выражение);

• for (инициализация; условие окончания цикла; приращения цикла)

{ оператор(ы)};

 условные операторы:

• if (логическое выражение) {оператор(ы)}.

 

 

Комментарии // (single line comment), /* */ (multi-line comment)

 

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

Есть два способа пометить строку как комментарий:

 однострочный комментарий — // ;

 многострочный комментарий — /* ... */ .

Пример

x = 5; // Это комментарий в одной строке. Все после двойного // слэша – комментарий до конца строки

/* это многострочный комментарий – используйте его для закомментирования целых кусков кода */

 

 

Арифметические операторы

 

 

= (assignment) = оператор присваивания

Присваивает переменной слева от оператора значение переменной или выражения, находящееся справа

int sensVal; // объявление переменной типа integer

senVal=analogRead(0); // присваивание переменной sensVal значение,

// считанное с аналогового входа 0

Переменная слева от оператора присваивания (=) должна быть способна сохранить присваиваемое значение. Если оно выходит за диапазон допустимых значений, то сохраненное значение будет не верно. Необходимо различать оператор присваивания (=) и оператор сравнения (== двойной знак равенства), который осуществляет проверку на равенство.

 

+ (cложение), - (вычитание), * (умножение) , / (деление)

Операторы +, -, * и /, соответственно, возвращают результат выполнения арифметических действий над двумя операндами. Возвращаемый результат будет зависеть от типа данных операндов, например, 9 / 4 возвратит 2, т. к. операнды 9 и 4 имеют тип int. Также следует следить за тем, чтобы результат не вышел за диапазон допустимых значений для используемого типа данных. Так, например, сложение 1 с переменной типа int и значением 32 767 возвратит –32 768. Если операнды имеют разные типы, то тип с более "широким" диапазоном будет использован для вычислений. Если один из операндов имеет тип float или double, то арифметика "с плавающей запятой" будет использована для вычислений.

 

% (modulo)

 

Возвращает остаток от деления одного целого (int) операнда на другой. Примеры:

x = 9 % 5; // x имеет значение 4

x = 5 % 5; // x имеет значение 0

Нельзя применить к типу float.

 

Операторы сравнения

 

Операторы сравнения:

 x == y (x равно y);

 x != y (x не равно y);

 x < y (x меньше чем y);

 x > y (x больше чем y);

 x <= y (x меньше чем или равно y);

 x >= y (x больше чем или равно y).

 

 

 Унарные операторы

 

++ (увеличение значения) / -- (уменьшение значения)

 

Унарные (имеющие один операнд) операторы ++, -- увеличивают, уменьшают значение переменной соответственно

x++; // увеличивает значение x на единицу и возвращает старое значение x

++x; // увеличивает значение x на единицу и возвращает новое значение x

x-- ; // уменьшает значение x на единицу и возвращает старое значение x

--x ; // уменьшает значение x на единицу и возвращает новое значение x

 

+= , -= , *= , /=

 

Короткий способ записи арифметических действий над переменной и одним операндом.

x += y; // эквивалент записи x = x + y;

x -= y; // эквивалент записи x = x - y;

x *= y; // эквивалент записи x = x * y;

x /= y; // эквивалент записи x = x / y;

 

 

 

Логические операторы

 

Логические операторы чаще всего используются в проверке условия оператора if.

 

(&& (логическое И))

Истина, если оба операнда истина (true).

Пример:

if (digitalRead(2) == HIGH && digitalRead(3) == HIGH) Serial.println("ok");

 

(II(логическое ИЛИ))


Истина, если хотя бы один операнд истина.

Пример:

if (digitalRead(2) == || digitalRead(3) == HIGH)

Serial.println("ok");

 

(!логическое отрицание))

Истина, если операнд false, и наоборот.

Пример:

if (!(digitalRead(2)== HIGH))

Serial.println("ok");

 

Данные

Типы данных

Компилятор Arduino определяет следующие типы данных:

 boolean;

 char;

 byte;

 int;

 unsigned int;

 long;

 unsigned long;

 float;

 double;

 string;

 массив (array);

 void.

Рассмотрим типы данных более подробно.

boolean

Логический (булевый) тип данных — boolean. Может принимать одно из двух значений: true или false. Данные типа boolean занимают в памяти один байт.

char

 

Переменная типа char занимает 1 байт памяти и может хранить один алфавитно-цифровой символ (литеру). При объявлении литеры используются одиночные кавычки: 'A' (двойные кавычки используются при объявлении строки символов — тип string: "ABC").

Символ хранится в памяти как число, соответствующее коду символа в таблице кодировки символов ASCII. Так как символ хранится как число, в памяти над ним возможно производить арифметические действия (например, 'A' + 1 будет 66, т. к. ASCII код для 'A' — 65).

Тип char знаковый тип, т. е. число (код), хранящийся в памяти, может принимать значения от –128 до 127. Если необходима знаковая однобайтовая переменная, используйте тип byte.

Пример:

char myChar = 'A';

char myChar = 65; // Варианты эквивалентны

byte

Хранит 8-битовое числовое значение без десятичной точки. Имеет диапазон от 0 до 255.

Пример:

byte someVariable=150; // объявление переменной someVariable,

// имеющей тип byte

 

int

 

Тип данных int (от англ. integer — целое число) — один из наиболее часто используемых типов данных для хранения чисел. int занимает 2 байта памяти и может хранить числа от –32 768 до 32 767.

Для размещения отрицательных значений int использует так называемый дополнительный код представления числа. Старший бит указывает на отрицательный знак числа, остальные биты инвертируются с добавлением 1.

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

Когда переменная типа int вследствие арифметической операции достигает своего максимального значения, она "перескакивает" на самое минимальное значение и наоборот .

int x;

x = -32,768;

x = x - 1; // x теперь равно 32,767 x = 32,767;

x = x + 1; // x теперь равно -32,768

 

unsigned int

 

Тип данных unsigned int — беззнаковое целое число, так же как и тип int (знаковое), занимает в памяти 2 байта. Но в отличие от int, тип unsigned int может хранить только положительные целые числа в диапазоне от 0 до 65 535.

Отличие кроется в том, как unsigned int использует старший бит, иногда называемый знаковым битом. Если старший бит равен 1, то для типа int компилятор Arduino считает, что это число отрицательное, а остальные 15 битов несут информацию о модуле целого числа в дополнительном коде представления числа, в то время как unsigned int использует все 16 битов для хранения модуля числа.

Когда переменная типа unsigned int вследствие арифметической операции достигает своего максимального значения, она "перескакивает" на самое минимальное значение и наоборот.

unsigned int x; x = 0;

x = x - 1; // x теперь равна 65535

x = x + 1; // x теперь 0

 

long

 

Тип данных long используется для хранения целых чисел в расширенном диапазоне от –2 147 483 648 до 2 147 483 647. long занимает 4 байта в памяти. Пример:

long var1 = -178000;

 

unsigned long

 

Unsigned long используется для хранения положительных целых чисел в диапазоне от 0 до 4 294 967 295 и занимает 32 бита (4 байта) в памяти. Пример вывода в мил- лисекундах (мс) с начала выполнения программы приведен

void loop()

{

Serial.print("Time: ");

time = millis();

//выводит время, прошедшее с момента начала выполнения программы Serial.println(time);

function1();

}

 

float

 

Тип данных float служит для хранения чисел с плавающей запятой. Этот тип часто используется для операций с данными, считываемыми с аналоговых входов. Диапазон значений — от –3,4028235E+38 до 3,4028235E+38. Переменная типа float занимает 32 бита (4 байта) в памяти.

Тип float имеет точность 6–7 знаков, имеются в виду все знаки, а не только мантисса. Обычно для увеличения точности используют другой тип — double, но на платформе Arduino double и float имеют одинаковую точность.

 

double

 

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

Тип double поддерживается в Arduino для совместимости кода с другими платформами.

 

string — текстовые строки

 

Текстовые строки в Arduino объявляются как массив (array) типа char (символов, литер), оканчивающийся символом "конца строки". Возможны следующие варианты объявления текстовых строк;

 объявить массив символов без присваивания значений;

 объявить массив символов и присвоить значения всем элементам, кроме последнего, компилятор Arduino автоматически добавит символ конца строки;

 явно объявить завершающий символ;

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

 инициализировать массив с явным заданием размера и присвоением строковой константы;

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

приведены варианты объявления и присвоения строк.

char Str1[15];

char Str2[8] = {'a','r','d','u','i','n','o'};

char Str3[8] = {'a','r','d','u','i','n','o','\0'};

char Str4[ ] = "arduino";

char Str5[8] = "arduino";

char Str6[15] = "arduino";

Обычно строки оканчиваются нулевым символом (код 0 в ASCII). Это позволяет функциям (таким как Serial.print()) выявлять окончание строки. В противном случае могут считаться байты памяти, не принадлежащие переменной.

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

Строки всегда объявляются внутри двойных кавычек ("Abc").

При работе с большими объемами текстовой информации бывает удобно использо- вать массивы строк. Так как строки сами по себе массивы, массив строк будет двумерным массивом.

В примере, приведенном, символ звездочки после объявления типа "char*" указывает на то, что это массив указателей. Это необходимо для задания двумерного массива.

char* myStrings[]={"string 1", "string 2", "string 3","string 4",

"string 5","string 6"};

void setup()

{Serial.begin(9600);}

void loop()

{

for (int i = 0; i < 6; i++){ Serial.println(myStrings[i]);

delay(500);

}

}

 

 

 

Массивы

Массивы — именованный набор однотипных переменных с доступом к отдельным элементам по их индексу. Существует несколько вариантов объявления массива:

 массив может быть объявлен без непосредственной инициализации элементов массива:

int myInts[6];

 массив может быть объявлен без явного задания размера. Компилятор сам посчитает фактическое количество элементов и создаст в памяти массив необходимого размера:

int myPins[] = {2, 4, 8, 3, 6};

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

int mySensVals[6] = {2, 4, -8, 3, 2};

char message[6] = "hello";

Индексация массива начинается с 0. Присваивание значения элементу массива происходит следующим образом:

mySensVals[0] = 10;

Получение значения массива:

x = mySensVals[4];

Чаще всего для перебора элементов цикла используется цикл for, счетчик цикла используется как индекс для доступа к каждому элементу массива. Например, для вывода массива через последовательный порт (Serial) можно использовать следующий код:

int i;

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

{ Serial.println(myPins[i]); }

 

void

void

Ключевое слово void используется при объявлении функций, если функция не возвращает никакого значения при ее вызове.

Константы

Константы — предопределенные значения. Они используются, чтобы делать программы более легкими для чтения. Объявление констант (а также базовых макросов и функций) можно посмотреть в файле \hardware\arduino\cores\arduino\ wiring.h. Рассмотрим некоторые константы.

true/false — это булевы константы, определяющие логические уровни. false легко определяется как 0 (ноль), а true, как 1, но может быть и чемто другим, отличным от нуля. Поэтому –1, 2 и 200 — это все тоже определяется как true.

#define true 0x1

#define false 0x0

HIGH/LOW — уровни сигналов порта HIGH и LOW:

#define HIGH 0x1

#define LOW 0x0

INPUT/OUTPUT — настройка цифровых портов на ввод (INPUT) и вывод (OUTPUT) сигналов:

#define INPUT 0x0

#define OUTPUT 0x1

Цифровые порты могут использоваться на ввод или вывод сигналов. Изменение порта с ввода на вывод производится при помощи функции pinMode():

pinMode(13, OUTPUT); // 13 вывод будет выходом

pinMode(12, INPUT); // 12 – входом

В программе можно создавать собственные константы:

#define LEFT 0x95

#define MESS_LEFT "поворот влево"

 

Переменные

 

Переменные — это способ именовать и хранить числовые значения для последующего использования программой.

Переменные — это значения, которые могут последовательно меняться, в отличие от констант, чье значение никогда не меняется. Переменные нужно декларировать (объявлять). Следующий код объявляет переменную inputVariable, а затем присваивает ей значение, полученное от 2-го аналогового порта:

int inputVariable=0;

inputVariable=analogRead(2);

Переменные могут быть названы любыми именами, которые не являются ключевыми словами языка программирования Arduino.

 

Объявление переменных

 

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

Следующий пример показывает, что объявленная переменная inputVariable имеет тип int, и ее начальное значение равно нулю. Это называется простым присваиванием.

int inputVariable = 0;

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

 

Границы переменных

 

Переменные могут быть объявлены в начале программы перед void setup(), локально внутри функций и иногда в блоке выражений, таком как цикл for. То, где объявлена переменная, определяет ее границы (область видимости), т. е. возможность некоторых частей программы ее использовать.

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

Локальные переменные определяются внутри функций или таких частей, как цикл for. Они видимы и могут использоваться только внутри функции, в которой объявлены. Таким образом, могут существовать несколько переменных с одинаковыми именами в разных частях одной программы, которые содержат разные значения. Уверенность, что только одна функция имеет доступ к ее переменной, упрощает программу и уменьшает потенциальную опасность возникновения ошибок.

 

 

Преобразование типов данных

 

 

char()

 

char() приводит значение к типу char.

Синтаксис:

char(x);

где x — переменная любого типа.

 

byte()

 

byte() приводит значение к типу byte.

Синтаксис:

byte(x);

где x — переменная любого типа.

 

int()

 

int() приводит значение к типу int.

Синтаксис:

int(x);

где x — переменная любого типа.

 

long()

 

long() приводит значение к типу long.

Синтаксис:

long(x);

где x — переменная любого типа.

 

float()

 

float() приводит значение к типу float.

Синтаксис:

long(x);

где x — переменная любого типа.

 

 

Функции

Цифровой ввод/вывод

 

Рассмотрим функции цифрового ввода/вывода:

 pinMode();

 digitalWrite();

 digitalRead().

 

Функция pinMode

 

Устанавливает режим работы заданного входа/выхода (pin) как входа или как выхода.

Синтаксис:

pinMode(pin, mode);

Параметры:

 pin — номер входа/выхода (pin), который вы хотите установить;

 mode — режим. Одно из двух значений: INPUT или OUTPUT устанавливает на вход или выход соответственно.

Пример:

int ledPin = 13; // Светодиод, подключенный к входу/выходу 13 void setup()

{

pinMode(ledPin, OUTPUT); // устанавливает режим работы - выход

}

 

Функция digitalWrite()

 

Подает HIGH или LOW значение на цифровой вход/выход (pin).

Если вход/выход (pin) был установлен в режим выход (OUTPUT) функцией pinMode(), то для значения HIGH напряжение на соответствующем входе/выходе (pin) будет 5 В (3,3 В для плат 3,3 В) и 0 В (земля) для LOW.

Если вход/выход (pin) был установлен в режим вход (INPUT), то функция digitalWrite со значением HIGH будет активировать внутренний нагрузочный резистор 20 K. Подача LOW в свою очередь отключает этот резистор. Нагрузочного резистора достаточно, чтобы светодиод, подключенный к входу, светил тускло. Если вдруг светодиод работает, но очень тускло, возможно необходимо установить режим выход (OUTPUT) функцией pinMode().

Синтаксис: digitalWrite(pin, value); Параметры:

 pin — номер входа/выхода (pin);

 value — значение HIGH или LOW.

Пример.

int ledPin = 13; // Светодиод, подключенный к входу/выходу 13 void setup()

{

pinMode(ledPin, OUTPUT); // устанавливает режим работы – выход

}

void loop()

{

digitalWrite(ledPin, HIGH);

// включает светодиод

delay(1000);

// ждет секунду

digitalWrite(ledPin, LOW);

// выключает светодиод delay(1000);

// ждет секунду

}

 

Функция digitalRead()

 

Функция считывает значение с заданного входа: HIGH или LOW.

Синтаксис:

digitalRead(pin);

Параметр: pin — номер входа/выхода (pin), который вы хотите считать.

Пример

int ledPin = 13; // Светодиод, подключенный к входу/выходу 13

int inPin = 7; // кнопка на входе 7

int val = 0; // переменная для хранения значения void setup()

{

pinMode(ledPin, OUTPUT); // устанавливает режим работы - выход для 13

pinMode(inPin, INPUT); // устанавливает режим работы - вход для 7

}

void loop()

{

val = digitalRead(inPin); // считываем значение с входа

digitalWrite(ledPin, val); // устанавливаем значение на светодиоде

// равным значению входа кнопки

}

ЗАМЕЧАНИЕ

Если вход не подключен, то digitalRead может возвращать значения HIGH или LOW случайным образом. Аналоговые входы (analog pins) могут быть использованы как цифровые входы/выходы (digital pins). Обращение к ним идет по номерам от 14 (для аналогового входа 0) до 19 (для аналогового входа 5).

 

 

Аналоговый ввод/вывод

 

Рассмотрим функции аналогового ввода/вывода:

❒  analogRead();

 analogReference();

 analogWrite().

 

Функция analogRead()

 

Функция считывает значение с указанного аналогового входа. Большинство плат Arduino имеют 6 каналов (8 каналов у платы Mini и Nano, 16 — у Mega) c 10-битным аналого-цифровым преобразователем (АЦП). Напряжение, поданное на аналоговый вход (обычно от 0 до 5 вольт), будет преобразовано в значение от 0 до 1023 — это 1024 шага с разрешением 0,0049 вольт. Разброс напряжения и шаг может быть изменен функцией analogReference(). Считывание значения с аналогового входа занимает примерно 100 микросекунд (0,0001 сек), т. е. максимальная частота считывания приблизительно 10 000 раз в секунду.

Синтаксис:

analogRead(pin);

Параметр: pin — номер порта аналогового входа, с которого будет производиться считывание: 0..5 для большинства плат, 0..7 для Mini и Nano и 0..15 для Mega.

Возвращаемое значение int (0 to 1023).

ЗАМЕЧАНИЕ

Если аналоговый вход не подключен, то значения, возвращаемые функцией analogRead(), могут принимать случайные значения.

Пример .

int analogPin = 3; // номер порта, к которому подключен потенциометр

int val = 0; // переменная для хранения считываемого значения

void setup()

{

Serial.begin(9600); // установка связи по serial

}

void loop()

{

val = analogRead(analogPin); // считываем значение

Serial.println(val); // выводим полученное значение

}

 

Функция analogReference()

 

Функция определяет опорное напряжение, относительно которого происходят аналоговые измерения. Функция analogRead() возвращает значение с разрешением 8 битов (1024) пропорционально входному напряжению на аналоговом входе и в зависимости от опорного напряжения.

Возможные настройки:

 DEFAULT — стандартное опорное напряжение 5 В (на платформах с напряжением питания 5 В) или 3,3 В (на платформах с напряжением питания 3,3 В);

 INTERNAL — встроенное опорное напряжение 1,1 В на микроконтроллерах ATmega168 и ATmega328 и 2,56 В на ATmega8;

 EXTERNAL — внешний источник опорного напряжения, подключенный к выводу AREF.

Синтаксис:

analogReference(type);

Параметр: type — определяет используемое опорное напряжение (DEFAULT, INTERNAL или EXTERNAL).

Внешнее напряжение рекомендуется подключать к выводу AREF через резистор 5 кОм.

Рекомендуемой настройкой для вывода AREF является EXTERNAL. При этом происходит отключение обоих внутренних источников, и внешнее напряжение будет являться опорным для АЦП.

 

Функция analogWrite()

 

Выдает аналоговую величину (ШИМ-волну) на порт входа/выхода. Функция может быть полезна для управления яркостью подключенного светодиода или скоростью вращения электродвигателя. После вызова analogWrite() на выходе будет генерироваться постоянная прямоугольная волна с заданной шириной импульса до следующего вызова analogWrite (или вызова digitalWrite или digitalRead на том же порту входа/выхода). Частота ШИМ-сигнала приблизительно 490 Гц.

На большинстве плат Arduino (на базе микроконтроллера ATmega168 или ATmega328) ШИМ поддерживают порты 3, 5, 6, 9, 10 и 11, на плате Arduino Mega — порты с 2 по 13. На более ранних версиях плат Arduino analogWrite() ра- ботал только на портах 9, 10 и 11.

Для вызова analogWrite() нет необходимости устанавливать тип входа/выхода функцией pinMode(). Функция analogWrite() никак не связана с аналоговыми входами и с функцией analogRead().

Синтаксис: analogWrite(pin, value);

Параметры:

 pin — порт входа/выхода, на который подается ШИМ-сигнал;

 value — период рабочего цикла: значение между 0 (полностью выключено) и 255 (сигнал подан постоянно).

ЗАМЕЧАНИЕ

Период ШИМ-сигнала на портах входа/выхода 5 и 6 будет несколько длиннее. Это связано с тем, что таймер для данных выходов также задействован функциями millis() и delay(). Данный эффект более заметен при установке коротких периодов ШИМ-сигнала (0–10).

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

int ledPin = 9; // Светодиод подключен к выходу 9

int analogPin = 3; // потенциометр подключен к выходу 3

int val = 0; // переменная для хранения значения

void setup()

{

pinMode(ledPin, OUTPUT); // установка порта на выход

}

void loop()

{

val = analogRead(analogPin); // считываем значение с порта,

// подключенного к потенциометру

analogWrite(ledPin, val / 4); // analogRead возвращает значения от 0

// до 1023, analogWrite должно быть

// в диапазоне от 0 до 255

}

 

 

Дополнительные фунции ввода/вывода

 

Функция tone()

 

Генерирует на порту входа/выхода сигнал — прямоугольную "волну" заданной частоты и с 50 % рабочим циклом. Длительность может быть задана параметром, в противном случае сигнал генерируется до тех пор, пока не будет вызвана функция noTone(). К порту входа/выхода может быть подключен пьезо- или иной динамик для воспроизведения сигнала.

Воспроизводиться одновременно может только один сигнал. Если сигнал уже воспроизводится на одном порту, то вызов tone() с номером другого порта в качестве параметра ни к чему не приведет, если же tone() будет вызвана с тем же номером порта, то будет установлена новая частота сигнала.

Использование функции tone() помешает использовать ШИМ на портах входа/выхода 3 и 11 (кроме платы Arduino Mega).

Синтаксис:

tone(pin, frequency); tone(pin, frequency, duration);

Параметры:

 pin — номер порта входа/выхода, на котором будет генерироваться сигнал;

 frequency — частота сигнала в герцах;

 duration — длительность сигнала в миллисекундах.

 

Функция noTone()

 

Останавливает сигнал, генерируемый на порту входа/выхода, вызовом функции

Если сигнал не генерировался, то вызов noTone() ни к чему не приводит.

ЗАМЕЧАНИЕ

Если необходимы сигналы на разных портах, то следует сначала остановить один сигнал функцией noTone(), а лишь затем создавать новый сигнал на другом порту функцией Tone().

Синтаксис:

noTone(pin);

Параметр: pin — номер порта входа/выхода, на котором прекращается сигнал.

 

Функция shiftOut()

 

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

Такой способ передачи данных называется последовательным протоколом с синхронизацией. Он часто используется для взаимодействия микроконтроллеров с датчиками и сенсорами, а также другими микроконтроллерами. Последовательная передача с синхронизацией позволяет устройствам связываться на максимальной скорости. Смотрите также документацию (на англ. языке) по протоколу последовательного периферийного интерфейса (SPI, Serial Peripheral Interface Protocol).

Синтаксис:

shiftOut(dataPin, clockPin, bitOrder, value);

Параметры:

 dataPin — номер порта входа/выхода, на который выводятся биты (int);

 clockPin — номер порта, по которому производится синхронизация (int);

 bitOrder — используемая последовательность вывода битов. MSBFIRST (Most Significant Bit First) — слева или LSBFIRST (Least Significant Bit First) — справа;

 value — значение (байт) для вывода (byte).

ЗАМЕЧАНИЕ

Порт вывода (dataPin) и синхронизирующий порт (clockPin) должны быть предварительно сконфигурированы как порты вывода с помощью функции pinMode().

Текущая реализация функции shiftOut() может выводить только один байт (8 битов) информации, поэтому необходимо произвести несколько действий, чтобы вывести значения больше 255. Пример вывода

// Вывод будет MSBFIRST с первого (левого) бита int data = 500;

// выводим старший байт

shiftOut(dataPin, clock, MSBFIRST, (data >> 8));

// выводим младший бит

shiftOut(dataPin, clock, LSBFIRST, data);

// выводим старший бит

shiftOut(dataPin, clock, LSBFIRST, (data >> 8));

 

Пример вывода счетчика от 0 до 255 на сдвиговый регистр с последовательным вводом 74HC595

 

// Порт, подключенный к ST_CP 74HC595 int latchPin = 8;

// Порт, подключенный к SH_CP 74HC595 int clockPin = 12;

// Порт, подключенный к DS 74HC595 int dataPin = 11;

void setup()

{

// устанавливаем режим порта выхода pinMode(latchPin, OUTPUT); pinMode(clockPin, OUTPUT); pinMode(dataPin, OUTPUT);

}

void loop()

{

for (int j = 0; j < 256; j++)

{

// устанавливаем LOW на latchPin, пока не окончена передача байта digitalWrite(latchPin, LOW);

shiftOut(dataPin, clockPin, LSBFIRST, j);

// устанавливаем HIGH на latchPin, чтобы проинформировать регистр, что

// передача окончена. digitalWrite(latchPin, HIGH); delay(1000);

}

}

 

Функция pulseIn()

 

Считывает длину сигнала на заданном порту (HIGH или LOW). Например, если задано считывание HIGH функцией pulseIn(), функция ожидает, пока на заданном порту не появится HIGH. Когда HIGH получен, включается таймер, который будет остановлен, когда на порту входа/выхода будет LOW. Функция pulseIn() возвращает длину сигнала в микросекундах. Функция возвращает 0, если в течение заданного времени (тайм-аута) не был зафиксирован сигнал на порту.

Возможны некоторые погрешности в измерении длинных сигналов. Функция может измерять сигналы длиной от 10 микросекунд до 3 минут.

Синтаксис:

pulseIn(pin, value); pulseIn(pin, value, timeout);

Параметры:

 pin — номер порта входа/выхода, на котором будет ожидаться сигнал;

 value — тип ожидаемого сигнала: HIGH или LOW;

 timeout — время ожидания сигнала (тайм-аут) в секундах (unsigned long).

Возвращаемые значения: длина сигнала в микросекундах или 0, если сигнал не получен до истечения тайм-аута (тип unsigned long).

Пример использования функции

int pin = 7;

unsigned long duration; void setup()

{

pinMode(pin, INPUT);

}

void loop()

{

duration = pulseIn(pin, HIGH);

}

 

 

 

 

Работа со временем

 

Функция millis()

 

Возвращает количество миллисекунд с момента начала выполнения текущей программы на плате Arduino. Это количество сбрасывается на ноль вследствие переполнения значения приблизительно через 50 дней.

Параметров нет.

Возвращаемое значение — количество миллисекунд с момента начала выполнения программы (тип unsigned long).

Пример .

unsigned long time; void setup()

{

Serial.begin(9600);

}

void loop()

{

Serial.print("Time: "); time = millis();

// выводит количество миллисекунд с момента начала выполнения программы Serial.println(time);

// ждет секунду перед следующей итерацией цикла. delay(1000);

}

 

Функция micros()

 

Возвращает количество микросекунд с момента начала выполнения текущей программы на плате Arduino. Значение переполняется и сбрасывается на ноль приблизительно через 70 минут. На платах Arduino с 16 МГц (Duemilanove и Nano) функция micros() имеет разрешение 4 секунды (возвращаемое значение всегда кратно 4). На платах с 8 МГц (Arduino Lilypad) — разрешение функции 8 секунд.

Параметров нет.

Возвращаемое значение — количество микросекунд с момента начала выполнения программы (unsigned long).

Пример использования функции

unsigned long time; void setup()

{

Serial.begin(9600);

}

void loop()

{

Serial.print("Time: "); time = micros();

// выводит количество микросекунд с момента начала выполнения

// программы Serial.println(time);

// ждет секунду перед следующей итерацией цикла. delay(1000);

}

 

Функция delay()

 

Останавливает выполнение программы на заданное в параметре количество миллисекунд (1000 миллисекунд в 1 секунде).

Синтаксис:

delay(ms);

 

Параметр:

ms — количество миллисекунд, на которое приостанавливается выполнение программы ( тип unsigned long).

Пример

int ledPin = 13; // светодиод подключен на порт 13 void setup()

{

pinMode(ledPin, OUTPUT); // устанавливается режим порта – выход

}

void loop()

{

digitalWrite(ledPin, HIGH); // включаем светодиод

delay(1000); // ожидаем секунду

digitalWrite(ledPin, LOW); // выключаем светодиод

delay(1000); // ожидаем секунду

}

Не рекомендуется использовать эту функцию для событий длиннее 10 миллисекунд, т. к. во время останова не могут быть произведены манипуляции с портами, не могут быть считаны сенсоры или произведены математические операции. В качестве альтернативного подхода возможно контролирование времени выполнения тех или иных функций с помощью millis(). При использовании функции delay() работа прерываний не останавливается, продолжается запись последовательно (serial) передаваемых данных на RX-порту, ШИМ-сигнал (analogWrite) продолжает генерироваться на портах.

 

Функция delayMicroseconds()

 

Останавливает выполнение программы на заданное в параметре количество микро- секунд (1 000 000 микросекунд в 1 секунде).

В данной версии Arduino максимальная пауза, воспроизводимая корректно, — 16 383. Возможно, это будет изменено в следующих версиях Arduino. Для остановки выполнения программы, более чем на несколько тысяч микросекунд, рекомендуется использовать функцию delay().

 

Синтаксис:

delayMicroseconds(us);

Параметр:

us — количество микросекунд, на которое приостанавливается выполнение программы (unsigned int).

 

Пример использования функции

 

int outPin = 8; // цифровой порт входа/выхода 8 void setup()

{

pinMode(outPin, OUTPUT); // устанавливается режим порта – выход

}

void loop()

{

digitalWrite(outPin, HIGH); // подаем HIGH на выход delay(50); // ожидаем 50 микросекунд digitalWrite(outPin, LOW); // устанавливаем LOW на выходе delay(50); // ожидаем 50 микросекунд

}

 

 

 

Математические функции

 

В языке представлены следующие математические функции:

 min();

 max();

 abs();

 constrain();

 map();

 pow();

 sq();

 sqrt().

 

Функция min(x,yx)

 

Возвращает наименьшее из двух значений. Параметры:

 x — первое число, любой тип;

 y — второе число, любой тип.

Возвращаемое значение — возвращает меньшее из двух сравниваемых значений. Пример использования функции:

sensVal = min(sensVal, 100);

// проверяем, если sensVal больше 100, то senseVal будет присвоено 100

 

Функция max(x, y)

 

Возвращает большее из двух значений.

Параметры:

 x — первое число, любой тип;

 y — второе число, любой тип.

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

sensVal = max(sensVal, 20);

// проверяем, если sensVal меньше 20, то senseVal будет присвоено 20

Функция max() зачастую используется для ограничения нижней границы значений переменной. Функцией min() ограничивают верхнюю границу переменной. В силу специфики реализации функции max() следует избегать использования других функций в качестве параметров.

Например:

max(a--, 0); // может привести к некорректным результатам a--;

max(a, 0); // так корректно

 

Функция abs()

 

Возвращает модуль числа.

Параметр: x — число.

Возвращаемые значения:

 x — если x больше или равен 0;

 -x — если x меньше 0.

В силу специфики реализации функции abs() следует избегать использования других функций в качестве параметров:

abs (a++); // может привести к некорректным результатам a++;

abs(a, 0); // так корректно

 

Функция constrain(x, a, b)

 

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

Параметры:

 x — проверяемое значение, любой тип;

 a — нижняя граница области допустимых значений, любой тип;

 b — верхняя граница области допустимых значений, любой тип.

Возвращаемое значение:

 x — если x входит в область допустимых значений [a..b];

 a — если x меньше a;

 b — если x больше b.

Пример:

sensVal = constrain(sensVal, 10, 150);

// ограничиваем значения sensVal диапазоном от 10 до 150

 

Функция map(value, fromLow, fromHigh, toLow, toHigh)

 

Функция пропорционально переносит значение (value) из текущего диапазона значений (fromLow .. fromHigh) в новый диапазон (toLow .. toHigh), заданный параметрами.

Функция map() не ограничивает значение рамками диапазона, как это делает функция constrain(). Функция contsrain() может быть использована до или после вызова map(), если необходимо ограничить допустимые значения заданным диапазоном.

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

y = map(x, 1, 50, 50, 1);

Возможно использование отрицательных значений:

y = map(x, 1, 50, 50, -100);

Функция map() оперирует целыми числами. При пропорциональном переносе дробная часть не округляется по правилам, а просто отбрасывается.

Параметры:

❒  value — значение для переноса;

 fromLow — нижняя граница текущего диапазона;

 fromHigh — верхняя граница текущего диапазона;

 toLow — нижняя граница нового диапазона, в который переносится значение;

 toHigh — верхняя граница нового диапазона. Возвращаемое значение — значение в новом диапазоне. Пример использования функции представлен в листинге 5.30.

// Переносим значение с аналогового входа

// (возможные значения от 0 до 1023) в 8 бит (0..255) void setup()

{;}

void loop()

{

int val = analogRead(0);

val = map(val, 0, 1023, 0, 255); analogWrite(9, val);

}

 

Функция pow(base, exponent)

 

Вычисляет значение, возведенное в заданную степень. Функция pow() может возводить и в дробную степень.

Параметры:

 base — число (тип float);

 exponent — степень, в которую будет возводиться число (тип float). Возвращаемое значение — результат возведения в степень, число (тип double).

 

Функция sq(x)

 

Функция возвращает квадрат числа, заданного параметром.

Параметр: x — число, любой тип.

Возвращаемое значение — квадрат числа.

 

Функция sqrt(x)

 

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

Параметры: x — число, любой тип.

Возвращаемое значение — квадратный корень числа (тип double).

 

 

 

Тригонометрические функции

 

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

 sin();

 cos();

 tan().

 

Функция sin(rad)

 

Возвращает синус угла, заданного в радианах в передаваемом параметре. Результат функции всегда в диапазоне –1 .. 1.

Параметр: rad — угол в радианах (float). Возвращаемое значение: синус угла (тип double).

 

Функция cos(rad)

 

Возвращает косинус угла, заданного в радианах в передаваемом параметре. Результат функции всегда находится в диапазоне –1 .. 1.

Параметр: rad — угол в радианах (тип float). Возвращаемое значение: косинус угла (тип double).

 

Функция tan(rad)

 

Возвращает тангенс угла, заданного в радианах в передаваемом параметре. Результат функции в диапазоне от минус бесконечности до плюс бесконечности.

Параметр: rad — угол в радианах (тип float). Возвращаемое значение: тангенс угла (тип double).

 

 

 

Генераторы случайных значений

 

Функции формирования случайных чисел:

 randomSeed();

 random().

 

Функция randomSeed(seed)

 

Функция randomSeed() инициализирует генератор псевдослучайных чисел. Генерируемая  последовательность случайных чисел очень длинная, и всегда одна и та же. Точка в этой последовательности, с которой начинается генерация чисел, зависит от параметра seed.

Параметр: seed — параметр, задающий начало выдачи псевдослучайных значений на последовательности (тип int, long).

 

Функция random()

 

Функция random() возвращает псевдослучайное число.

Синтаксис:

random(max); random(min, max);

Параметры:

 min — нижняя граница случайных значений, включительно (опционально);

 max — верхняя граница случайных значений, включительно. Возвращаемое значение: случайное число между min и max – 1 (тип long).

Если при каждом запуске программы необходимо получать разные последовательности значений, генерируемых функцией random(), то необходимо инициализировать генератор псевдослучайных чисел со случайным параметром. Например, можно использовать значение, отдаваемое функцией analogRead() c неподключенного порта входа/выхода. В некоторых случаях необходимо получать одинаковую последовательность при каждом запуске программы на Arduino. Тогда инициализировать генератор псевдослучайных чисел следует вызовом функции randomSeed() с фиксированным параметром.

Пример использования функции

long randNumber; void setup()

{

Serial.begin(9600);

}

void loop()

{

// выводим случайное число из диапазона 0..299 randNumber = random(300); Serial.println(randNumber);

// выводим случайное число из диапазона 0..19 randNumber = random(10, 20); Serial.println(randNumber);

delay(50);

}

 

 

 

Операции с битами и байтами

 

Функции — операции с битами и байтами:

 lowByte();

 highByte();

 bitRead();

 bitWrite();

 bitSet();

 bitClear();

 bit().

 

Функция lowByte()

 

Извлекает младший (самый правый) байт переменной (например, типа word).

Синтаксис:

lowByte(x);

Параметр:

x — величина любого типа. Возвращает байт.

 

Функция highByte()

 

Извлекает старший (крайний левый) байт слова (или второй младший байт большего типа данных).

Синтаксис:

highByte(x);

Параметр: x — величина любого типа. Возвращает байт.

 

Функция bitRead()

 

Читает определенный бит переменной.

Синтаксис:

bitRead(x, n);

Параметры:

 x — число, из которого необходимо прочитать;

 n — указывает бит, который необходимо прочитать, начиная с 0 для младшего (правого) бита.

Возвращает: значение бита (0 или 1).

 

Функция bitWrite()

 

Записывает бит числовой переменной.

Синтаксис:

bitWrite(x, n, b);

Параметры:

 x — числовая переменная, в которую необходимо записать;

 n — номер бита, который необходимо записать, начиная с 0 для младшего (левого) бита;

 b — значение, которое необходимо записать в бит (0 или 1).

 

Функция bitSet()

 

Устанавливает (записывает 1) бит числовой переменной.

Синтаксис:

bitSet(x, n)

Параметры:

 x — числовая переменная, которую необходимо записать;

 n — номер бита, который необходимо установить, начиная с 0 для младшего (левого) бита.

 

Функция bitClear()

 

Сбрасывает (записывает 0) бит числовой переменной.

Синтаксис:

bitClear(x, n);

Параметры:

 x — числовая переменная, которую необходимо записать;

 n — номер бита, который необходимо установить, начиная с 0 для младшего (левого) бита.

 

Функция bit()

 

Вычисляет значение указанного бита (бит 0 — это 1, бит 1 — это 2, бит 2 — это 4 и т. д.).

Синтаксис:

bit(n);

Параметр: n — номер бита, который необходимо вычислить. Возвращает: значение бита.

 

 

Внешние прерывания

 

Прерывание (англ. interrupt) — сигнал, сообщающий процессору о наступлении какого-либо события. При этом выполнение текущей последовательности команд приостанавливается, и управление передается обработчику прерывания, который выполняет работу по обработке события и возвращает управление в прерванный код. Arduino так же предоставляет свои функции для работы с прерываниями.

Их всего две:

 attachInterrupt();

 detachInterrupt().

 

Функция attachInterrupt

 

Задает функцию обработки внешнего прерывания, т. е. функцию, которая будет вызвана по внешнему прерыванию. Если до этого была задана другая функция, то назначается новая. Вычисляет значение указанного бита (бит 0 — это 1, бит 1 — это 2, бит 2 — это 4 и т. д.).

Синтаксис:

attachInterrupt(interrupt, function, mode);

Параметры:

 interrupt — номер прерывания:

• 0— на цифровом порту 2;

• 1— на цифровом порту 3;

• 2— на цифровом порту 21 (для Arduino Mega);

• 3— на цифровом порту 21 (для Arduino Mega);

• 4— на цифровом порту 21 (для Arduino Mega);

• 5— на цифровом порту 21 (для Arduino Mega);

 function — функция, вызываемая прерыванием (должна быть без параметров и не возвращать  значений);

 mode — задает режим обработки прерывания, допустимо использование следующих констанст:

LOW— вызывает прерывание, когда на порту LOW;

CHANGE— прерывание вызывается при смене значения на порту с LOW на HIGH и наоборот;

RISING— прерывание вызывается только при смене значения на порту с LOW на HIGH;

FALLING— прерывание вызывается только при смене значения на порту с HIGH на LOW.

Возвращаемого значения нет.

Внутри функции обработки прерывания не работает функция delay(), значения, возвращаемые функцией millis(), не изменяются. Возможна потеря данных, передаваемых по последовательному соединению (Serial data) в момент выполнения функции обработки прерывания. Переменные, изменяемые в функции, должны быть объявлены как volatile.

 

Функция detachInterrupt

 

Выключает обработку внешнего прерывания.

Синтаксис:

detachInterrupt(interrupt);

Параметр: interrupt — номер прерывания (0 или 1), для Arduino Mega еще 2, 3, 4

или 5.

Возвращаемого значения нет.

приведен пример использования прерывания 0 при наступлении события CHANGE на порту 2. При этом светодиод на выводе 13 Arduino при каждом прерывании меняет статус (горит либо гаснет).

int pin = 13;

volatile int state = LOW;

void setup()

{

pinMode(pin, OUTPUT); attachInterrupt(0, blink, CHANGE);

}

void loop()

{

digitalWrite(pin, state);

}

// функция обработки прерывания void blink()

{

state = !state;

}

 

 

 

Программирование, Типы данных int, Управляющие операторы, Унарные операторы, Логические операторы, Типы данных, Синтаксис, Операции с битами и байтами, Арифметические операторы, Внешние прерывания, Операторы сравнения, Унарные операторы, Унарные операторы, Дополнительные фунции ввода/вывода, Логические операторы, Типы данных, Функции transfer(), Массивы, Константы, Цифровой ввод/вывод, Переменные, Преобразование типов данных, Функции digitalRead(), Цифровой ввод/вывод, Аналоговый ввод/вывод, Функции setBitOrder(), Функции digitalWrite(), Функции digitalRead(), Дополнительные фунции ввода/вывода, Генераторы случайных значений, Операции с битами и байтами, Внешние прерывания, Работа со временем, Математические функции, Математические функции, Тригонометрические функции, Тригонометрические, функции, Типы данных, Генераторы случайных значений, Функции digitalRead(), Типы данных int, Операции с битами и байтами, Функции digitalWrite(), Функции digitalRead(), Внешние прерывания, Работа со временем, Функции pinMode(), Функции attachInterrupt(), Функции analogReference(type),Синтаксис, Арифметические операторы, Операторы сравнения, Функции setClockDivider(), Функции setDataMode(), Функции transfer(), Функции setBitOrder(), Функции digitalWrite(), Функции digitalRead(), Типы данных int, Программирование, Побитовый свдиг влево (<<), побитовый сдвиг вправо (>>), Управляющие операторы, Константы.

All Vintage Vinyl Records VinylSU.xyz

1.png2.png3.png4.png5.png

РУБИКОН Группа «Мозаика», ИЕРОГЛИФ ГРУППА «ПИКНИК», В ПОЛЁТ ГРУППА «ТЯЖЕЛЫЙ ДЕНЬ», Группа «Алиса», Бенни Гудмен, Равноденствие ГРУППА «АКВАРИУМ», Элтон Джон Твоя песня, Демон Группа «Август», Deep Purple – The House Of Blue Light, «Лед Зеппелин» Led Zeppelin, «Акцепт», Doors, «Металлика», АНСАМБЛЬ „UB 40", группа «Зоопарк», рок-группа «ЗОДИАК», «Браво», «Кино», Rolling Stones «Роллинг стоунз», РОК-ГРУППА «МАШИНА ВРЕМЕНИ»,«Кокто твинз», Группа «ДИАЛОГ», Bill Evans, Джимми Лансфорд, Флетчера Хендерсона, Дюк Эллингтон, Каунт Бейси, АНСАМБЛЬ "THE MOODY BLUES", Элвис Пресли, "Юнона" и "Авось" , Дж. Верди Реквием G.Verdi Requiem Mass, Элтон Джон, Реджинальд Кеннет Дуайт, АББА, ABBA, “Deep Purple”, «ЧЕЛОВЕК С БУЛЬВАРА КАПУЦИНОВ», “Rolling Stone”, Instrumrutal rock group Zodiac,‘‘Long Tall Ernie and The Shakers”, “The Beatles”, "Tom Fcgerty and The Blue Velvets", "Creedruce Clearwater Revival","Greru River" "Bayou Country", "Willy and The Poorboys", Varnishing Day Songs on Ilya Reznik's lirics , Leo Sayer ЛЕО СЕЙЕР, Boney M,"Waiting For The Sun", Doors «ДОРЗ», "Piper At The Gates Of Dawn", Led Zeppelin ? «ЛЕД ЗЕППЕЛИН», Rolling Stones , "Юнона" и "Авось" Опера Либретто, «РОЛЛИНГ СТОУНЗ», Modern talking,"Aftermath", «ДОМ ГОЛУБОГО СВЕТА», "Out Of Our Heads", Ricchi E Poveri, PINK FLOYD «Пинк Флойд», Vladimir Kuzmin, ПОЛ МАККАРТНИ Paul McCartney, «TWruTY FLIGHT ROCK», Creedruce Clearvater revival Traveling band,«LAWDY. MISS CLAWDY», «BRING IT ON HOME TO ME», Light My Fire,«DON'T GET AROUND MUCH ANY MORE», МУЗЫКАЛЬНЫЙ ТЕЛЕТАЙП-3,«I'М GONNA BE A WHEEL SOME DAY», МОДЕРН ТОКИНГ,«AINT THAT A SHAME», «THAT'S ALL RIGHT (МАМА)», АНСАМБЛЬ UB 40, «JUST BECAUSE», МИГЕЛЬ РАМОС, «SUMMERTIME», "АНСАМБЛЬ "THE MOODY BLUES", «CRACKIN UP», ТНЕ СОММОDORES, «MIDNIGHT SPECIAL», АННА ГEРМАН, Deep Purple «ДИП ПЁРПЛ», „Deep Purple in Rock", Андрей Миронов, Олег Табаков, Михаил Боярский, Николай Караченцов, Альберт Филозов, Олег Анофриев, Игорь Кваша, Леонид Ярмольник, ИЛЬЯ РЕЗНИК , Резанов Николай Петрович, ВЛАДИМИР ВЫСОЦКИЙ, Роджер Уотерс, АЛЕКСАНДР РОЗЕНБАУМ, Ричард Райт и Ник Мэйсон, ВЛАДИМИР КУЗЬМИН, Элвис Аарон Пресли, Leo Sayer, АДРИАНО ЧЕЛЕНТАНО, Билл Эванс, Клаудия Мори....

и это еще не конец.

С уваженим Dron!