Arduino - Краткое руководство

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

Ключевые особенности:

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

• Вы можете управлять функциями своей платы, отправляя набор инструкций микроконтроллеру на плате через Arduino IDE (называемый программным обеспечением для загрузки).

• В отличие от большинства предыдущих программируемых плат, Arduino не требует дополнительного оборудования (называемого программатором) для загрузки нового кода на плату. Вы можете просто использовать USB-кабель.

• Кроме того, IDE Arduino использует упрощенную версию C ++, что упрощает обучение программированию.

• Наконец, Arduino предоставляет стандартный форм-фактор, который разбивает функции микроконтроллера на более доступный пакет.

Типы досок

Доступны различные виды плат Arduino в зависимости от используемых микроконтроллеров. Однако все платы Arduino имеют одну общую черту: они программируются через Arduino IDE.

Различия основаны на количестве входов и выходов (количество датчиков, светодиодов и кнопок, которые вы можете использовать на одной плате), скорости, рабочем напряжении, форм-факторе и т. Д. Некоторые платы предназначены для встраивания и не требуют программирования. интерфейс (оборудование), который вам нужно будет покупать отдельно. Некоторые могут работать напрямую от батареи 3,7 В, другим требуется не менее 5 В.

Вот список различных доступных плат Arduino.

Arduino boards based on ATMEGA328 microcontroller

Название платы	Рабочее напряжение	Тактовая частота	Цифровой ввод / вывод	Аналоговые входы	ШИМ	UART	Интерфейс программирования
Arduino Uno R3	5В	16 МГц	14	6	6	1	USB через ATMega16U2
Arduino Uno R3 SMD	5В	16 МГц	14	6	6	1	USB через ATMega16U2
Красная доска	5В	16 МГц	14	6	6	1	USB через FTDI
Arduino Pro 3,3 В / 8 МГц	3,3 В	8 МГц	14	6	6	1	Заголовок, совместимый с FTDI
Arduino Pro 5 В / 16 МГц	5В	16 МГц	14	6	6	1	Заголовок, совместимый с FTDI
Ардуино мини 05	5В	16 МГц	14	8	6	1	Заголовок, совместимый с FTDI
Arduino Pro mini 3,3 В / 8 МГц	3,3 В	8 МГц	14	8	6	1	Заголовок, совместимый с FTDI
Arduino Pro mini 5 В / 16 МГц	5В	16 МГц	14	8	6	1	Заголовок, совместимый с FTDI
Arduino Ethernet	5В	16 МГц	14	6	6	1	Заголовок, совместимый с FTDI
Ардуино Фио	3,3 В	8 МГц	14	8	6	1	Заголовок, совместимый с FTDI
Основная плата LilyPad Arduino 328	3,3 В	8 МГц	14	6	6	1	Заголовок, совместимый с FTDI
Простая плата LilyPad Arduino	3,3 В	8 МГц	9	4	5	0	Заголовок, совместимый с FTDI

Arduino boards based on ATMEGA32u4 microcontroller

Название платы	Рабочее напряжение	Тактовая частота	Цифровой ввод / вывод	Аналоговые входы	ШИМ	UART	Интерфейс программирования
Ардуино Леонардо	5В	16 МГц	20	12	7	1	Родной USB
Pro micro 5 В / 16 МГц	5В	16 МГц	14	6	6	1	Родной USB
Pro micro 3,3 В / 8 МГц	5В	16 МГц	14	6	6	1	Родной USB
LilyPad Arduino USB	3,3 В	8 МГц	14	6	6	1	Родной USB

Arduino boards based on ATMEGA2560 microcontroller

Название платы	Рабочее напряжение	Тактовая частота	Цифровой ввод / вывод	Аналоговые входы	ШИМ	UART	Интерфейс программирования
Ардуино Мега 2560 R3	5В	16 МГц	54	16	14	4	USB через ATMega16U2B
Mega Pro 3,3 В	3,3 В	8 МГц	54	16	14	4	Заголовок, совместимый с FTDI
Mega Pro 5 В	5В	16 МГц	54	16	14	4	Заголовок, совместимый с FTDI
Mega Pro Mini 3,3 В	3,3 В	8 МГц	54	16	14	4	Заголовок, совместимый с FTDI

Arduino boards based on AT91SAM3X8E microcontroller

Название платы	Рабочее напряжение	Тактовая частота	Цифровой ввод / вывод	Аналоговые входы	ШИМ	UART	Интерфейс программирования
Ардуино Мега 2560 R3	3,3 В	84 МГц	54	12	12	4	USB родной

В этой главе мы узнаем о различных компонентах платы Arduino. Мы изучим плату Arduino UNO, потому что это самая популярная плата в семействе плат Arduino. Кроме того, это лучшая плата для начала работы с электроникой и программированием. Некоторые платы выглядят немного иначе, чем приведенная ниже, но большинство Arduinos имеют большинство этих общих компонентов.

	Power USB Плата Arduino может получать питание от компьютера через USB-кабель. Все, что вам нужно сделать, это подключить кабель USB к разъему USB (1).
	Power (Barrel Jack) Платы Arduino могут получать питание напрямую от сети переменного тока, подключив ее к разъему Barrel Jack (2).
	Voltage Regulator Функция регулятора напряжения - контролировать напряжение, подаваемое на плату Arduino, и стабилизировать напряжения постоянного тока, используемые процессором и другими элементами.
	Crystal Oscillator Кварцевый генератор помогает Arduino справляться с проблемами времени. Как Arduino рассчитывает время? Ответ заключается в использовании кварцевого генератора. Число, напечатанное на кристалле Arduino, - 16.000H9H. Это говорит нам, что частота составляет 16 000 000 Гц или 16 МГц.
	Arduino Reset Вы можете перезагрузить плату Arduino, то есть запустить программу с самого начала. Сбросить плату UNO можно двумя способами. Во-первых, с помощью кнопки сброса (17) на плате. Во-вторых, вы можете подключить внешнюю кнопку сброса к контакту Arduino с меткой RESET (5).
	Pins (3.3, 5, GND, Vin) 3,3 В (6) - Выходное напряжение 3,3 В 5V (7) - питание 5 выходных вольт Большинство компонентов, используемых с платой Arduino, нормально работают с напряжением 3,3 и 5 вольт. GND (8) (Земля) - на Arduino есть несколько контактов GND, любой из которых можно использовать для заземления вашей цепи. Vin (9) - этот вывод также может использоваться для питания платы Arduino от внешнего источника питания, например от сети переменного тока.
	Analog pins Плата Arduino UNO имеет шесть аналоговых входных контактов с A0 по A5. Эти контакты могут считывать сигнал от аналогового датчика, такого как датчик влажности или датчик температуры, и преобразовывать его в цифровое значение, которое может считывать микропроцессор.
	Main microcontroller Каждая плата Arduino имеет свой микроконтроллер (11). Вы можете считать это мозгом вашей доски. Основная ИС (интегральная схема) на Arduino немного отличается от платы к плате. Микроконтроллеры обычно от компании ATMEL. Вы должны знать, какая микросхема установлена ​​на вашей плате, прежде чем загружать новую программу из Arduino IDE. Эта информация доступна в верхней части ИС. Для получения более подробной информации о конструкции и функциях ИС вы можете обратиться к спецификации.
	ICSP pin В основном ICSP (12) - это AVR, крошечный программный заголовок для Arduino, состоящий из MOSI, MISO, SCK, RESET, VCC и GND. Его часто называют SPI (Serial Peripheral Interface), который можно рассматривать как «расширение» вывода. Фактически, вы подчиняете устройство вывода мастеру шины SPI.
	Power LED indicator Этот светодиод должен загореться, когда вы подключаете Arduino к источнику питания, чтобы указать, что ваша плата правильно включена. Если этот индикатор не загорается, значит, с подключением что-то не так.
	TX and RX LEDs На вашей плате вы найдете две метки: TX (передача) и RX (прием). Они появляются в двух местах на плате Arduino UNO. Во-первых, на цифровых выводах 0 и 1, чтобы указать выводы, отвечающие за последовательную связь. Во-вторых, светодиоды TX и RX (13). Светодиод TX мигает с разной скоростью при отправке последовательных данных. Скорость мигания зависит от скорости передачи данных, используемой платой. RX мигает во время приема.
	Digital I/O Плата Arduino UNO имеет 14 цифровых выводов ввода / вывода (15) (из которых 6 обеспечивают вывод ШИМ (широтно-импульсной модуляции). Эти выводы могут быть настроены для работы в качестве входных цифровых выводов для чтения логических значений (0 или 1) или как цифровых выходные контакты для управления различными модулями, такими как светодиоды, реле и т. д. Контакты, помеченные знаком «~», могут использоваться для генерации ШИМ.
	AREF AREF означает аналоговое задание. Иногда, используются для установки внешнего опорного напряжения (от 0 до 5 вольт) в качестве верхнего предела для аналоговых входных выводов.

Узнав об основных частях платы Arduino UNO, мы готовы узнать, как настроить Arduino IDE. Как только мы это узнаем, мы будем готовы загрузить нашу программу на плату Arduino.

В этом разделе мы с легкостью узнаем, как настроить Arduino IDE на нашем компьютере и подготовить плату для приема программы через USB-кабель.

Step 1- Сначала у вас должна быть плата Arduino (вы можете выбрать свою любимую плату) и USB-кабель. Если вы используете Arduino UNO, Arduino Duemilanove, Nano, Arduino Mega 2560 или Diecimila, вам понадобится стандартный USB-кабель (штекер от A к штекеру B), который вы подключаете к USB-принтеру, как показано на следующем рисунке.

Если вы используете Arduino Nano, вам понадобится кабель от A до Mini-B, как показано на следующем рисунке.

Step 2 − Download Arduino IDE Software.

Вы можете получить разные версии Arduino IDE на странице загрузки на официальном сайте Arduino. Вы должны выбрать свое программное обеспечение, совместимое с вашей операционной системой (Windows, IOS или Linux). После завершения загрузки файла разархивируйте его.

Step 3 − Power up your board.

Arduino Uno, Mega, Duemilanove и Arduino Nano автоматически потребляют питание либо от USB-подключения к компьютеру, либо от внешнего источника питания. Если вы используете Arduino Diecimila, вы должны убедиться, что плата настроена на получение питания от USB-соединения. Источник питания выбирается с помощью перемычки, небольшого кусочка пластика, который устанавливается на два из трех контактов между разъемом USB и разъемом питания. Убедитесь, что он находится на двух контактах, ближайших к USB-порту.

Подключите плату Arduino к компьютеру с помощью кабеля USB. Зеленый светодиодный индикатор питания (обозначен как PWR) должен гореть.

Step 4 − Launch Arduino IDE.

После загрузки программного обеспечения Arduino IDE вам необходимо распаковать папку. Внутри папки вы можете найти значок приложения с меткой бесконечности (application.exe). Дважды щелкните значок, чтобы запустить среду IDE.

Step 5 − Open your first project.

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

• Создайте новый проект.
• Откройте существующий пример проекта.

Чтобы создать новый проект, выберите Файл → New.

Чтобы открыть существующий пример проекта, выберите File → Example → Basics → Blink.

Здесь мы выбираем только один из примеров с названием Blink. Он включает и выключает светодиод с некоторой задержкой по времени. Вы можете выбрать любой другой пример из списка.

Step 6 − Select your Arduino board.

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

Перейдите в Инструменты → Доска и выберите свою доску.

Здесь мы выбрали плату Arduino Uno в соответствии с нашим руководством, но вы должны выбрать имя, соответствующее плате, которую вы используете.

Step 7 − Select your serial port.

Выберите последовательное устройство платы Arduino. Идти кTools → Serial Portменю. Вероятно, это будет COM3 или выше (COM1 и COM2 обычно зарезервированы для аппаратных последовательных портов). Чтобы узнать это, вы можете отключить плату Arduino и снова открыть меню, пропадающая запись должна относиться к плате Arduino. Снова подключите плату и выберите этот последовательный порт.

Step 8 − Upload the program to your board.

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

A - Используется для проверки наличия ошибок компиляции.

B - Используется для загрузки программы на плату Arduino.

C - Ярлык, используемый для создания нового эскиза.

D - Используется для прямого открытия одного из примеров эскиза.

E - Используется для сохранения вашего эскиза.

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

Теперь просто нажмите кнопку «Загрузить» в среде. Подождите несколько секунд; на плате будут мигать светодиоды RX и TX. Если загрузка прошла успешно, в строке состояния появится сообщение «Готово».

Note - Если у вас есть плата Arduino Mini, NG или другая, вам нужно физически нажать кнопку сброса на плате, непосредственно перед тем, как нажать кнопку загрузки в программном обеспечении Arduino.

В этой главе мы подробно изучим структуру программы Arduino и узнаем больше новых терминов, используемых в мире Arduino. Программное обеспечение Arduino имеет открытый исходный код. Исходный код среды Java выпускается под лицензией GPL, а библиотеки микроконтроллеров C / C ++ - под LGPL.

Sketch - Первая новая терминология - это программа Arduino под названием «sketch».

Структура

Программы Arduino можно разделить на три основные части: Structure, Values (переменные и константы) и Functions. В этом руководстве мы шаг за шагом узнаем о программе Arduino и о том, как написать программу без синтаксических ошибок или ошибок компиляции.

Начнем с Structure. Структура программного обеспечения состоит из двух основных функций -

• Функция Setup ()
• Функция Loop ()

Void setup ( ) {

}

• PURPOSE - The setup()функция вызывается при запуске скетча. Используйте его для инициализации переменных, режимов вывода, начала использования библиотек и т. Д. Функция настройки запускается только один раз, после каждого включения или сброса платы Arduino.

• INPUT - -

• OUTPUT - -

• RETURN - -

Void Loop ( ) {

}

• PURPOSE - После создания setup() функция, которая инициализирует и устанавливает начальные значения, loop()функция делает именно то, что предполагает ее название, и последовательно зацикливается, позволяя вашей программе изменяться и реагировать. Используйте его для активного управления платой Arduino.

• INPUT - -

• OUTPUT - -

• RETURN - -

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

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

пустота	Булево	char	Беззнаковый символ	байт	int	Беззнаковое целое	слово
долго	Беззнаковый длинный	короткая	плавать	двойной	массив	Строка-символьный массив	String-объект

пустота

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

пример

Void Loop ( ) {
   // rest of the code
}

Булево

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

пример

boolean val = false ; // declaration of variable with type boolean and initialize it with false
boolean state = true ; // declaration of variable with type boolean and initialize it with true

Char

Тип данных, занимающий один байт памяти, в котором хранится символьное значение. Символьные литералы записываются в одинарные кавычки, например: «A», а для нескольких символов в строках используются двойные кавычки: «ABC».

Однако символы хранятся в виде чисел. Вы можете увидеть конкретную кодировку в таблице ASCII . Это означает, что можно выполнять арифметические операции с символами, в которых используется значение ASCII символа. Например, «A» + 1 имеет значение 66, поскольку значение ASCII заглавной буквы A равно 65.

пример

Char chr_a = ‘a’ ;//declaration of variable with type char and initialize it with character a
Char chr_c = 97 ;//declaration of variable with type char and initialize it with character 97

беззнаковый символ

Unsigned charбеззнаковый тип данных, занимающий один байт памяти. Тип данных unsigned char кодирует числа от 0 до 255.

пример

Unsigned Char chr_y = 121 ; // declaration of variable with type Unsigned char and initialize it with character y

байт

Байт хранит 8-битное беззнаковое число от 0 до 255.

пример

byte m = 25 ;//declaration of variable with type byte and initialize it with 25

int

Целые числа являются основным типом данных для хранения чисел. int хранит 16-битное (2-байтовое) значение. Это дает диапазон от -32 768 до 32 767 (минимальное значение -2 ^ 15 и максимальное значение (2 ^ 15) - 1).

В intразмер варьируется от доски к доске. На Arduino Due, например,intхранит 32-битное (4-байтовое) значение. Это дает диапазон от -2 147 483 648 до 2 147 483 647 (минимальное значение -2 ^ 31 и максимальное значение (2 ^ 31) - 1).

пример

int counter = 32 ;// declaration of variable with type int and initialize it with 32

Беззнаковое целое

Беззнаковые целые числа (целые числа без знака) такие же, как int в том, как они хранят 2-байтовое значение. Однако вместо хранения отрицательных чисел они хранят только положительные значения, что дает полезный диапазон от 0 до 65 535 (2 ^ 16) - 1). Due хранит 4-байтовое (32-битное) значение в диапазоне от 0 до 4 294 967 295 (2 ^ 32 - 1).

пример

Unsigned int counter = 60 ; // declaration of variable with 
   type unsigned int and initialize it with 60

слово

На Uno и других платах на базе ATMEGA слово хранит 16-битное беззнаковое число. На Due и Zero хранится 32-битное число без знака.

пример

word w = 1000 ;//declaration of variable with type word and initialize it with 1000

Долго

Длинные переменные представляют собой переменные расширенного размера для хранения чисел и хранят 32 бита (4 байта), от -2 147 483 648 до 2 147 483 647.

пример

Long velocity = 102346 ;//declaration of variable with type Long and initialize it with 102346

беззнаковый длинный

Беззнаковые длинные переменные представляют собой переменные расширенного размера для хранения чисел и хранят 32 бита (4 байта). В отличие от стандартных long, беззнаковые long не хранят отрицательные числа, делая их диапазон от 0 до 4 294 967 295 (2 ^ 32 - 1).

пример

Unsigned Long velocity = 101006 ;// declaration of variable with 
   type Unsigned Long and initialize it with 101006

короткая

Short - это 16-битный тип данных. На всех Arduinos (на базе ATMega и ARM) короткий сохраняет 16-битное (2-байтовое) значение. Это дает диапазон от -32 768 до 32 767 (минимальное значение -2 ^ 15 и максимальное значение (2 ^ 15) - 1).

пример

short val = 13 ;//declaration of variable with type short and initialize it with 13

плавать

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

Числа с плавающей запятой могут быть от 3,4028235E + 38 до -3,4028235E + 38. Они хранятся как 32 бита (4 байта) информации.

пример

float num = 1.352;//declaration of variable with type float and initialize it with 1.352

двойной

На Uno и других платах на базе ATMEGA число с плавающей запятой двойной точности занимает четыре байта. То есть реализация double точно такая же, как и float, без увеличения точности. В Arduino Due двойники имеют 8-байтовую (64-битную) точность.

пример

double num = 45.352 ;// declaration of variable with type double and initialize it with 45.352

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

Что такое переменная область?

Переменные в языке программирования C, который использует Arduino, имеют свойство, называемое областью действия. Область видимости - это область программы, и есть три места, где могут быть объявлены переменные. Они -

• Внутри функции или блока, который вызывается local variables.
• В определении параметров функции, которая называется formal parameters.
• Вне всех функций, которые вызываются global variables.

Локальные переменные

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

Void setup () {

}

Void loop () {
   int x , y ;
   int z ; Local variable declaration
   x = 0;
   y = 0; actual initialization
   z = 10;
}

Глобальные переменные

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

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

В следующем примере используются глобальные и локальные переменные -

Int T , S ;
float c = 0 ; Global variable declaration

Void setup () {

}

Void loop () {
   int x , y ;
   int z ; Local variable declaration
   x = 0;
   y = 0; actual initialization
   z = 10;
}

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

• Арифметические операторы
• Операторы сравнения
• Булевы операторы
• Побитовые операторы
• Составные операторы

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

Предположим, что переменная A содержит 10, а переменная B содержит 20, тогда -

Показать пример

Имя оператора	Оператор простой	Описание	пример
оператор присваивания	знак равно	Сохраняет значение справа от знака равенства в переменной слева от знака равенства.	А = В
дополнение	+	Добавляет два операнда	A + B даст 30
вычитание	-	Вычитает второй операнд из первого	A - B даст -10
умножение	*	Умножьте оба операнда	A * B даст 200
деление	/	Разделите числитель на знаменатель	Б / А даст 2
по модулю	%	Оператор модуля и остаток после целочисленного деления	B% A даст 0

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

Предположим, что переменная A содержит 10, а переменная B содержит 20, тогда -

Показать пример

Имя оператора	Оператор простой	Описание	пример
равно	==	Проверяет, равны ли значения двух операндов или нет, если да, то условие становится истинным.	(A == B) неверно
не равно	знак равно	Проверяет, равны ли значения двух операндов или нет, если значения не равны, условие становится истинным.	(A! = B) верно
меньше, чем	<	Проверяет, меньше ли значение левого операнда, чем значение правого операнда, если да, то условие становится истинным.	(A <B) верно
лучше чем	>	Проверяет, больше ли значение левого операнда, чем значение правого операнда, если да, то условие становится истинным.	(A> B) неверно
меньше или равно	<=	Проверяет, меньше ли значение левого операнда или равно значению правого операнда, если да, то условие становится истинным.	(A <= B) верно
больше или равно	> =	Проверяет, больше ли значение левого операнда или равно значению правого операнда, если да, то условие становится истинным.	(A> = B) неверно

Булевы операторы

Предположим, что переменная A содержит 10, а переменная B содержит 20, тогда -

Показать пример

Имя оператора	Оператор простой	Описание	пример
и	&&	Вызывается логическим оператором И. Если оба операнда не равны нулю, тогда условие становится истинным.	(A && B) верно
или же	||	Вызывается логическим оператором ИЛИ. Если какой-либо из двух операндов не равен нулю, тогда условие становится истинным.	(A || B) верно
не	!	Вызывается оператором логического НЕ. Используется для изменения логического состояния операнда на обратное. Если условие истинно, то оператор логического НЕ сделает ложным.	! (A && B) ложно

Побитовые операторы

Предположим, что переменная A содержит 60, а переменная B содержит 13, тогда -

Показать пример

Имя оператора	Оператор простой	Описание	пример
и	&	Двоичный оператор И копирует бит в результат, если он существует в обоих операндах.	(A и B) даст 12, что составляет 0000 1100
или же	|	Оператор двоичного ИЛИ копирует бит, если он существует в любом из операндов	(A | B) даст 61, что составляет 0011 1101
xor	^	Двоичный оператор XOR копирует бит, если он установлен в одном операнде, но не в обоих.	(A ^ B) даст 49, что составляет 0011 0001
не	~	Оператор дополнения двоичных единиц является унарным и имеет эффект «переворачивания» битов.	(~ A) даст -60, что составляет 1100 0011
сдвиг влево	<<	Оператор двоичного сдвига влево. Значение левого операнда сдвигается влево на количество битов, указанное правым операндом.	<< 2 даст 240, что составляет 1111 0000
сдвиг вправо	>>	Оператор двоичного сдвига вправо. Значение левого операнда перемещается вправо на количество битов, указанное правым операндом.	A >> 2 даст 15, что равно 0000 1111

Составные операторы

Предположим, что переменная A содержит 10, а переменная B содержит 20, тогда -

Показать пример

Имя оператора	Оператор простой	Описание	пример
приращение	++	Оператор увеличения, увеличивает целочисленное значение на единицу	A ++ даст 11
декремент	-	Оператор декремента, уменьшает целое значение на единицу	A - даст 9
сложное добавление	+ =	Добавить оператор присваивания И. Он добавляет правый операнд к левому операнду и присваивает результат левому операнду	B + = A эквивалентно B = B + A
сложное вычитание	знак равно	Оператор вычитания И присваивания. Он вычитает правый операнд из левого операнда и присваивает результат левому операнду	B - = A эквивалентно B = B - A
сложное умножение	знак равно	Оператор умножения И присваивания. Он умножает правый операнд на левый операнд и присваивает результат левому операнду	B * = A эквивалентно B = B * A
сложное деление	знак равно	Оператор деления И присваивания. Он делит левый операнд на правый и присваивает результат левому операнду	B / = A эквивалентно B = B / A
составной модуль	знак равно	Оператор модуля И присваивания. Он принимает модуль с использованием двух операндов и присваивает результат левому операнду	B% = A эквивалентно B = B% A
составное побитовое или	| =	побитовое включающее ИЛИ и оператор присваивания	A | = 2 совпадает с A = A | 2
составное побитовое и	знак равно	Побитовый оператор присваивания И	A & = 2 совпадает с A = A & 2

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

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

Управляющие операторы - это элементы исходного кода, которые контролируют ход выполнения программы. Они -

С.НО.	Положение и описание управления
1	Если заявление Он принимает выражение в скобках и инструкцию или блок инструкций. Если выражение истинно, то выполняется оператор или блок операторов, в противном случае эти операторы пропускаются.
2	Если… else заявление An if За оператором может следовать необязательный оператор else, который выполняется, когда выражение ложно.
3	If… else if… else заявление В if за заявлением может следовать необязательный else if...else оператор, который очень полезен для проверки различных условий с помощью одного оператора if ... else if.
4	оператор переключения регистра Подобно операторам if, switch...case управляет потоком программ, позволяя программистам указывать различные коды, которые должны выполняться в различных условиях.
5	Условный оператор? : Условный оператор? : - единственный тернарный оператор в C.

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

Оператор цикла позволяет нам выполнять оператор или группу операторов несколько раз, и ниже приводится общая форма оператора цикла на большинстве языков программирования:

Язык программирования C предоставляет следующие типы циклов для обработки требований цикла.

С.НО.	Цикл и описание
1	пока цикл Циклы while будут повторяться непрерывно и бесконечно, пока выражение внутри скобок () не станет ложным. Что-то должно изменить проверяемую переменную, иначе цикл while никогда не завершится.
2	делать… пока цикл В do…whileцикл похож на цикл while. В цикле while условие продолжения цикла проверяется в начале цикла перед выполнением тела цикла.
3	для цикла А for loopвыполняет операторы заданное количество раз. Выражение управления для цикла инициализируется, тестируется и обрабатывается полностью в круглых скобках цикла for.
4	Вложенный цикл Язык C позволяет использовать один цикл внутри другого цикла. Следующий пример иллюстрирует эту концепцию.
5	Бесконечная петля Это цикл, не имеющий условия завершения, поэтому цикл становится бесконечным.

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

Стандартизация фрагментов кода в функции имеет несколько преимуществ:

• Функции помогают программисту оставаться организованным. Часто это помогает концептуализировать программу.

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

• Это также снижает вероятность ошибок при модификации, если код необходимо изменить.

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

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

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

Наиболее распространенный синтаксис для определения функции -

Объявление функции

Функция объявляется вне любых других функций, выше или ниже функции цикла.

Мы можем объявить функцию двумя разными способами:

Первый способ - просто написать часть функции с именем a function prototype над функцией цикла, которая состоит из -

• Тип возврата функции
• Название функции
• Тип аргумента функции, нет необходимости писать имя аргумента

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

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

пример

int sum_func (int x, int y) // function declaration {
   int z = 0;
   z = x+y ;
   return z; // return the value
}

void setup () {
   Statements // group of statements
}

Void loop () {
   int result = 0 ;
   result = Sum_func (5,6) ; // function call
}

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

• Тип возврата функции
• Название функции
• Тип аргумента функции, здесь необходимо добавить имя аргумента
• Тело функции (операторы внутри функции, выполняемые при вызове функции)

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

пример

int sum_func (int , int ) ; // function prototype

void setup () {
   Statements // group of statements
}

Void loop () {
   int result = 0 ;
   result = Sum_func (5,6) ; // function call
}

int sum_func (int x, int y) // function declaration {
   int z = 0;
   z = x+y ;
   return z; // return the value
}

Второй метод просто объявляет функцию над функцией цикла.

Строки используются для хранения текста. Их можно использовать для отображения текста на ЖК-дисплее или в окне последовательного монитора Arduino IDE. Строки также полезны для хранения пользовательского ввода. Например, символы, которые пользователь вводит на клавиатуре, подключенной к Arduino.

В программировании Arduino есть два типа строк:

• Массивы символов, которые такие же, как строки, используемые в программировании на C.
• Строка Arduino, которая позволяет нам использовать строковый объект в эскизе.

В этой главе мы изучим строки, объекты и использование строк в эскизах Arduino. К концу главы вы узнаете, какой тип струны использовать в эскизе.

Строковые массивы символов

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

Строка - это специальный массив, который имеет один дополнительный элемент в конце строки, который всегда имеет значение 0 (ноль). Это известно как «строка с завершающим нулем».

Пример массива строковых символов

В этом примере показано, как создать строку и распечатать ее в окне последовательного монитора.

Example

void setup() {
   char my_str[6]; // an array big enough for a 5 character string
   Serial.begin(9600);
   my_str[0] = 'H'; // the string consists of 5 characters
   my_str[1] = 'e';
   my_str[2] = 'l';
   my_str[3] = 'l';
   my_str[4] = 'o';
   my_str[5] = 0; // 6th array element is a null terminator
   Serial.println(my_str);
}

void loop() { 

}

В следующем примере показано, из чего состоит строка; массив символов с печатаемыми символами и 0 в качестве последнего элемента массива, чтобы показать, что здесь заканчивается строка. Строку можно распечатать в окне Serial Monitor Arduino IDE, используяSerial.println() и передача имени строки.

Этот же пример можно записать более удобным способом, как показано ниже -

Example

void setup() {
   char my_str[] = "Hello";
   Serial.begin(9600);
   Serial.println(my_str);
}

void loop() {

}

В этом эскизе компилятор вычисляет размер массива строк, а также автоматически завершает строку нулем нулем. Массив из шести элементов, состоящий из пяти символов, за которыми следует ноль, создается точно так же, как и в предыдущем эскизе.

Управление строковыми массивами

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

пример

void setup() {
   char like[] = "I like coffee and cake"; // create a string
   Serial.begin(9600);
   // (1) print the string
   Serial.println(like);
   // (2) delete part of the string
   like[13] = 0;
   Serial.println(like);
   // (3) substitute a word into the string
   like[13] = ' '; // replace the null terminator with a space
   like[18] = 't'; // insert the new word
   like[19] = 'e';
   like[20] = 'a';
   like[21] = 0; // terminate the string
   Serial.println(like);
}

void loop() {

}

Результат

I like coffee and cake
I like coffee
I like coffee and tea

Скетч работает следующим образом.

Создание и печать строки

В приведенном выше эскизе создается новая строка, которая затем печатается для отображения в окне Serial Monitor.

Укорочение струны

Строка укорачивается, заменяя 14-й символ в строке нулевым завершающим нулем (2). Это элемент номер 13 в массиве строк, отсчитываемый от 0.

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

Изменение слова в строке

Наконец, в скетче слово «торт» заменяется словом «чай» (3). Сначала необходимо заменить нулевой ограничитель в подобной [13] пробелом, чтобы строка была восстановлена ​​в первоначально созданном формате.

Новые символы заменяют "cak" слова "cake" словом "tea". Это делается путем перезаписи отдельных символов. Буква "e" слова "cake" заменяется новым завершающим символом null. В результате строка фактически заканчивается двумя нулевыми символами: исходным в конце строки и новым, заменяющим букву «e» в «cake». Это не имеет значения, когда печатается новая строка, потому что функция, которая печатает строку, прекращает печать символов строки, когда встречает первый нулевой терминатор.

Функции для управления массивами строк

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

Ниже приведен список функций для управления массивами строк.

S.No.	Функции и описание
1	String() Класс String, являющийся частью ядра начиная с версии 0019, позволяет вам использовать и управлять строками текста более сложными способами, чем это делают массивы символов. Вы можете объединять строки, добавлять к ним, искать и заменять подстроки и многое другое. Он требует больше памяти, чем простой массив символов, но он также более полезен. Для справки, символьные массивы называются строками с маленькой буквой 's', а экземпляры класса String называются строками с заглавной S. Обратите внимание, что постоянные строки, указанные в «двойных кавычках», обрабатываются как символьные массивы, не экземпляры класса String
2	charAt() Доступ к определенному символу строки.
3	compareTo() Сравнивает две строки, проверяя, идет ли одна до или после другой и равны ли они. Строки сравниваются посимвольно с использованием значений символов ASCII. Это означает, например, что «a» стоит перед «b», но после «A». Цифры идут перед буквами.
4	concat() Добавляет параметр в строку.
5	c_str() Преобразует содержимое строки в строку в стиле C с завершающим нулем. Обратите внимание, что это дает прямой доступ к внутреннему буферу String, и его следует использовать с осторожностью. В частности, вы никогда не должны изменять строку с помощью возвращаемого указателя. Когда вы изменяете объект String или когда он уничтожается, любой указатель, ранее возвращенный c_str (), становится недействительным и больше не должен использоваться.
6	endsWith() Проверяет, заканчивается ли строка символами другой строки.
7	equals() Сравнивает две строки на равенство. При сравнении учитывается регистр, то есть строка «hello» не равна строке «HELLO».
8	equalsIgnoreCase() Сравнивает две строки на равенство. При сравнении регистр не учитывается, что означает, что строка («привет») равна строке («ПРИВЕТ»).
9	getBytes() Копирует символы строки в предоставленный буфер.
10	indexOf() Находит символ или строку в другой строке. По умолчанию поиск выполняется с начала строки, но может также начинаться с заданного индекса, что позволяет найти все экземпляры символа или строки.
11	lastIndexOf() Находит символ или строку в другой строке. По умолчанию поиск ведется с конца строки, но также может работать и назад от заданного индекса, что позволяет найти все экземпляры символа или строки.
12	length() Возвращает длину строки в символах. (Обратите внимание, что это не включает завершающий нулевой символ.)
13	remove() Измените на месте строку, удалив символы из предоставленного индекса до конца строки или из предоставленного индекса на индекс плюс счетчик.
14	replace() Функция String replace () позволяет заменить все экземпляры данного символа другим символом. Вы также можете использовать replace для замены подстрок строки другой подстрокой.
15	reserve() Функция String Reserve () позволяет вам выделить буфер в памяти для управления строками.
16	setCharAt() Устанавливает символ строки. Не влияет на индексы за пределами существующей длины String.
17	startsWith() Проверяет, начинается ли строка с символов другой строки.
18	toCharArray() Копирует символы строки в предоставленный буфер.
19	substring() Получить подстроку строки. Начальный индекс является включающим (соответствующий символ включается в подстроку), но необязательный конечный индекс является исключающим (соответствующий символ не включается в подстроку). Если конечный индекс не указан, подстрока продолжается до конца строки.
20	toInt() Преобразует действительную строку в целое число. Строка ввода должна начинаться с целого числа. Если строка содержит нецелые числа, функция прекратит преобразование.
21 год	toFloat() Преобразует действительную строку в число с плавающей запятой. Строка ввода должна начинаться с цифры. Если строка содержит нецифровые символы, функция прекратит преобразование. Например, строки «123.45», «123» и «123fish» преобразуются в 123,45, 123,00 и 123,00 соответственно. Обратите внимание, что «123,456» приблизительно равно 123,46. Также обратите внимание, что числа с плавающей запятой имеют только 6-7 десятичных цифр точности и что более длинные строки могут быть усечены.
22	toLowerCase() Получите строчную версию String. Начиная с 1.0, toLowerCase () изменяет строку на месте, а не возвращает новую.
23	toUpperCase() Получите версию String в верхнем регистре. Начиная с 1.0, toUpperCase () изменяет строку на месте, а не возвращает новую.
24	trim() Получите версию String с удаленными начальными и конечными пробелами. Начиная с версии 1.0, trim () изменяет строку на месте, а не возвращает новую.

В следующем скетче используются некоторые строковые функции C.

пример

void setup() {
   char str[] = "This is my string"; // create a string
   char out_str[40]; // output from string functions placed here
   int num; // general purpose integer
   Serial.begin(9600);

   // (1) print the string
   Serial.println(str);

   // (2) get the length of the string (excludes null terminator)
   num = strlen(str);
   Serial.print("String length is: ");
   Serial.println(num);

   // (3) get the length of the array (includes null terminator)
   num = sizeof(str); // sizeof() is not a C string function
   Serial.print("Size of the array: ");
   Serial.println(num);

   // (4) copy a string
   strcpy(out_str, str);
   Serial.println(out_str);

   // (5) add a string to the end of a string (append)
   strcat(out_str, " sketch.");
   Serial.println(out_str);
   num = strlen(out_str);
   Serial.print("String length is: ");
   Serial.println(num);
   num = sizeof(out_str);
   Serial.print("Size of the array out_str[]: ");
   Serial.println(num);
}

void loop() {

}

Результат

This is my string
String length is: 17
Size of the array: 18
This is my string
This is my string sketch.
String length is: 25
Size of the array out_str[]: 40

Скетч работает следующим образом.

Распечатать строку

Вновь созданная строка печатается в окне Serial Monitor, как это было сделано на предыдущих рисунках.

Получить длину строки

Функция strlen () используется для получения длины строки. Длина строки предназначена только для печатаемых символов и не включает нулевой терминатор.

Строка содержит 17 символов, поэтому в окне Serial Monitor мы видим 17 символов.

Получить длину массива

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

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

Скопируйте строку

Функция strcpy () используется для копирования строки str [] в массив out_num []. Функция strcpy () копирует вторую переданную ей строку в первую строку. Копия строки теперь существует в массиве out_num [], но занимает только 18 элементов массива, так что у нас все еще есть 22 свободных элемента char в массиве. Эти свободные элементы находятся в памяти после строки.

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

Добавить строку в строку (объединить)

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

После конкатенации длина строки печатается, чтобы показать новую длину строки. Затем печатается длина массива, чтобы показать, что у нас есть строка длиной 25 символов в массиве длиной 40 элементов.

Помните, что длинная 25-символьная строка фактически занимает 26 символов массива из-за нулевого завершающего нуля.

Границы массива

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

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

Второй тип строки, используемый в программировании Arduino, - это объект String.

Что такое объект?

Объект - это конструкция, которая содержит как данные, так и функции. Объект String можно создать так же, как переменную, и присвоить ему значение или строку. Объект String содержит функции (которые в объектно-ориентированном программировании (ООП) называются «методами»), которые работают со строковыми данными, содержащимися в объекте String.

Следующий набросок и пояснение прояснят, что такое объект и как используется объект String.

пример

void setup() { 
   String my_str = "This is my string.";
   Serial.begin(9600);

   // (1) print the string
   Serial.println(my_str);

   // (2) change the string to upper-case
   my_str.toUpperCase();
   Serial.println(my_str);

   // (3) overwrite the string
   my_str = "My new string.";
   Serial.println(my_str);

   // (4) replace a word in the string
   my_str.replace("string", "Arduino sketch");
   Serial.println(my_str);

   // (5) get the length of the string
   Serial.print("String length is: ");
   Serial.println(my_str.length());
}

void loop() { 

}

Результат

This is my string.
THIS IS MY STRING.
My new string.
My new Arduino sketch.
String length is: 22

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

String my_str = "This is my string." ;

Это создает объект String с именем my_str и присваивает ему значение «Это моя строка.».

Это можно сравнить с созданием переменной и присвоением ей значения, такого как целое число -

int my_var = 102;

Скетч работает следующим образом.

Печать строки

Строку можно напечатать в окне Serial Monitor так же, как строку массива символов.

Преобразование строки в верхний регистр

Созданный строковый объект my_str имеет ряд функций или методов, с которыми можно работать. Эти методы вызываются с использованием имени объекта, за которым следует оператор точка (.), А затем имя используемой функции.

my_str.toUpperCase();

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

Перезаписать строку

Оператор присваивания используется для присвоения новой строки объекту my_str объект, заменяющий старую строку

my_str = "My new string." ;

Оператор присваивания не может использоваться для строк символьного массива, но работает только с объектами String.

Замена слова в строке

Функция replace () используется для замены первой переданной ей строки второй переданной ей строкой. replace () - еще одна функция, которая встроена в класс String и поэтому доступна для использования в объекте String my_str.

Получение длины строки

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

Когда использовать строковый объект

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

Основным недостатком использования объекта String является то, что он использует много памяти и может быстро использовать оперативную память Arduinos, что может привести к зависанию, сбою или неожиданному поведению Arduino. Если скетч на Arduino небольшой и ограничивает использование объектов, то проблем возникнуть не должно.

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

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

Где используются струны

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

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

Arduino предоставляет четыре различных функции манипулирования временем. Они -

S.No.	Описание функции
1	функция delay () Путь delay()Функция работает довольно просто. Он принимает один целочисленный (или числовой) аргумент. Это число представляет время (измеряется в миллисекундах).
2	Функция delayMicroseconds () В delayMicroseconds()функция принимает единственный целочисленный (или числовой) аргумент. В миллисекунде тысяча микросекунд, а в секунде - миллион микросекунд.
3	функция millis () Эта функция используется для возврата количества миллисекунд в момент, когда плата Arduino запускает текущую программу.
4	функция micros () Функция Micros () возвращает количество микросекунд с момента, когда плата Arduino начала запускать текущую программу. Это число переполняется, т.е. возвращается к нулю примерно через 70 минут.

Массив - это последовательная группа ячеек памяти одного типа. Чтобы сослаться на определенное место или элемент в массиве, мы указываем имя массива и номер позиции конкретного элемента в массиве.

На приведенной ниже иллюстрации показан целочисленный массив C, содержащий 11 элементов. Для ссылки на любой из этих элементов указывается имя массива, за которым следует номер позиции конкретного элемента в квадратных скобках ([]). Номер позиции более формально называется индексом или индексом (это число указывает количество элементов от начала массива). Первый элемент имеет индекс 0 (ноль) и иногда называется нулевым элементом.

Таким образом, элементами массива C являются C [0] (произносится «C sub zero»), C [1], C [2] и так далее. Наивысший индекс в массиве C равен 10, что на 1 меньше количества элементов в массиве (11). Имена массивов соответствуют тем же соглашениям, что и имена других переменных.

Нижний индекс должен быть целым или целочисленным выражением (с использованием любого целочисленного типа). Если программа использует выражение как нижний индекс, то программа оценивает выражение, чтобы определить нижний индекс. Например, если мы предположим, что переменная a равна 5, а переменная b равна 6, тогда оператор добавляет 2 к элементу массива C [11].

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

Рассмотрим подробнее массив C на данном рисунке. Имя всего массива - C. Его 11 элементов обозначаются от C [0] до C [10]. Значение C [0] равно -45, значение C [1] равно 6, значение C [2] равно 0, значение C [7] равно 62, а значение C [10] равно 78.

Чтобы напечатать сумму значений, содержащихся в первых трех элементах массива C, мы должны написать:

Serial.print (C[ 0 ] + C[ 1 ] + C[ 2 ] );

Чтобы разделить значение C [6] на 2 и присвоить результат переменной x, мы должны написать:

x = C[ 6 ] / 2;

Объявление массивов

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

type arrayName [ arraySize ] ;

Компилятор резервирует соответствующий объем памяти. (Напомним, что объявление, которое резервирует память, более правильно известно как определение). ArraySize должен быть целочисленной константой больше нуля. Например, чтобы указать компилятору зарезервировать 11 элементов для целочисленного массива C, используйте объявление -

int C[ 12 ]; // C is an array of 12 integers

Можно объявить массивы как содержащие значения любого не ссылочного типа данных. Например, для хранения символьных строк можно использовать массив типа string.

Примеры использования массивов

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

Пример 1: Объявление массива и использование цикла для инициализации элементов массива

Программа объявляет целочисленный массив из 10 элементов n. Строки a – b используют aForоператор для инициализации элементов массива нулями. Как и другие автоматические переменные, автоматические массивы не инициализируются неявно нулем. Первый оператор вывода (строка c) отображает заголовки столбцов, напечатанных в последующем операторе for (строки d – e), который печатает массив в табличном формате.

Example

int n[ 10 ] ; // n is an array of 10 integers

void setup () {

}

void loop () {
   for ( int i = 0; i < 10; ++i ) // initialize elements of array n to 0 {
      n[ i ] = 0; // set element at location i to 0
      Serial.print (i) ;
      Serial.print (‘\r’) ;
   }
   for ( int j = 0; j < 10; ++j ) // output each array element's value {
      Serial.print (n[j]) ;
      Serial.print (‘\r’) ;
   } 
}

Result - Это даст следующий результат -

 
       

        
 
         
Element
 
         
Value
 
        
 
        
 
         
 
0
 
1
 
2
 
3
 
4
 
5
 
6
 
7
 
8
 
9
 
 
         
 
0
 
0
 
0
 
0
 
0
 
0
 
0
 
0
 
0
 
0
 
 
        
 
       
      

Пример 2: Инициализация массива в объявлении со списком инициализаторов

Элементы массива также можно инициализировать в объявлении массива, поставив после имени массива знак равенства и список инициализаторов, разделенных запятыми, разделенных фигурными скобками. Программа использует список инициализаторов для инициализации целочисленного массива с 10 значениями (строка a) и печатает массив в табличном формате (строки b – c).

Example

// n is an array of 10 integers
int n[ 10 ] = { 32, 27, 64, 18, 95, 14, 90, 70, 60, 37 } ;

void setup () {

}

void loop () {
   for ( int i = 0; i < 10; ++i ) {
      Serial.print (i) ;
      Serial.print (‘\r’) ;
   }
   for ( int j = 0; j < 10; ++j ) // output each array element's value {
      Serial.print (n[j]) ;
      Serial.print (‘\r’) ;
   } 
}

Result - Это даст следующий результат -

 
       

        
 
         
Element
 
         
Value
 
        
 
        
 
         
 
0
 
1
 
2
 
3
 
4
 
5
 
6
 
7
 
8
 
9
 
 
         
 
32
 
27
 
64
 
18
 
95
 
14
 
90
 
70
 
60
 
37
 
 
        
 
       
      

Пример 3: Суммирование элементов массива

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

Example

const int arraySize = 10; // constant variable indicating size of array
int a[ arraySize ] = { 87, 68, 94, 100, 83, 78, 85, 91, 76, 87 };
int total = 0;

void setup () {

}
void loop () {
   // sum contents of array a
   for ( int i = 0; i < arraySize; ++i )
      total += a[ i ];
   Serial.print (“Total of array elements : ”) ;
   Serial.print(total) ;
}

Result - Это даст следующий результат -

Total of array elements: 849

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

С.НО.	Концепция и описание
1	Передача массивов функциям Чтобы передать аргумент массива функции, укажите имя массива без скобок.
2	Многомерные массивы Массивы с двумя измерениями (т.е. индексы) часто представляют собой таблицы значений, состоящие из информации, упорядоченной по строкам и столбцам.

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

Контакты настроены как ВХОД

Контакты Arduino по умолчанию настроены как входы, поэтому их не нужно явно объявлять как входы с pinMode()когда вы используете их в качестве входных данных. Выводы, настроенные таким образом, считаются находящимися в состоянии высокого импеданса. Входные контакты предъявляют чрезвычайно низкие требования к цепи, в которой они осуществляют выборку, что эквивалентно последовательному резистору 100 МОм перед контактом.

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

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

Подтягивающие резисторы

Подтягивающие резисторы часто используются для перевода входного контакта в известное состояние, если вход отсутствует. Это можно сделать, добавив на вход подтягивающий резистор (до +5 В) или подтягивающий резистор (резистор к земле). Резистор 10 кОм - хорошее значение для повышающего или понижающего резистора.

Использование встроенного подтягивающего резистора с выводами, настроенными как вход

В микросхему Atmega встроено 20 000 подтягивающих резисторов, доступ к которым можно получить из программного обеспечения. Доступ к этим встроенным подтягивающим резисторам можно получить, установивpinMode()как INPUT_PULLUP. Это эффективно меняет поведение режима INPUT, где HIGH означает, что датчик выключен, а LOW означает, что датчик включен. Значение этого подтягивания зависит от используемого микроконтроллера. На большинстве плат на основе AVR гарантированное значение составляет от 20 кОм до 50 кОм. На Arduino Due оно составляет от 50 кОм до 150 кОм. Чтобы узнать точное значение, обратитесь к таблице данных микроконтроллера на вашей плате.

При подключении датчика к контакту, сконфигурированному с INPUT_PULLUP, другой конец должен быть подключен к земле. В случае простого переключателя это приводит к тому, что вывод показывает ВЫСОКИЙ, когда переключатель разомкнут, и НИЗКИЙ, когда переключатель нажат. Подтягивающие резисторы обеспечивают ток, достаточный для освещения светодиода, тускло подключенного к выводу, настроенному как вход. Если светодиоды в проекте кажутся работающими, но очень тускло, скорее всего, это и происходит.

Те же регистры (ячейки внутренней памяти микросхемы), которые контролируют, является ли вывод ВЫСОКИМ или НИЗКИМ, управляют подтягивающими резисторами. Следовательно, вывод, который настроен на включение подтягивающих резисторов, когда вывод находится в режиме INPUT, будет иметь вывод, сконфигурированный как HIGH, если вывод затем переключится в режим OUTPUT с помощью pinMode (). Это работает и в другом направлении, и на выходном контакте, который остается в ВЫСОКОМ состоянии, будет установлен подтягивающий резистор, если он переключен на вход с помощью pinMode ().

Example

pinMode(3,INPUT) ; // set pin to input without using built in pull up resistor
pinMode(5,INPUT_PULLUP) ; // set pin to input using built in pull up resistor

Контакты настроены как ВЫХОД

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

Попытка подключить сильноточные устройства к выходным контактам может повредить или разрушить выходные транзисторы на контакте или повредить весь чип Atmega. Часто это приводит к «мертвому» выводу микроконтроллера, но оставшиеся микросхемы по-прежнему работают нормально. По этой причине рекомендуется подключать выводы OUTPUT к другим устройствам через резисторы 470 Ом или 1 кОм, если для конкретного применения не требуется максимальный ток, потребляемый от выводов.

Функция pinMode ()

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

Синтаксис функции pinMode ()

Void setup () {
   pinMode (pin , mode);
}

• pin - номер пина, режим которого вы хотите установить

• mode - INPUT, OUTPUT или INPUT_PULLUP.

Example

int button = 5 ; // button connected to pin 5
int LED = 6; // LED connected to pin 6

void setup () {
   pinMode(button , INPUT_PULLUP); 
   // set the digital pin as input with pull-up resistor
   pinMode(button , OUTPUT); // set the digital pin as output
}

void setup () {
   If (digitalRead(button ) == LOW) // if button pressed {
      digitalWrite(LED,HIGH); // turn on led
      delay(500); // delay for 500 ms
      digitalWrite(LED,LOW); // turn off led
      delay(500); // delay for 500 ms
   }
}

digitalWrite (), функция

В digitalWrite()Функция используется для записи ВЫСОКОГО или НИЗКОГО значения на цифровой вывод. Если вывод был настроен как ВЫХОД с помощью pinMode () , его напряжение будет установлено на соответствующее значение: 5 В (или 3,3 В на платах 3,3 В) для ВЫСОКОГО, 0 В (земля) для НИЗКОГО. Если вывод настроен как INPUT, digitalWrite () включит (HIGH) или отключит (LOW) внутреннюю подтяжку на входном выводе. Рекомендуется установить для pinMode () значение INPUT_PULLUP, чтобы включить внутренний подтягивающий резистор.

Если вы не установите для pinMode () значение OUTPUT и не подключите светодиод к контакту, при вызове digitalWrite (HIGH) светодиод может потускнеть. Без явной установки pinMode () digitalWrite () включит внутренний подтягивающий резистор, который действует как большой токоограничивающий резистор.

Синтаксис функции digitalWrite ()

Void loop() {
   digitalWrite (pin ,value);
}

• pin - номер пина, режим которого вы хотите установить

• value - ВЫСОКИЙ или НИЗКИЙ.

Example

int LED = 6; // LED connected to pin 6

void setup () {
   pinMode(LED, OUTPUT); // set the digital pin as output
}

void setup () { 
   digitalWrite(LED,HIGH); // turn on led
   delay(500); // delay for 500 ms
   digitalWrite(LED,LOW); // turn off led
   delay(500); // delay for 500 ms
}

Функция analogRead ()

Arduino может определить, есть ли напряжение на одном из его контактов, и сообщить об этом с помощью функции digitalRead (). Существует разница между датчиком включения / выключения (который определяет присутствие объекта) и аналоговым датчиком, значение которого постоянно изменяется. Чтобы считывать данные с датчика этого типа, нам понадобится штырь другого типа.

В правом нижнем углу платы Arduino вы увидите шесть контактов с пометкой «Analog In». Эти специальные контакты не только показывают, есть ли на них напряжение, но и его значение. ИспользуяanalogRead() функция, мы можем прочитать напряжение, приложенное к одному из контактов.

Эта функция возвращает число от 0 до 1023, которое представляет напряжение от 0 до 5 вольт. Например, если к контакту номер 0 приложено напряжение 2,5 В, analogRead (0) возвращает 512.

Синтаксис функции analogRead ()

analogRead(pin);

• pin - номер аналогового входа для чтения (от 0 до 5 на большинстве плат, от 0 до 7 на Mini и Nano, от 0 до 15 на Mega)

Example

int analogPin = 3;//potentiometer wiper (middle terminal) 
   // connected to analog pin 3 
int val = 0; // variable to store the value read

void setup() {
   Serial.begin(9600); // setup serial
} 

void loop() {
   val = analogRead(analogPin); // read the input pin
   Serial.println(val); // debug value
}

В этой главе мы изучим некоторые расширенные функции ввода и вывода.

Функция analogReference ()

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

• DEFAULT - Аналоговый по умолчанию ссылка 5 вольт (на 5V Arduino платах) или 3,3 вольт (на 3,3 Arduino плат)

• INTERNAL - An встроенный в ссылке, равным 1,1 вольт на ATmega168 или ATmega328 и 2,56 вольт на ATmega8 (не доступен на Arduino Mega)

• INTERNAL1V1 - Встроенный 1.1V ссылки (Arduino Mega только)

• INTERNAL2V56 - Встроенный 2.56V ссылки (Arduino Mega только)

• EXTERNAL - Напряжение, прикладываемое к AREF штифтом (от 0 до 5 только) используется в качестве ссылки

Синтаксис функции analogReference ()

analogReference (type);

type - можно использовать любой из следующих типов (ПО УМОЛЧАНИЮ, ВНУТРЕННЯЯ, ВНУТРЕННЯЯ1V1, ВНУТРЕННЯЯ2V56, ВНЕШНЯЯ)

Ничего не использовать меньше 0В или более 5В для внешнего опорного напряжения на Ареф штифтом. Если вы используете внешнюю ссылку на выводе AREF, вы должны установить аналоговую ссылку на EXTERNAL перед вызовомanalogRead()функция. В противном случае, вы будете короткий активный источник опорного напряжения (внутренне генерируется) и AREF контактный, возможно, повреждая микроконтроллер на вашем Arduino борту.

Кроме того, вы можете подключить внешний источник опорного напряжения к AREF штифтом через резистор 5K, что позволяет переключаться между внешними и внутренними опорными напряжениями.

Обратите внимание, что резистор изменит напряжение, которое используется в качестве эталона, так как есть внутренний 32K резистор на AREF штифтом. Они действуют как делитель напряжения. Например, 2,5 В, приложенное через резистор, даст 2,5 * 32 / (32 + 5) = ~ 2,2 В на выводе AREF.

Example

int analogPin = 3;// potentiometer wiper (middle terminal) connected to analog pin 3 
int val = 0; // variable to store the read value

void setup() {
   Serial.begin(9600); // setup serial
   analogReference(EXTERNAL); // the voltage applied to the AREF pin (0 to 5V only) 
      // is used as the reference.
}

void loop() {
   val = analogRead(analogPin); // read the input pin
   Serial.println(val); // debug value
}

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

Библиотека обработки символов включает несколько функций, которые выполняют полезные тесты и манипуляции с символьными данными. Каждая функция получает в качестве аргумента символ, представленный как int, или EOF. Символы часто обрабатываются как целые числа.

Помните, что EOF обычно имеет значение –1 и что некоторые аппаратные архитектуры не позволяют хранить отрицательные значения в переменных типа char. Следовательно, функции обработки символов обрабатывают символы как целые числа.

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

S.No.	Прототип и описание
1	int isdigit( int c ) Возвращает 1, если c - цифра, и 0 в противном случае.
2	int isalpha( int c ) Возвращает 1, если c - буква, и 0 в противном случае.
3	int isalnum( int c ) Возвращает 1, если c - цифра или буква, и 0 в противном случае.
4	int isxdigit( int c ) Возвращает 1, если c - шестнадцатеричный символ, и 0 в противном случае. (См. Приложение D, Системы счисления, для подробного объяснения двоичных, восьмеричных, десятичных и шестнадцатеричных чисел.)
5	int islower( int c ) Возвращает 1, если c - строчная буква, и 0 в противном случае.
6	int isupper( int c ) Возвращает 1, если c - заглавная буква; 0 в противном случае.
7	int isspace( int c ) Возвращает 1, если c - символ пробела - новая строка ('\ n'), пробел (''), подача формы ('\ f'), возврат каретки ('\ r'), горизонтальная табуляция ('\ t') или вертикальная табуляция ('\ v') - и 0 в противном случае.
8	int iscntrl( int c ) Возвращает 1, если c является управляющим символом, таким как новая строка ('\ n'), подача формы ('\ f'), возврат каретки ('\ r'), горизонтальная табуляция ('\ t'), вертикальная табуляция (' \ v '), alert (' \ a ') или backspace (' \ b ') - и 0 в противном случае.
9	int ispunct( int c ) Возвращает 1, если c - печатный символ, отличный от пробела, цифры или буквы, и 0 в противном случае.
10	int isprint( int c ) Возвращает 1, если c - печатный символ, включая пробел (''), и 0 в противном случае.
11	int isgraph( int c ) Возвращает 1, если c - печатный символ, отличный от пробела (''), и 0 в противном случае.

Примеры

В следующем примере демонстрируется использование функций isdigit, isalpha, isalnum и isxdigit. Функцияisdigitопределяет, является ли его аргумент цифрой (0–9). Функцияisalphaопределяет, является ли его аргумент прописной буквой (AZ) или строчной буквой (a – z). Функцияisalnumопределяет, является ли его аргумент прописной, строчной буквой или цифрой. Функцияisxdigit определяет, является ли его аргумент шестнадцатеричной цифрой (A – F, a – f, 0–9).

Пример 1

void setup () {
   Serial.begin (9600);
   Serial.print ("According to isdigit:\r");
   Serial.print (isdigit( '8' ) ? "8 is a": "8 is not a");
   Serial.print (" digit\r" );
   Serial.print (isdigit( '8' ) ?"# is a": "# is not a") ;
   Serial.print (" digit\r");
   Serial.print ("\rAccording to isalpha:\r" );
   Serial.print (isalpha('A' ) ?"A is a": "A is not a");
   Serial.print (" letter\r");
   Serial.print (isalpha('A' ) ?"b is a": "b is not a");
   Serial.print (" letter\r");
   Serial.print (isalpha('A') ?"& is a": "& is not a");
   Serial.print (" letter\r");
   Serial.print (isalpha( 'A' ) ?"4 is a":"4 is not a");
   Serial.print (" letter\r");
   Serial.print ("\rAccording to isalnum:\r");
   Serial.print (isalnum( 'A' ) ?"A is a" : "A is not a" );

   Serial.print (" digit or a letter\r" );
   Serial.print (isalnum( '8' ) ?"8 is a" : "8 is not a" ) ;
   Serial.print (" digit or a letter\r");
   Serial.print (isalnum( '#' ) ?"# is a" : "# is not a" );
   Serial.print (" digit or a letter\r");
   Serial.print ("\rAccording to isxdigit:\r");
   Serial.print (isxdigit( 'F' ) ?"F is a" : "F is not a" );
   Serial.print (" hexadecimal digit\r" );
   Serial.print (isxdigit( 'J' ) ?"J is a" : "J is not a" ) ;
   Serial.print (" hexadecimal digit\r" );
   Serial.print (isxdigit( '7' ) ?"7 is a" : "7 is not a" ) ;

   Serial.print (" hexadecimal digit\r" );
   Serial.print (isxdigit( '$' ) ? "$ is a" : "$ is not a" );
   Serial.print (" hexadecimal digit\r" );
   Serial.print (isxdigit( 'f' ) ? “f is a" : "f is not a");
   
}

void loop () {

}

Результат

According to isdigit:
8 is a digit
# is not a digit
According to isalpha:
A is a letter
b is a letter
& is not a letter
4 is not a letter
According to isalnum:
A is a digit or a letter

8 is a digit or a letter
# is not a digit or a letter
According to isxdigit:
F is a hexadecimal digit
J is not a hexadecimal digit
7 is a hexadecimal digit

$ is not a hexadecimal digit
f is a hexadecimal digit

Мы используем условный оператор (?:)с каждой функцией, чтобы определить, должна ли строка «является» или строка «не является» выводиться для каждого проверенного символа. Например, строкаa указывает, что если «8» - это цифра, т. е. isdigitвозвращает истинное (ненулевое) значение - печатается строка «8 is a». Если «8» не цифра (т. Е. Еслиisdigit возвращает 0) выводится строка «8 is not a».

Пример 2

В следующем примере демонстрируется использование функций islower и isupper. Функцияislowerопределяет, является ли его аргумент строчной буквой (a – z). Функцияisupper определяет, является ли его аргумент прописной буквой (A – Z).

int thisChar = 0xA0;

void setup () {
   Serial.begin (9600);
   Serial.print ("According to islower:\r") ;
   Serial.print (islower( 'p' ) ? "p is a" : "p is not a" );
   Serial.print ( " lowercase letter\r" );
   Serial.print ( islower( 'P') ? "P is a" : "P is not a") ;
   Serial.print ("lowercase letter\r");
   Serial.print (islower( '5' ) ? "5 is a" : "5 is not a" );
   Serial.print ( " lowercase letter\r" );
   Serial.print ( islower( '!' )? "! is a" : "! is not a") ;
   Serial.print ("lowercase letter\r");

   Serial.print ("\rAccording to isupper:\r") ;
   Serial.print (isupper ( 'D' ) ? "D is a" : "D is not an" );
   Serial.print ( " uppercase letter\r" );
   Serial.print ( isupper ( 'd' )? "d is a" : "d is not an") ;
   Serial.print ( " uppercase letter\r" );
   Serial.print (isupper ( '8' ) ? "8 is a" : "8 is not an" );
   Serial.print ( " uppercase letter\r" );
   Serial.print ( islower( '$' )? "$ is a" : "$ is not an") ;
   Serial.print ("uppercase letter\r ");
}

void setup () {

}

Результат

According to islower:
p is a lowercase letter
P is not a lowercase letter
5 is not a lowercase letter
! is not a lowercase letter

According to isupper:
D is an uppercase letter
d is not an uppercase letter
8 is not an uppercase letter
$ is not an uppercase letter

Пример 3

В следующем примере демонстрируется использование функций isspace, iscntrl, ispunct, isprint и isgraph.

• Функция isspace определяет, является ли его аргумент символом пробела, например пробелом (''), переводом формы ('\ f'), новой строкой ('\ n'), возвратом каретки ('\ r'), горизонтальной табуляцией ('\ t ') или вертикальной табуляции (' \ v ').

• Функция iscntrl определяет, является ли его аргумент управляющим символом, таким как горизонтальная табуляция ('\ t'), вертикальная табуляция ('\ v'), подача формы ('\ f'), предупреждение ('\ a'), backspace ('\ b '), возврата каретки (' \ r ') или новой строки (' \ n ').

• Функция ispunct определяет, является ли его аргумент печатным символом, отличным от пробела, цифры или буквы, например $, #, (,), [,], {,},;,: или%.

• Функция isprint определяет, является ли его аргумент символом, который может отображаться на экране (включая пробел).

• Функция isgraph проверяет наличие тех же символов, что и isprint, но без пробела.

void setup () {
   Serial.begin (9600);
   Serial.print ( " According to isspace:\rNewline ") ;
   Serial.print (isspace( '\n' )? " is a" : " is not a" );
   Serial.print ( " whitespace character\rHorizontal tab") ;
   Serial.print (isspace( '\t' )? " is a" : " is not a" );
   Serial.print ( " whitespace character\n") ;
   Serial.print (isspace('%')? " % is a" : " % is not a" );
   
   Serial.print ( " \rAccording to iscntrl:\rNewline") ;
   Serial.print ( iscntrl( '\n' )?"is a" : " is not a" ) ;
   Serial.print (" control character\r");
   Serial.print (iscntrl( '$' ) ? " $ is a" : " $ is not a" );
   Serial.print (" control character\r");
   Serial.print ("\rAccording to ispunct:\r");
   Serial.print (ispunct(';' ) ?"; is a" : "; is not a" ) ;
   Serial.print (" punctuation character\r");
   Serial.print (ispunct('Y' ) ?"Y is a" : "Y is not a" ) ;
   Serial.print ("punctuation character\r");
   Serial.print (ispunct('#' ) ?"# is a" : "# is not a" ) ;
   Serial.print ("punctuation character\r");

   Serial.print ( "\r According to isprint:\r");
   Serial.print (isprint('$' ) ?"$ is a" : "$ is not a" );
   Serial.print (" printing character\rAlert ");
   Serial.print (isprint('\a' ) ?" is a" : " is not a" );
   Serial.print (" printing character\rSpace ");
   Serial.print (isprint(' ' ) ?" is a" : " is not a" );
   Serial.print (" printing character\r");
   
   Serial.print ("\r According to isgraph:\r");
   Serial.print (isgraph ('Q' ) ?"Q is a" : "Q is not a" );
   Serial.print ("printing character other than a space\rSpace ");
   Serial.print (isgraph (' ') ?" is a" : " is not a" );
   Serial.print ("printing character other than a space ");
}

void loop () {

}

Результат

According to isspace:
Newline is a whitespace character
Horizontal tab is a whitespace character
% is not a whitespace character
According to iscntrl:
Newline is a control character
$ is not a control character
According to ispunct:
; is a punctuation character
Y is not a punctuation character
# is a punctuation character
According to isprint:
$ is a printing character
Alert is not a printing character
Space is a printing character
According to isgraph:
Q is a printing character other than a space
Space is not a printing character other than a space

Библиотека Arduino Math (math.h) включает ряд полезных математических функций для управления числами с плавающей запятой.

Макросы библиотеки

Ниже приведены макросы, определенные в заголовке math.h:

Ниже приведен список макросов, определенных в заголовке math.h

Макросы	Значение	Описание
МНЕ	2,7182818284590452354	Константа e.
M_LOG2E	1.4426950408889634074 / * log_2 e * /	Логарифм числа е по основанию 2
M_1_PI	0,31830988618379067154 / * 1 / пи * /	Константа 1 / пи
M_2_PI	0,63661977236758134308 / * 2 / пи * /	Константа 2 / пи
M_2_SQRTPI	1,12837916709551257390 / * 2 / sqrt (пи) * /	Константа 2 / sqrt (пи)
M_LN10	2,30258509299404568402 / * log_e 10 * /	Натуральный логарифм 10
M_LN2	0,69314718055994530942 / * log_e 2 * /	Натуральный логарифм 2
M_LOG10E	0,43429448190325182765 / * log_10 e * /	Логарифм числа е по основанию 10
M_PI	3,14159265358979323846 /* Пи */	Постоянная пи
M_PI_2	3.3V1.57079632679489661923 / * пи / 2 * /	Константа пи / 2
M_PI_4	0,78539816339744830962 / * пи / 4 * /	Константа пи / 4
M_SQRT1_2	0,70710678118654752440 / * 1 / sqrt (2) * /	Константа 1 / sqrt (2)
M_SQRT2	1,41421356237309504880 / * sqrt (2) * /	Квадратный корень из 2
acosf	-	Псевдоним для функции acos ()
asinf	-	Псевдоним для функции asin ()
atan2f	-	Псевдоним для функции atan2 ()
cbrtf	-	Псевдоним для функции cbrt ()
потолок	-	Псевдоним для функции ceil ()
copysignf	-	Псевдоним для функции copysign ()
шф	-	Псевдоним для функции cosh ()
expf	-	Псевдоним для функции exp ()
фабсф	-	Псевдоним для функции fabs ()
fdimf	-	Псевдоним для функции fdim ()
пол	-	Псевдоним для функции floor ()
fmaxf	-	Псевдоним для функции fmax ()
fminf	-	Псевдоним для функции fmin ()
fmodf	-	Псевдоним для функции fmod ()
frexpf	-	Псевдоним для функции frexp ()
гипотф	-	Псевдоним для функции hypot ()
БЕСКОНЕЧНОСТЬ	-	БЕСКОНЕЧНАЯ константа
isfinitef	-	Псевдоним для функции isfinite ()
isinff	-	Псевдоним для функции isinf ()
isnanf	-	Псевдоним для функции isnan ()
ldexpf	-	Псевдоним для функции ldexp ()
log10f	-	Псевдоним для функции log10 ()
logf	-	Псевдоним для функции log ()
lrintf	-	Псевдоним для функции lrint ()
lroundf	-	Псевдоним для функции lround ()

Библиотечные функции

Следующие функции определены в заголовке math.h -

Ниже приведен список функций, определенных в заголовке math.h

S.No.	Библиотека Функция и описание
1	double acos (double __x) Функция acos () вычисляет главное значение арккосинуса __x. Возвращаемое значение находится в диапазоне [0, пи] радиан. Ошибка домена возникает для аргументов вне диапазона [-1, +1].
2	double asin (double __x) Функция asin () вычисляет главное значение арксинуса __x. Возвращаемое значение находится в диапазоне [-pi / 2, pi / 2] радиан. Ошибка домена возникает для аргументов вне диапазона [-1, +1].
3	double atan (double __x) Функция atan () вычисляет главное значение арктангенса __x. Возвращаемое значение находится в диапазоне [-pi / 2, pi / 2] радиан.
4	double atan2 (double __y, double __x) Функция atan2 () вычисляет главное значение арктангенса __y / __x, используя знаки обоих аргументов для определения квадранта возвращаемого значения. Возвращаемое значение находится в диапазоне [-pi, + pi] радиан.
5	double cbrt (double __x) Функция cbrt () возвращает кубический корень __x.
6	double ceil (double __x) Функция ceil () возвращает наименьшее целое значение, большее или равное __x, выраженное в виде числа с плавающей запятой.
7	static double copysign (double __x, double __y) Функция copysign () возвращает __x, но со знаком __y. Они работают, даже если __x или __y NaN или ноль.
8	double cos(double __x) Функция cos () возвращает косинус __x, измеренный в радианах.
9	double cosh (double __x) Функция cosh () возвращает гиперболический косинус __x.
10	double exp (double __x) Функция exp () возвращает экспоненциальное значение __x.
11	double fabs (double __x) Функция fabs () вычисляет абсолютное значение числа с плавающей запятой __x.
12	double fdim (double __x, double __y) Функция fdim () возвращает max (__ x - __y, 0). Если __x или __y или оба являются NaN, возвращается NaN.
13	double floor (double __x) Функция floor () возвращает наибольшее целое значение, меньшее или равное __x, выраженное в виде числа с плавающей запятой.
14	double fma (double __x, double __y, double __z) Функция fma () выполняет умножение-сложение с плавающей запятой. Это операция (__x * __y) + __z, но промежуточный результат не округляется до целевого типа. Иногда это может улучшить точность вычислений.
15	double fmax (double __x, double __y) Функция fmax () возвращает большее из двух значений __x и __y. Если аргумент NaN, возвращается другой аргумент. Если оба аргумента - NaN, возвращается NaN.
16	double fmin (double __x, double __y) Функция fmin () возвращает меньшее из двух значений __x и __y. Если аргумент NaN, возвращается другой аргумент. Если оба аргумента - NaN, возвращается NaN.
17	double fmod (double __x, double__y) Функция fmod () возвращает остаток от __x / __y с плавающей запятой.
18	double frexp (double __x, int * __pexp) Функция frexp () разбивает число с плавающей запятой на нормализованную дробь и целую степень 2. Она сохраняет целое число в объекте int, на который указывает __pexp. Если __x - обычное число с плавающей запятой, функция frexp () возвращает значение v, так что v имеет величину в интервале [1/2, 1) или ноль, а __x равно v, умноженному на 2, в степени __pexp. Если __x равно нулю, обе части результата равны нулю. Если __x не является конечным числом, frexp () возвращает __x как есть и сохраняет 0 с помощью __pexp. Note - Эта реализация позволяет нулевому указателю в качестве директивы пропустить сохранение экспоненты.
19	double hypot (double __x, double__y) Функция hypot () возвращает sqrt (__ x * __ x + __y * __ y). Это длина гипотенузы прямоугольного треугольника со сторонами длиной __x и __y или расстояние от точки (__x, __y) до начала координат. Использование этой функции вместо прямой формулы является разумным, поскольку ошибка намного меньше. Отсутствие потери значимости при малых __x и __y. Нет переполнения, если результат находится в допустимом диапазоне.
20	static int isfinite (double __x) Функция isfinite () возвращает ненулевое значение, если __x конечно: не плюс или минус бесконечность, и не NaN.
21 год	int isinf (double __x) Функция isinf () возвращает 1, если аргумент __x положительная бесконечность, -1, если __x отрицательная бесконечность, и 0 в противном случае. Note - GCC 4.3 может заменить эту функцию встроенным кодом, который возвращает значение 1 для обеих бесконечностей (ошибка gcc № 35509).
22	int isnan (double __x) Функция isnan () возвращает 1, если аргумент __x представляет «не-число» (NaN) объект, иначе 0.
23	double ldexp (double __x, int __exp ) Функция ldexp () умножает число с плавающей запятой на целую степень 2. Она возвращает значение __x, умноженное на 2, в степени __exp.
24	double log (double __x) Функция log () возвращает натуральный логарифм аргумента __x.
25	double log10(double __x) Функция log10 () возвращает логарифм аргумента __x с основанием 10.
26	long lrint (double __x) Функция lrint () округляет __x до ближайшего целого числа, округляя средние значения до четного целого числа. (То есть значения 1,5 и 2,5 округляются до 2). Эта функция похожа на функцию rint (), но отличается типом возвращаемого значения и тем, что возможно переполнение. Returns Округленное длинное целое число. Если __x не является конечным числом или переполнением, эта реализация возвращает значение LONG_MIN (0x80000000).
27	long lround (double __x) Функция lround () округляет __x до ближайшего целого числа, но округляет половину случаев от нуля (вместо ближайшего четного целого числа). Эта функция похожа на функцию round (), но отличается типом возвращаемого значения и возможностью переполнения. Returns Округленное длинное целое число. Если __x не является конечным числом или было переполнение, эта реализация возвращает значение LONG_MIN (0x80000000).
28	double modf (double __x, double * __iptr ) Функция modf () разбивает аргумент __x на целую и дробную части, каждая из которых имеет тот же знак, что и аргумент. Он хранит неотъемлемую часть как двойную в объекте, на который указывает __iptr. Функция modf () возвращает дробную часть __x со знаком. Note- Эта реализация пропускает запись по нулевому указателю. Однако GCC 4.3 может заменить эту функцию встроенным кодом, который не позволяет использовать NULL-адрес, чтобы избежать сохранения.
29	float modff (float __x, float * __iptr) Псевдоним для modf ().
30	double pow (double __x, double __y) Функция pow () возвращает значение __x экспоненте __y.
31 год	double round (double __x) Функция round () округляет __x до ближайшего целого числа, но округляет половину случаев от нуля (вместо ближайшего четного целого числа). Переполнение невозможно. Returns Округленное значение. Если __x является целым или бесконечным, возвращается сам __x. Если __xNaN, тогда NaN возвращается.
32	int signbit (double __x) Функция signbit () возвращает ненулевое значение, если для значения __x установлен знаковый бит. Это не то же самое, что `__x <0.0 ', потому что с плавающей запятой IEEE 754 можно подписать ноль. Сравнение `-0.0 <0.0 'неверно, но` signbit (-0.0)' вернет ненулевое значение.
33	double sin (double __x) Функция sin () возвращает синус __x, измеренный в радианах.
34	double sinh (double __x) Функция sinh () возвращает гиперболический синус __x.
35 год	double sqrt (double __x) Функция sqrt () возвращает неотрицательный квадратный корень из __x.
36	double square (double __x) Функция square () возвращает __x * __x. Note - Эта функция не входит в стандартное определение C.
37	double tan (double __x) Функция tan () возвращает тангенс __x, измеренный в радианах.
38	double tanh ( double __x) Функция tanh () возвращает гиперболический тангенс __x.
39	double trunc (double __x) Функция trunc () округляет __x до ближайшего целого числа, не большего по модулю.

пример

В следующем примере показано, как использовать наиболее распространенные функции библиотеки math.h:

double double__x = 45.45 ;
double double__y = 30.20 ;

void setup() {
   Serial.begin(9600);
   Serial.print("cos num = ");
   Serial.println (cos (double__x) ); // returns cosine of x
   Serial.print("absolute value of num = ");
   Serial.println (fabs (double__x) ); // absolute value of a float
   Serial.print("floating point modulo = ");
   Serial.println (fmod (double__x, double__y)); // floating point modulo
   Serial.print("sine of num = ");
   Serial.println (sin (double__x) ) ;// returns sine of x
   Serial.print("square root of num : ");
   Serial.println ( sqrt (double__x) );// returns square root of x
   Serial.print("tangent of num : ");
   Serial.println ( tan (double__x) ); // returns tangent of x
   Serial.print("exponential value of num : ");
   Serial.println ( exp (double__x) ); // function returns the exponential value of x.
   Serial.print("cos num : ");

   Serial.println (atan (double__x) ); // arc tangent of x
   Serial.print("tangent of num : ");
   Serial.println (atan2 (double__y, double__x) );// arc tangent of y/x
   Serial.print("arc tangent of num : ");
   Serial.println (log (double__x) ) ; // natural logarithm of x
   Serial.print("cos num : ");
   Serial.println ( log10 (double__x)); // logarithm of x to base 10.
   Serial.print("logarithm of num to base 10 : ");
   Serial.println (pow (double__x, double__y) );// x to power of y
   Serial.print("power of num : ");
   Serial.println (square (double__x)); // square of x
}

void loop() {

}

Результат

cos num = 0.10
absolute value of num = 45.45
floating point modulo =15.25
sine of num = 0.99
square root of num : 6.74
tangent of num : 9.67
exponential value of num : ovf
cos num : 1.55
tangent of num : 0.59
arc tangent of num : 3.82
cos num : 1.66
logarithm of num to base 10 : inf
power of num : 2065.70

Вам нужно использовать тригонометрию практически так же, как вычисление расстояния для движущегося объекта или угловой скорости. Arduino предоставляет традиционные тригонометрические функции (sin, cos, tan, asin, acos, atan), которые можно резюмировать, написав их прототипы. Math.h содержит прототип функции тригонометрии.

Тригонометрический точный синтаксис

double sin(double x); //returns sine of x radians
double cos(double y); //returns cosine of y radians
double tan(double x); //returns the tangent of x radians
double acos(double x); //returns A, the angle corresponding to cos (A) = x
double asin(double x); //returns A, the angle corresponding to sin (A) = x
double atan(double x); //returns A, the angle corresponding to tan (A) = x

пример

double sine = sin(2); // approximately 0.90929737091
double cosine = cos(2); // approximately -0.41614685058
double tangent = tan(2); // approximately -2.18503975868

Arduino Due - это плата микроконтроллера на базе процессора Atmel SAM3X8E ARM Cortex-M3. Это первая плата Arduino на базе 32-битного микроконтроллера ARM.

Важные особенности -

• Он имеет 54 цифровых входа / выхода (из которых 12 могут использоваться как выходы ШИМ)
• 12 аналоговых входов
• 4 UART (аппаратные последовательные порты)
• Тактовая частота 84 МГц, подключение с поддержкой USB OTG
• 2 ЦАП (цифро-аналоговый), 2 TWI, разъем питания, заголовок SPI, заголовок JTAG
• Кнопка сброса и кнопка стирания

Характеристики платы Arduino Due

Рабочее напряжение	Скорость процессора	Аналоговый вход / выход	Цифровой ввод-вывод / ШИМ	EEPROM [КБ]	SRAM [КБ]	Flash [КБ]	USB	UART
3.3 Вольт	84 МГц	12/2	54/12	-	96	512	2 микро	4

Общение

• 4 аппаратных UART
• 2 I2C
• 1 интерфейс CAN (автомобильный протокол связи)
• 1 SPI
• 1 интерфейс JTAG (10 контактов)
• 1 USB-хост (как у Леонардо)
• 1 порт программирования

В отличие от большинства плат Arduino, плата Arduino Due работает от 3,3 В. Максимальное напряжение, которое могут выдерживать контакты ввода / вывода, составляет 3,3 В. Подача напряжения выше 3,3 В на любой вывод ввода / вывода может привести к повреждению платы.

На плате есть все необходимое для поддержки микроконтроллера. Вы можете просто подключить его к компьютеру с помощью кабеля micro-USB или подключить к нему адаптер переменного тока в постоянный или аккумулятор, чтобы начать работу. Due совместим со всеми экранами Arduino, работающими от 3,3 В.

Arduino Zero

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

Важные особенности -

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

• Плата питается от микроконтроллера SAMD21 компании Atmel с 32-разрядным ядром ARM Cortex® M0 +.

• Одной из наиболее важных функций является встроенный отладчик Atmel (EDBG), который обеспечивает полный интерфейс отладки без необходимости в дополнительном оборудовании, что значительно повышает простоту использования отладки программного обеспечения.

• EDBG также поддерживает виртуальный COM-порт, который можно использовать для программирования устройств и загрузчика.

Характеристики платы Arduino Zero

Рабочее напряжение	Скорость процессора	Аналоговый вход / выход	Цифровой ввод-вывод / ШИМ	EEPROM [КБ]	SRAM [КБ]	Flash [КБ]	USB	UART
3.3 Вольт	48 МГц	6/1	14/10	-	32	256	2 микро	2

В отличие от большинства плат Arduino и Genuino, Zero работает от 3,3 В. Максимальное напряжение, которое могут выдерживать контакты ввода / вывода, составляет 3,3 В. Подача напряжения выше 3,3 В на любой вывод ввода / вывода может привести к повреждению платы.

На плате есть все необходимое для поддержки микроконтроллера. Вы можете просто подключить его к компьютеру с помощью кабеля micro-USB или подключить к нему адаптер переменного тока в постоянный или аккумулятор, чтобы начать работу. Zero совместим со всеми экранами, работающими от 3,3 В.

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

Основной принцип ШИМ

Широтно-импульсная модуляция - это, по сути, прямоугольная волна с переменным временем высокого и низкого уровня. Базовый сигнал ШИМ показан на следующем рисунке.

Есть различные термины, связанные с ШИМ -

• On-Time - Длительность сигнала времени высокая.

• Off-Time - Длительность сигнала времени мала.

• Period - Он представлен как сумма времени включения и времени выключения сигнала ШИМ.

• Duty Cycle - Он представлен как процент времени сигнала, который остается включенным в течение периода сигнала ШИМ.

Период

Как показано на рисунке, T _on обозначает время включения, а T _off обозначает время отключения сигнала. Период представляет собой сумму времени включения и выключения и рассчитывается, как показано в следующем уравнении -

Рабочий цикл

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

Функция analogWrite ()

В analogWrite()функция записывает аналоговое значение (сигнал ШИМ) на вывод. Его можно использовать для освещения светодиода с разной яркостью или для привода двигателя с разной скоростью. После вызова функции analogWrite () вывод будет генерировать устойчивую прямоугольную волну указанного рабочего цикла до следующего вызова analogWrite () или вызова digitalRead () или digitalWrite () на том же выводе. Частота сигнала ШИМ на большинстве контактов составляет примерно 490 Гц. На Uno и аналогичных платах контакты 5 и 6 имеют частоту примерно 980 Гц. Контакты 3 и 11 на Леонардо также работают на частоте 980 Гц.

На большинстве плат Arduino (с ATmega168 или ATmega328) эта функция работает на контактах 3, 5, 6, 9, 10 и 11. На Arduino Mega она работает на контактах 2-13 и 44-46. платы с ATmega8 поддерживают только analogWrite() на контактах 9, 10 и 11.

Arduino Due поддерживает analogWrite()на контактах 2-13 и контактах DAC0 и DAC1. В отличие от контактов PWM, DAC0 и DAC1 представляют собой цифро-аналоговые преобразователи и действуют как настоящие аналоговые выходы.

Вам не нужно вызывать pinMode (), чтобы установить вывод в качестве вывода перед вызовом analogWrite ().

Синтаксис функции analogWrite ()

analogWrite ( pin , value ) ;

value - рабочий цикл: от 0 (всегда выключен) до 255 (всегда включен).

Example

int ledPin = 9; // LED connected to digital pin 9
int analogPin = 3; // potentiometer connected to analog pin 3
int val = 0; // variable to store the read value

void setup() {
   pinMode(ledPin, OUTPUT); // sets the pin as output
}

void loop() {
   val = analogRead(analogPin); // read the input pin
   analogWrite(ledPin, (val / 4)); // analogRead values go from 0 to 1023, 
      // analogWrite values from 0 to 255
}

Для генерации случайных чисел вы можете использовать функции случайных чисел Arduino. У нас есть две функции -

• randomSeed(seed)
• random()

randomSeed (семя)

Функция randomSeed (seed) сбрасывает генератор псевдослучайных чисел Arduino. Хотя распределение чисел, возвращаемых функцией random (), по существу случайное, последовательность предсказуема. Вам следует сбросить генератор на какое-то случайное значение. Если у вас есть неподключенный аналоговый вывод, он может улавливать случайный шум из окружающей среды. Это могут быть радиоволны, космические лучи, электромагнитные помехи от сотовых телефонов, люминесцентные лампы и так далее.

пример

randomSeed(analogRead(5)); // randomize using noise from analog pin 5

случайный ()

Случайная функция генерирует псевдослучайные числа. Ниже приводится синтаксис.

Синтаксис операторов random ()

long random(max) // it generate random numbers from 0 to max
long random(min, max) // it generate random numbers from min to max

пример

long randNumber;

void setup() {
   Serial.begin(9600);
   // if analog input pin 0 is unconnected, random analog
   // noise will cause the call to randomSeed() to generate
   // different seed numbers each time the sketch runs.
   // randomSeed() will then shuffle the random function.
   randomSeed(analogRead(0));
}

void loop() {
   // print a random number from 0 to 299
   Serial.print("random1=");
   randNumber = random(300);
   Serial.println(randNumber); // print a random number from 0to 299
   Serial.print("random2=");
   randNumber = random(10, 20);// print a random number from 10 to 19
   Serial.println (randNumber);
   delay(50);
}

Давайте теперь освежим наши знания о некоторых основных понятиях, таких как биты и байты.

Биты

Бит - это просто двоичная цифра.

• В двоичной системе используются две цифры: 0 и 1.

• Подобно десятичной системе счисления, в которой цифры числа не имеют одинакового значения, «значимость» бита зависит от его позиции в двоичном числе. Например, цифры в десятичном числе 666 одинаковы, но имеют разные значения.

Байтов

Байт состоит из восьми бит.

• Если бит является цифрой, логично, что байты представляют числа.

• С ними можно производить все математические операции.

• Цифры в байте также не имеют одинакового значения.

• Самый левый бит имеет наибольшее значение, называемое наиболее значимым битом (MSB).

• Самый правый бит имеет наименьшее значение и поэтому называется младшим значащим битом (LSB).

• Поскольку восемь нулей и единицы одного байта можно комбинировать 256 различными способами, наибольшее десятичное число, которое может быть представлено одним байтом, равно 255 (одна комбинация представляет ноль).

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

Предположим, вы сидите дома, болтаете с кем-то. Вдруг звонит телефон. Вы прекращаете болтать и берете трубку, чтобы поговорить с вызывающим абонентом. Когда вы закончите телефонный разговор, вы вернетесь к разговору с человеком до того, как зазвонил телефон.

Точно так же вы можете думать об основной рутине как о разговоре с кем-то, когда телефонный звонок заставляет вас перестать общаться. Процедура обслуживания прерывания - это процесс разговора по телефону. Когда телефонный разговор заканчивается, вы возвращаетесь к своей основной рутине общения в чате. Этот пример объясняет, как именно прерывание заставляет процессор действовать.

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

Важные особенности

Вот некоторые важные особенности прерываний -

• Прерывания могут поступать из разных источников. В этом случае мы используем аппаратное прерывание, которое запускается изменением состояния на одном из цифровых выводов.

• В большинстве конструкций Arduino есть два аппаратных прерывания (называемые «прерывание0» и «прерывание1»), жестко подключенные к контактам 2 и 3 цифрового ввода / вывода соответственно.

• Arduino Mega имеет шесть аппаратных прерываний, включая дополнительные прерывания (от «interrupt2» до «interrupt5») на контактах 21, 20, 19 и 18.

• Вы можете определить подпрограмму, используя специальную функцию, называемую «подпрограмма обслуживания прерывания» (обычно известная как ISR).

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

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

Типы прерываний

Есть два типа прерываний -

• Hardware Interrupts - Они возникают в ответ на внешнее событие, такое как высокий или низкий уровень внешнего прерывания.

• Software Interrupts- Они возникают в ответ на инструкцию, отправленную в программном обеспечении. Единственный тип прерывания, который поддерживает «язык Arduino», - это функция attachInterrupt ().

Использование прерываний в Arduino

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

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

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

attachInterrupt(digitalPinToInterrupt(pin),ISR,mode);//recommended for arduino board
attachInterrupt(pin, ISR, mode) ; //recommended Arduino Due, Zero only
//argument pin: the pin number
//argument ISR: the ISR to call when the interrupt occurs; 
   //this function must take no parameters and return nothing. 
   //This function is sometimes referred to as an interrupt service routine.
//argument mode: defines when the interrupt should be triggered.

Следующие три константы предопределены как допустимые значения -

• LOW для запуска прерывания всякий раз, когда на выводе низкий уровень.

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

• FALLING всякий раз, когда булавка идет от высокого к низкому.

Example

int pin = 2; //define interrupt pin to 2
volatile int state = LOW; // To make sure variables shared between an ISR
//the main program are updated correctly,declare them as volatile.

void setup() {
   pinMode(13, OUTPUT); //set pin 13 as output
   attachInterrupt(digitalPinToInterrupt(pin), blink, CHANGE);
   //interrupt at pin 2 blink ISR when pin to change the value
} 
void loop() { 
   digitalWrite(13, state); //pin 13 equal the state value
} 

void blink() { 
   //ISR function
   state = !state; //toggle the state when the interrupt occurs
}

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

Параллельная связь

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

Преимущества и недостатки параллельной связи

У параллельного общения, безусловно, есть свои преимущества. Он быстрее, чем последовательный, прост и относительно прост в реализации. Однако для этого требуется много портов и линий ввода / вывода (I / O). Если вам когда-либо приходилось переносить проект с базового Arduino Uno на Mega, вы знаете, что линии ввода-вывода на микропроцессоре могут быть драгоценными и немногочисленными. Таким образом, мы предпочитаем последовательную связь, жертвуя потенциальной скоростью в пользу булавки.

Модули последовательной связи

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

Какая из этих систем используется, зависит от следующих факторов:

• Со сколькими устройствами микроконтроллер должен обмениваться данными?
• Насколько быстрым должен быть обмен данными?
• Какое расстояние между этими устройствами?
• Обязательно ли отправлять и получать данные одновременно?

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

Типы последовательной связи

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

• Synchronous - Устройства, которые синхронизированы, используют одни и те же часы, и их время синхронизируется друг с другом.

• Asynchronous - Устройства, которые являются асинхронными, имеют свои собственные часы и запускаются выходом из предыдущего состояния.

Узнать, синхронно устройство или нет, несложно. Если на все подключенные устройства выставлены одинаковые часы, то они синхронны. Если линии часов нет, это асинхронно.

Например, модуль UART (универсальный асинхронный приемный передатчик) является асинхронным.

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

• Биты синхронизации
• Биты данных
• Биты четности
• Скорость передачи

Биты синхронизации

Биты синхронизации - это два или три специальных бита, передаваемых с каждым пакетом данных. Это стартовый бит и стоповый бит (ы). Верные своему названию, эти биты обозначают начало и конец пакета соответственно.

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

Стартовый бит всегда обозначается незанятой строкой данных, переходящей от 1 до 0, в то время как стоповый бит (ы) переходит обратно в состояние ожидания, удерживая строку на 1.

Биты данных

Объем данных в каждом пакете может быть установлен любым размером от 5 до 9 бит. Конечно, стандартный размер данных - это ваш базовый 8-битный байт, но другие размеры имеют свое применение. 7-битный пакет данных может быть более эффективным, чем 8-битный, особенно если вы просто передаете 7-битные символы ASCII.

Биты четности

Пользователь может выбрать, должен ли быть бит четности или нет, и если да, будет ли четность нечетной или четной. Бит четности равен 0, если количество единиц среди битов данных четное. Нечетная четность как раз наоборот.

Скорость передачи

Термин «скорость передачи» используется для обозначения количества битов, передаваемых в секунду [бит / с]. Обратите внимание, что это относится к битам, а не байтам. Обычно протокол требует, чтобы каждый байт передавался вместе с несколькими битами управления. Это означает, что один байт в последовательном потоке данных может состоять из 11 бит. Например, если скорость передачи составляет 300 бит / с, то в секунду может передаваться максимум 37 и минимум 27 байтов.

Arduino UART

Следующий код заставит Arduino отправить привет, мир при запуске.

void setup() {
   Serial.begin(9600); //set up serial library baud rate to 9600
   Serial.println("hello world"); //print hello world
}

void loop() {

}

После загрузки скетча Arduino в Arduino откройте последовательный монитор

в правом верхнем углу Arduino IDE.

Введите что-нибудь в верхнее поле Serial Monitor и нажмите кнопку отправки или ввода на клавиатуре. Это отправит серию байтов в Arduino.

Следующий код возвращает все, что получает на входе.

Следующий код заставит Arduino выдавать выходные данные в зависимости от предоставленных входных данных.

void setup() {
   Serial.begin(9600); //set up serial library baud rate to 9600
}

void loop() {
   if(Serial.available()) //if number of bytes (characters) available for reading from { 
      serial port
      Serial.print("I received:"); //print I received
      Serial.write(Serial.read()); //send what you read
   }
}

Заметить, что Serial.print и Serial.println вернет фактический код ASCII, тогда как Serial.writeотправит обратно фактический текст. См. Коды ASCII для получения дополнительной информации.

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

Как видно на следующем рисунке, одно устройство всегда является ведущим. Он выполняет адресацию одного подчиненного чипа до начала связи. Таким образом, один микроконтроллер может взаимодействовать со 112 различными устройствами. Скорость передачи обычно составляет 100 Кб / сек (стандартный режим) или 10 Кб / сек (режим низкой скорости передачи). Недавно появились системы со скоростью передачи 3,4 Мб / сек. Расстояние между устройствами, которые обмениваются данными по шине I2C, ограничено несколькими метрами.

Пины I2C платы

Шина I2C состоит из двух сигналов - SCL и SDA. SCL - это тактовый сигнал, а SDA - это сигнал данных. Текущий мастер шины всегда генерирует тактовый сигнал. Некоторые ведомые устройства могут время от времени устанавливать низкие часы, чтобы задержать отправку большего количества данных ведущим (или для того, чтобы потребовать больше времени для подготовки данных, прежде чем ведущее попытается синхронизировать его). Это известно как «растяжение часов».

Ниже приведены контакты для различных плат Arduino.

• Uno, Pro Mini A4 (SDA), A5 (SCL)
• Mega, Due 20 (SDA), 21 (SCL)
• Леонардо, Юнь 2 (ПДД), 3 (СКЛ)

Ардуино I2C

У нас есть два режима - мастер-код и подчиненный код - для подключения двух плат Arduino с использованием I2C. Они -

• Главный передатчик / подчиненный приемник
• Главный приемник / ведомый передатчик

Главный передатчик / подчиненный приемник

Давайте теперь посмотрим, что такое главный передатчик и подчиненный приемник.

Главный передатчик

Следующие функции используются для инициализации библиотеки Wire и присоединения к шине I2C в качестве ведущего или ведомого. Обычно это вызывается только один раз.

• Wire.begin(address) - Address - это 7-битный адрес подчиненного устройства в нашем случае, поскольку мастер не указан, и он присоединится к шине как мастер.

• Wire.beginTransmission(address) - Начните передачу на ведомое устройство I2C с заданным адресом.

• Wire.write(value) - Помещает байты в очередь для передачи от ведущего к ведомому устройству (между вызовами beginTransmission () и endTransmission ()).

• Wire.endTransmission() - Завершает передачу на ведомое устройство, начатую функцией beginTransmission (), и передает байты, поставленные в очередь функцией wire.write ().

Example

#include <Wire.h> //include wire library

void setup() //this will run only once { 
   Wire.begin(); // join i2c bus as master
} 

short age = 0; 

void loop() {   
   Wire.beginTransmission(2); 
   // transmit to device #2
   Wire.write("age is = ");
   Wire.write(age); // sends one byte
   Wire.endTransmission(); // stop transmitting
   delay(1000); 
}

Ведомый приемник

Используются следующие функции -

• Wire.begin(address) - Адрес - это 7-битный адрес подчиненного устройства.

• Wire.onReceive(received data handler) - Функция, вызываемая, когда ведомое устройство получает данные от ведущего.

• Wire.available() - Возвращает количество байтов, доступных для получения с помощью Wire.read (). Это должно вызываться внутри обработчика Wire.onReceive ().

Example

#include <Wire.h> //include wire library

void setup() {  //this will run only once
   Wire.begin(2); // join i2c bus with address #2
   Wire.onReceive(receiveEvent); // call receiveEvent when the master send any thing 
   Serial.begin(9600); // start serial for output to print what we receive 
}

void loop() {   
   delay(250); 
}

//-----this function will execute whenever data is received from master-----//

void receiveEvent(int howMany) { 
   while (Wire.available()>1) // loop through all but the last {
      char c = Wire.read(); // receive byte as a character
      Serial.print(c); // print the character
   }
}

Главный приемник / ведомый передатчик

Давайте теперь посмотрим, что такое главный приемник и подчиненный передатчик.

Мастер-приемник

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

Используется следующая функция -

Wire.requestFrom(address,number of bytes)- Используется ведущим устройством для запроса байтов от ведомого устройства. Затем байты можно получить с помощью функций wire.available () и wire.read ().

Example

#include <Wire.h> //include wire library void setup() { 
   Wire.begin(); // join i2c bus (address optional for master) 
   Serial.begin(9600); // start serial for output
} 

void loop() { 
   Wire.requestFrom(2, 1); // request 1 bytes from slave device #2
   while (Wire.available()) // slave may send less than requested {
      char c = Wire.read(); // receive a byte as character
      Serial.print(c); // print the character
   } 
   delay(500); 
}

Ведомый передатчик

Используется следующая функция.

Wire.onRequest(handler) - Функция вызывается, когда ведущее устройство запрашивает данные от этого ведомого устройства.

Example

#include <Wire.h> 

void setup() { 
   Wire.begin(2); // join i2c bus with address #2
   Wire.onRequest(requestEvent); // register event
} 

Byte x = 0;

void loop() { 
   delay(100); 
} 

// function that executes whenever data is requested by master
// this function is registered as an event, see setup()

void requestEvent() { 
   Wire.write(x); // respond with message of 1 bytes as expected by master
   x++; 
}

Шина последовательного периферийного интерфейса (SPI) - это система для последовательной связи, в которой используется до четырех проводов, обычно трех. Один проводник используется для приема данных, один для отправки данных, один для синхронизации и один альтернативно для выбора устройства для связи. Это полнодуплексное соединение, что означает, что данные отправляются и принимаются одновременно. Максимальная скорость передачи выше, чем в системе связи I2C.

Пины SPI платы

SPI использует следующие четыре провода -

• SCK - Это последовательные часы, управляемые мастером.

• MOSI - Это главный выход / подчиненный вход, управляемый мастером.

• MISO - Это главный вход / подчиненный выход, управляемый мастером.

• SS - Это провод выбора ведомого.

Используются следующие функции. Вы должны включить SPI.h.

• SPI.begin() - Инициализирует шину SPI, устанавливая SCK, MOSI и SS на выходы, устанавливая SCK и MOSI в низкий уровень, а SS в высокий.

• SPI.setClockDivider(divider)- Для установки делителя тактовой частоты SPI относительно системных часов. На платах на базе AVR доступны делители 2, 4, 8, 16, 32, 64 или 128. Значение по умолчанию - SPI_CLOCK_DIV4, которое устанавливает тактовую частоту SPI на одну четверть частоты системных часов (5 МГц для платы на 20 МГц).

• Divider - Это может быть (SPI_CLOCK_DIV2, SPI_CLOCK_DIV4, SPI_CLOCK_DIV8, SPI_CLOCK_DIV16, SPI_CLOCK_DIV32, SPI_CLOCK_DIV64, SPI_CLOCK_DIV128).

• SPI.transfer(val) - Передача SPI основана на одновременной отправке и приеме: полученные данные возвращаются в файле receiveVal.

• SPI.beginTransaction(SPISettings(speedMaximum, dataOrder, dataMode)) - speedMaximum - это часы, dataOrder (MSBFIRST или LSBFIRST), dataMode (SPI_MODE0, SPI_MODE1, SPI_MODE2 или SPI_MODE3).

У нас есть четыре режима работы в SPI:

• Mode 0 (the default) - Тактовая частота обычно низкая (CPOL = 0), и данные дискретизируются при переходе от низкого к высокому (передний фронт) (CPHA = 0).

• Mode 1 - Тактовая частота обычно низкая (CPOL = 0), и данные дискретизируются при переходе от высокого к низкому (задний фронт) (CPHA = 1).

• Mode 2 - Тактовый сигнал обычно высокий (CPOL = 1), и данные дискретизируются при переходе от высокого к низкому (передний фронт) (CPHA = 0).

• Mode 3 - Тактовый сигнал обычно высокий (CPOL = 1), и данные дискретизируются при переходе от низкого уровня к высокому (задний фронт) (CPHA = 1).

• SPI.attachInterrupt(handler) - Функция, вызываемая, когда ведомое устройство получает данные от ведущего.

Теперь мы соединим две платы Arduino UNO вместе; один как хозяин, а другой как раб.

• (SS): контакт 10
• (MOSI): контакт 11
• (MISO): контакт 12
• (SCK): контакт 13

Земля общая. Ниже приведено схематическое изображение соединения между обеими платами.

Давайте посмотрим на примеры SPI как Master и SPI как Slave.

SPI как МАСТЕР

пример

#include <SPI.h>

void setup (void) {
   Serial.begin(115200); //set baud rate to 115200 for usart
   digitalWrite(SS, HIGH); // disable Slave Select
   SPI.begin ();
   SPI.setClockDivider(SPI_CLOCK_DIV8);//divide the clock by 8
}

void loop (void) {
   char c;
   digitalWrite(SS, LOW); // enable Slave Select
   // send test string
   for (const char * p = "Hello, world!\r" ; c = *p; p++) {
      SPI.transfer (c);
      Serial.print(c);
   }
   digitalWrite(SS, HIGH); // disable Slave Select
   delay(2000);
}

SPI как SLAVE

пример

#include <SPI.h>
char buff [50];
volatile byte indx;
volatile boolean process;

void setup (void) {
   Serial.begin (115200);
   pinMode(MISO, OUTPUT); // have to send on master in so it set as output
   SPCR |= _BV(SPE); // turn on SPI in slave mode
   indx = 0; // buffer empty
   process = false;
   SPI.attachInterrupt(); // turn on interrupt
}
ISR (SPI_STC_vect) // SPI interrupt routine { 
   byte c = SPDR; // read byte from SPI Data Register
   if (indx < sizeof buff) {
      buff [indx++] = c; // save data in the next index in the array buff
      if (c == '\r') //check for the end of the word
      process = true;
   }
}

void loop (void) {
   if (process) {
      process = false; //reset the process
      Serial.println (buff); //print the array on serial monitor
      indx= 0; //reset button to zero
   }
}

Светодиоды - это небольшие мощные фонари, которые используются во многих различных приложениях. Для начала поработаем над миганием светодиода, Hello World микроконтроллеров. Это так же просто, как включить и выключить свет. Установление этого важного исходного уровня даст вам прочную основу для работы над более сложными экспериментами.

Необходимые компоненты

Вам понадобятся следующие компоненты -

• 1 × Макетная плата
• 1 × Arduino Uno R3
• 1 × светодиод
• 1 × 330 Ом резистор
• 2 × Джемпер

Процедура

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

Note- Чтобы узнать полярность светодиода, внимательно посмотрите на него. Более короткая из двух ножек по направлению к плоскому краю лампы указывает на отрицательную клемму.

Компоненты, такие как резисторы, должны иметь свои клеммы согнутыми под углом 90 °, чтобы правильно соответствовать разъемам на макетной плате. Вы также можете сократить клеммы короче.

Эскиз

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

Код Arduino

/*
   Blink
   Turns on an LED on for one second, then off for one second, repeatedly.
*/

// the setup function runs once when you press reset or power the board

void setup() {  // initialize digital pin 13 as an output.
   pinMode(2, OUTPUT);
}

// the loop function runs over and over again forever

void loop() {
   digitalWrite(2, HIGH); // turn the LED on (HIGH is the voltage level)
   delay(1000); // wait for a second
   digitalWrite(2, LOW); // turn the LED off by making the voltage LOW
   delay(1000); // wait for a second
}

Код для примечания

pinMode(2, OUTPUT)- Прежде чем вы сможете использовать один из выводов Arduino, вам необходимо сообщить Arduino Uno R3, является ли он INPUT или OUTPUT. Для этого мы используем встроенную «функцию» pinMode ().

digitalWrite(2, HIGH) - Когда вы используете вывод в качестве ВЫХОДА, вы можете задать ему ВЫСОКИЙ (выход 5 вольт) или НИЗКИЙ (выход 0 вольт).

Результат

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

Этот пример демонстрирует использование функции analogWrite () для постепенного выключения светодиода. AnalogWrite использует широтно-импульсную модуляцию (ШИМ), очень быстро включая и выключая цифровой вывод с различными соотношениями между включением и выключением, чтобы создать эффект затухания.

Необходимые компоненты

Вам понадобятся следующие компоненты -

• 1 × Макетная плата
• 1 × Arduino Uno R3
• 1 × светодиод
• 1 × 330 Ом резистор
• 2 × Джемпер

Процедура

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

Note- Чтобы узнать полярность светодиода, внимательно посмотрите на него. Более короткая из двух ножек по направлению к плоскому краю лампы указывает на отрицательную клемму.

Компоненты, такие как резисторы, должны иметь свои клеммы согнутыми под углом 90 °, чтобы правильно соответствовать разъемам на макетной плате. Вы также можете сократить клеммы короче.

Эскиз

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

Код Arduino

/*
   Fade
   This example shows how to fade an LED on pin 9 using the analogWrite() function.

   The analogWrite() function uses PWM, so if you want to change the pin you're using, be
   sure to use another PWM capable pin. On most Arduino, the PWM pins are identified with
   a "~" sign, like ~3, ~5, ~6, ~9, ~10 and ~11.
*/

int led = 9; // the PWM pin the LED is attached to
int brightness = 0; // how bright the LED is
int fadeAmount = 5; // how many points to fade the LED by
// the setup routine runs once when you press reset:

void setup() {
   // declare pin 9 to be an output:
   pinMode(led, OUTPUT);
}

// the loop routine runs over and over again forever:

void loop() {
   // set the brightness of pin 9:
   analogWrite(led, brightness);
   // change the brightness for next time through the loop:
   brightness = brightness + fadeAmount;
   // reverse the direction of the fading at the ends of the fade:
   if (brightness == 0 || brightness == 255) {
      fadeAmount = -fadeAmount ;
   }
   // wait for 30 milliseconds to see the dimming effect
   delay(300);
}

Код для примечания

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

Чтобы светодиод гаснул и загорался, постепенно увеличивайте значения ШИМ от 0 (полностью выключен) до 255 (полностью включен), а затем обратно до 0, чтобы завершить цикл. В приведенном выше эскизе значение ШИМ устанавливается с помощью переменной, называемой яркостью. Каждый раз при прохождении цикла он увеличивается на значение переменнойfadeAmount.

Если яркость находится на одном из крайних значений (0 или 255), то fadeAmount изменяется на отрицательное. Другими словами, если fadeAmount равно 5, то он устанавливается на -5. Если он равен -5, то он устанавливается на 5. При следующем прохождении цикла это изменение также приводит к изменению направления яркости.

analogWrite()может очень быстро изменить значение ШИМ, поэтому задержка в конце скетча контролирует скорость затухания. Попробуйте изменить значение задержки и посмотрите, как это изменит эффект затухания.

Результат

Вы должны увидеть постепенное изменение яркости светодиода.

Этот пример покажет вам, как считывать аналоговый вход на аналоговом контакте 0. Вход преобразуется из analogRead () в напряжение и распечатывается на последовательном мониторе программного обеспечения Arduino (IDE).

Необходимые компоненты

Вам понадобятся следующие компоненты -

• 1 × Макетная плата
• 1 × Arduino Uno R3
• 1 × 5K переменный резистор (потенциометр)
• 2 × Джемпер

Процедура

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

Потенциометр

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

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

На изображении слева показан стандартный схематический символ горшка. Изображение справа - потенциометр.

Эскиз

Откройте программу Arduino IDE на вашем компьютере. Кодирование на языке Arduino будет управлять вашей схемой. Откройте новый файл эскиза, нажав кнопку «Создать».

Код Arduino

/*
   ReadAnalogVoltage
   Reads an analog input on pin 0, converts it to voltage, 
   and prints the result to the serial monitor.
   Graphical representation is available using serial plotter (Tools > Serial Plotter menu)
   Attach the center pin of a potentiometer to pin A0, and the outside pins to +5V and ground.
*/

// the setup routine runs once when you press reset:

void setup() {
   // initialize serial communication at 9600 bits per second:
   Serial.begin(9600);
}

// the loop routine runs over and over again forever:

void loop() {
   // read the input on analog pin 0:
   int sensorValue = analogRead(A0);
   // Convert the analog reading (which goes from 0 - 1023) to a voltage (0 - 5V):
   float voltage = sensorValue * (5.0 / 1023.0);
   // print out the value you read:
   Serial.println(voltage);
}

Код для примечания

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

Serial.begin(9600);

В основном цикле вашего кода вам необходимо установить переменную для хранения значения сопротивления (которое будет между 0 и 1023, идеально подходит для типа данных int), поступающего с вашего потенциометра -

int sensorValue = analogRead(A0);

Чтобы изменить значения от 0 до 1023 на диапазон, соответствующий напряжению, считываемому выводом, вам необходимо создать другую переменную, число с плавающей запятой, и выполнить небольшой расчет. Чтобы масштабировать числа от 0,0 до 5,0, разделите 5,0 на 1023,0 и умножьте это на sensorValue -

float voltage= sensorValue * (5.0 / 1023.0);

Наконец, вам нужно распечатать эту информацию в окне последовательного порта. Вы можете сделать это с помощью команды Serial.println () в последней строке кода -

Serial.println(voltage)

Теперь откройте Serial Monitor в среде Arduino IDE, щелкнув значок справа от верхней зеленой полосы или нажав Ctrl + Shift + M.

Результат

Вы увидите постоянный поток чисел от 0,0 до 5,0. При повороте потенциометра значения будут изменяться в соответствии с напряжением на выводе A0.

В этом примере показано, как считать аналоговый вход на аналоговом выводе 0, преобразовать значения из analogRead () в напряжение и распечатать их на последовательном мониторе программного обеспечения Arduino (IDE).

Необходимые компоненты

Вам понадобятся следующие компоненты -

• 1 × Макетная плата
• 1 × Arduino Uno R3
• Переменный резистор 1 × 5 кОм (потенциометр)
• 2 × Джемпер
• 8 светодиодов или вы можете использовать (светодиодная гистограмма, как показано на изображении ниже)

Процедура

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

Эскиз

Откройте программу Arduino IDE на вашем компьютере. Кодирование на языке Arduino будет управлять вашей схемой. Откройте новый файл эскиза, нажав кнопку «Создать».

10-сегментная светодиодная гистограмма

Эти 10-сегментные светодиоды в виде гистограмм имеют множество применений. Благодаря компактным размерам и простоте подключения они легко могут быть изготовлены как прототипы, так и готовые изделия. По сути, они представляют собой 10 отдельных синих светодиодов, размещенных вместе, каждый с индивидуальным подключением анода и катода.

Они также доступны в желтом, красном и зеленом цветах.

Note- Расположение выводов на этих гистограммах может отличаться от того, что указано в таблице данных. Поворот устройства на 180 градусов исправит изменение, сделав штифт 11 первым штифтом на линии.

Код Arduino

/*
   LED bar graph
   Turns on a series of LEDs based on the value of an analog sensor. 
   This is a simple way to make a bar graph display. 
   Though this graph uses 8LEDs, you can use any number by
      changing the LED count and the pins in the array.
   This method can be used to control any series of digital
      outputs that depends on an analog input.
*/

// these constants won't change:
const int analogPin = A0; // the pin that the potentiometer is attached to
const int ledCount = 8; // the number of LEDs in the bar graph
int ledPins[] = {2, 3, 4, 5, 6, 7, 8, 9}; // an array of pin numbers to which LEDs are attached

void setup() {
   // loop over the pin array and set them all to output:
   for (int thisLed = 0; thisLed < ledCount; thisLed++) {
      pinMode(ledPins[thisLed], OUTPUT);
   }
}

void loop() {
   // read the potentiometer:
   int sensorReading = analogRead(analogPin);
   // map the result to a range from 0 to the number of LEDs:
   int ledLevel = map(sensorReading, 0, 1023, 0, ledCount);
   // loop over the LED array:
   for (int thisLed = 0; thisLed < ledCount; thisLed++) {
      // if the array element's index is less than ledLevel,
      // turn the pin for this element on:
      if (thisLed < ledLevel) {
         digitalWrite(ledPins[thisLed], HIGH);
      }else { // turn off all pins higher than the ledLevel:
         digitalWrite(ledPins[thisLed], LOW);
      }
   }
}

Код для примечания

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

Результат

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

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

Warning - Когда вы используете Keyboard.print()команда, Arduino берет на себя клавиатуру вашего компьютера. Чтобы не потерять контроль над своим компьютером при выполнении скетча с этой функцией, настройте надежную систему управления перед вызовом Keyboard.print (). Этот эскиз предназначен для отправки команды с клавиатуры только после того, как штифт был прижат к земле.

Необходимые компоненты

Вам понадобятся следующие компоненты -

• 1 × Макетная плата
• 1 × плата Arduino Leonardo, Micro или Due
• 1 × кнопка
• 1 × Джемпер

Процедура

Следуйте принципиальной схеме и подключите компоненты на макетной плате, как показано на рисунке ниже.

Эскиз

Откройте программу Arduino IDE на вашем компьютере. Кодирование на языке Arduino будет управлять вашей схемой. Откройте новый файл эскиза, нажав кнопку «Создать».

Для этого примера вам нужно использовать Arduino IDE 1.6.7.

Note- Вы должны включить библиотеку клавиатуры в файл библиотеки Arduino. Скопируйте и вставьте файл библиотеки клавиатуры в файл с именами библиотек (выделены), как показано на следующем снимке экрана.

Код Arduino

/*
   Keyboard logout
   This sketch demonstrates the Keyboard library.
   When you connect pin 2 to ground, it performs a logout.
   It uses keyboard combinations to do this, as follows:
   On Windows, CTRL-ALT-DEL followed by ALT-l
   On Ubuntu, CTRL-ALT-DEL, and ENTER
   On OSX, CMD-SHIFT-q
   To wake: Spacebar.
   Circuit:
   * Arduino Leonardo or Micro
   * wire to connect D2 to ground.
*/

#define OSX 0
#define WINDOWS 1
#define UBUNTU 2

#include "Keyboard.h"

// change this to match your platform:
int platform = WINDOWS;

void setup() {
   // make pin 2 an input and turn on the
   // pullup resistor so it goes high unless
   // connected to ground:
   
   pinMode(2, INPUT_PULLUP);
   Keyboard.begin();
}

void loop() {
   while (digitalRead(2) == HIGH) {
      // do nothing until pin 2 goes low
      delay(500);
   }
   
   delay(1000);
   
   switch (platform) {
      case OSX:
      Keyboard.press(KEY_LEFT_GUI);
	  
      // Shift-Q logs out:
      Keyboard.press(KEY_LEFT_SHIFT);
      Keyboard.press('Q');
      delay(100);
	  
      // enter:
      Keyboard.write(KEY_RETURN);
      break;
	  
      case WINDOWS:
      // CTRL-ALT-DEL:
      Keyboard.press(KEY_LEFT_CTRL);
      Keyboard.press(KEY_LEFT_ALT);
      Keyboard.press(KEY_DELETE);
      delay(100);
      Keyboard.releaseAll();
	  
      //ALT-l:
      delay(2000);
      Keyboard.press(KEY_LEFT_ALT);
      Keyboard.press('l');
      Keyboard.releaseAll();
      break;
	  
      case UBUNTU:
      // CTRL-ALT-DEL:
      Keyboard.press(KEY_LEFT_CTRL);
      Keyboard.press(KEY_LEFT_ALT);
      Keyboard.press(KEY_DELETE);
	  
      delay(1000);
      Keyboard.releaseAll();
	  
      // Enter to confirm logout:
      Keyboard.write(KEY_RETURN);
      break;
   }
   
   // do nothing:
   while (true);
}

Keyboard.releaseAll();

   // enter:
      Keyboard.write(KEY_RETURN);
      break;
      case WINDOWS:
	  
   // CTRL-ALT-DEL:
      Keyboard.press(KEY_LEFT_CTRL);
      Keyboard.press(KEY_LEFT_ALT);
      Keyboard.press(KEY_DELETE);
      delay(100);
      Keyboard.releaseAll();
	  
   //ALT-l:
      delay(2000);
      Keyboard.press(KEY_LEFT_ALT);
      Keyboard.press('l');
      Keyboard.releaseAll();
      break;
	  
   case UBUNTU:
      // CTRL-ALT-DEL:
      Keyboard.press(KEY_LEFT_CTRL);
      Keyboard.press(KEY_LEFT_ALT);
      Keyboard.press(KEY_DELETE);
      delay(1000);
      Keyboard.releaseAll();
	  
      // Enter to confirm logout:
      Keyboard.write(KEY_RETURN);
      break;
   }
   
// do nothing:
   while (true);
}

Код для примечания

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

Во время работы скетча нажатие кнопки подключит контакт 2 к земле, и плата отправит последовательность выхода из системы на ПК, подключенный через USB.

Результат

Когда вы подключаете контакт 2 к земле, он выполняет операцию выхода.

Для выхода из системы используются следующие комбинации клавиш:

• На Windows, CTRL-ALT-DEL, за которым следует ALT-l

• На Ubuntu, CTRL-ALT-DEL и ENTER

• На OSX, CMD-SHIFT-q

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

Warning - Когда вы используете Keyboard.print()команда, Arduino берет на себя клавиатуру вашего компьютера. Чтобы не потерять контроль над компьютером во время выполнения скетча с этой функцией, настройте надежную систему управления перед тем, как позвонитьKeyboard.print(). Этот эскиз включает кнопку для переключения клавиатуры, так что она запускается только после нажатия кнопки.

Необходимые компоненты

Вам понадобятся следующие компоненты -

• 1 × Макетная плата
• 1 × плата Arduino Leonardo, Micro или Due
• 1 × кнопка мгновенного действия
• Резистор 1 × 10 кОм

Процедура

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

Эскиз

Откройте программу Arduino IDE на вашем компьютере. Кодирование на языке Arduino будет управлять вашей схемой. Откройте новый файл эскиза, нажав кнопку «Создать».

Код Arduino

/*
   Keyboard Message test For the Arduino Leonardo and Micro,
      Sends a text string when a button is pressed.
   The circuit:
   * pushbutton attached from pin 4 to +5V
   * 10-kilohm resistor attached from pin 4 to ground
*/

#include "Keyboard.h"
const int buttonPin = 4; // input pin for pushbutton
int previousButtonState = HIGH; // for checking the state of a pushButton
int counter = 0; // button push counter

void setup() {
   pinMode(buttonPin, INPUT); // make the pushButton pin an input:
   Keyboard.begin(); // initialize control over the keyboard:
}

void loop() {
   int buttonState = digitalRead(buttonPin); // read the pushbutton:
   if ((buttonState != previousButtonState)&& (buttonState == HIGH)) // and it's currently pressed: {
      // increment the button counter
      counter++;
      // type out a message
      Keyboard.print("You pressed the button ");
      Keyboard.print(counter);
      Keyboard.println(" times.");
   }
   // save the current button state for comparison next time:
   previousButtonState = buttonState;
}

Код для примечания

Подключите одну клемму кнопки к контакту 4 на Arduino. Подключите другой контакт к 5V. Используйте резистор в качестве понижающего, обеспечивая ссылку на землю, подключив его от контакта 4 к земле.

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

Результат

Используя любой текстовый редактор, он будет отображать текст, отправленный через Arduino.

Используя библиотеку Mouse, вы можете управлять экранным курсором компьютера с помощью Arduino Leonardo, Micro или Due.

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

Каждый раз, когда нажимается одна из кнопок направления, Arduino перемещает мышь, сопоставляя ВЫСОКИЙ вход с диапазоном 5 в соответствующем направлении.

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

Необходимые компоненты

Вам понадобятся следующие компоненты -

• 1 × Макетная плата
• 1 × плата Arduino Leonardo, Micro или Due
• Резистор 5 × 10 кОм
• 5 кнопок мгновенного действия

Процедура

Следуйте принципиальной схеме и подключите компоненты на макетной плате, как показано на рисунке ниже.

Эскиз

Откройте программу Arduino IDE на вашем компьютере. Кодирование на языке Arduino будет управлять вашей схемой. Откройте новый файл эскиза, нажав кнопку «Создать».

Для этого примера вам нужно использовать Arduino IDE 1.6.7.

Код Arduino

/*
   Button Mouse Control
   For Leonardo and Due boards only .Controls the mouse from 
   five pushbuttons on an Arduino Leonardo, Micro or Due.
   Hardware:
   * 5 pushbuttons attached to D2, D3, D4, D5, D6
   The mouse movement is always relative. This sketch reads
   four pushbuttons, and uses them to set the movement of the mouse.
   WARNING: When you use the Mouse.move() command, the Arduino takes
   over your mouse! Make sure you have control before you use the mouse commands.
*/

#include "Mouse.h"
// set pin numbers for the five buttons:
const int upButton = 2;
const int downButton = 3;
const int leftButton = 4;
const int rightButton = 5;
const int mouseButton = 6;
int range = 5; // output range of X or Y movement; affects movement speed
int responseDelay = 10; // response delay of the mouse, in ms

void setup() {
   // initialize the buttons' inputs:
   pinMode(upButton, INPUT);
   pinMode(downButton, INPUT);
   pinMode(leftButton, INPUT);
   pinMode(rightButton, INPUT);
   pinMode(mouseButton, INPUT);
   // initialize mouse control:
   Mouse.begin();
}

void loop() {
   // read the buttons:
   int upState = digitalRead(upButton);
   int downState = digitalRead(downButton);
   int rightState = digitalRead(rightButton);
   int leftState = digitalRead(leftButton);
   int clickState = digitalRead(mouseButton);
   // calculate the movement distance based on the button states:
   int xDistance = (leftState - rightState) * range;
   int yDistance = (upState - downState) * range;
   // if X or Y is non-zero, move:
   if ((xDistance != 0) || (yDistance != 0)) {
      Mouse.move(xDistance, yDistance, 0);
   }

   // if the mouse button is pressed:
   if (clickState == HIGH) {
      // if the mouse is not pressed, press it:
      if (!Mouse.isPressed(MOUSE_LEFT)) {
         Mouse.press(MOUSE_LEFT);
      }
   } else {                           // else the mouse button is not pressed:
      // if the mouse is pressed, release it:
      if (Mouse.isPressed(MOUSE_LEFT)) {
         Mouse.release(MOUSE_LEFT);
      }
   }
   // a delay so the mouse does not move too fast:
   delay(responseDelay);
}

Код для примечания

Подключите доску к компьютеру с помощью кабеля micro-USB. Кнопки подключены к цифровым входам от контактов 2 до 6. Убедитесь, что вы используете понижающие резисторы 10 кОм.

В этом примере прослушивается байт, поступающий из последовательного порта. При получении плата отправляет сигнал о нажатии клавиши компьютеру. Отправленное нажатие клавиши на единицу больше полученного, поэтому, если вы отправите «a» от монитора последовательного порта, вы получите «b» от платы, подключенной к компьютеру. «1» вернет «2» и так далее.

Warning - Когда вы используете Keyboard.print()команды, плата Leonardo, Micro или Due берет на себя клавиатуру вашего компьютера. Чтобы не потерять контроль над своим компьютером при выполнении скетча с этой функцией, настройте надежную систему управления перед вызовом Keyboard.print (). Этот эскиз предназначен для отправки команды клавиатуры только после того, как плата получила байт через последовательный порт.

Необходимые компоненты

Вам понадобятся следующие компоненты -

• 1 × плата Arduino Leonardo, Micro или Due

Процедура

Просто подключите плату к компьютеру с помощью USB-кабеля.

Эскиз

Откройте программу Arduino IDE на вашем компьютере. Кодирование на языке Arduino будет управлять вашей схемой. Откройте новый файл эскиза, нажав кнопку «Создать».

Notes- Вы должны включить библиотеку клавиатуры в файл библиотеки Arduino. Скопируйте и вставьте файл библиотеки клавиатуры в файл с именем «библиотеки», выделенным желтым цветом.

Код Arduino

/*
   Keyboard test
   For the Arduino Leonardo, Micro or Due Reads
      a byte from the serial port, sends a keystroke back. 
   The sent keystroke is one higher than what's received, e.g. if you send a, you get b, send
      A you get B, and so forth.
   The circuit:
   * none
*/

#include "Keyboard.h"

void setup() {
   // open the serial port:
   Serial.begin(9600);
   // initialize control over the keyboard:
   Keyboard.begin();
}

void loop() {
   // check for incoming serial data:
   if (Serial.available() > 0) {
      // read incoming serial data:
      char inChar = Serial.read();
      // Type the next ASCII value from what you received:
      Keyboard.write(inChar + 1);
   }
}

Код для примечания

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

Результат

Плата ответит нажатием клавиши, которое на один номер больше на последовательном мониторе Arduino IDE, когда вы отправляете байт.

В этом разделе мы узнаем, как подключить нашу плату Arduino к различным датчикам. Мы обсудим следующие датчики -

• Датчик влажности (DHT22)
• Датчик температуры (LM35)
• Датчик детектора воды (Simple Water Trigger)
• ПИР-ДАТЧИК
• УЛЬТРАЗВУКОВЫЙ ДАТЧИК
• GPS

Датчик влажности (DHT22)

DHT-22 (также называемый AM2302) - это датчик относительной влажности и температуры с цифровым выходом. Он использует емкостной датчик влажности и термистор для измерения окружающего воздуха и отправляет цифровой сигнал на вывод данных.

В этом примере вы узнаете, как использовать этот датчик с Arduino UNO. Комнатная температура и влажность будут распечатаны на серийном мониторе.

Датчик DHT-22

Подключения просты. Первый вывод слева для питания 3-5 В, второй вывод для ввода данных и крайний правый вывод для заземления.

Технические подробности

• Power - 3-5В

• Max Current - 2,5 мА

• Humidity - 0-100%, точность 2-5%

• Temperature - от 40 до 80 ° C, точность ± 0,5 ° C

Необходимые компоненты

Вам понадобятся следующие компоненты -

• 1 × Макетная плата
• 1 × Arduino Uno R3
• 1 × DHT22
• Резистор 1 × 10 кОм

Процедура

Следуйте принципиальной схеме и подключите компоненты на макетной плате, как показано на рисунке ниже.

Эскиз

Откройте программу Arduino IDE на вашем компьютере. Кодирование на языке Arduino будет управлять вашей схемой. Откройте новый файл эскиза, нажав кнопку «Создать».

Код Arduino

// Example testing sketch for various DHT humidity/temperature sensors

#include "DHT.h"
#define DHTPIN 2 // what digital pin we're connected to
// Uncomment whatever type you're using!
//#define DHTTYPE DHT11 // DHT 11
#define DHTTYPE DHT22 // DHT 22 (AM2302), AM2321
//#define DHTTYPE DHT21 // DHT 21 (AM2301)
// Connect pin 1 (on the left) of the sensor to +5V
// NOTE: If using a board with 3.3V logic like an Arduino Due connect pin 1
// to 3.3V instead of 5V!
// Connect pin 2 of the sensor to whatever your DHTPIN is
// Connect pin 4 (on the right) of the sensor to GROUND
// Connect a 10K resistor from pin 2 (data) to pin 1 (power) of the sensor
// Initialize DHT sensor.
// Note that older versions of this library took an optional third parameter to
// tweak the timings for faster processors. This parameter is no longer needed
// as the current DHT reading algorithm adjusts itself to work on faster procs.
DHT dht(DHTPIN, DHTTYPE);

void setup() {
   Serial.begin(9600);
   Serial.println("DHTxx test!");
   dht.begin();
}

void loop() {
   delay(2000); // Wait a few seconds between measurements
   float h = dht.readHumidity();
   // Reading temperature or humidity takes about 250 milliseconds!
   float t = dht.readTemperature();
   // Read temperature as Celsius (the default)
   float f = dht.readTemperature(true);
   // Read temperature as Fahrenheit (isFahrenheit = true)
   // Check if any reads failed and exit early (to try again).
   if (isnan(h) || isnan(t) || isnan(f)) {
      Serial.println("Failed to read from DHT sensor!");
      return;
   }
   
   // Compute heat index in Fahrenheit (the default)
   float hif = dht.computeHeatIndex(f, h);
   // Compute heat index in Celsius (isFahreheit = false)
   float hic = dht.computeHeatIndex(t, h, false);
   Serial.print ("Humidity: ");
   Serial.print (h);
   Serial.print (" %\t");
   Serial.print ("Temperature: ");
   Serial.print (t);
   Serial.print (" *C ");
   Serial.print (f);
   Serial.print (" *F\t");
   Serial.print ("Heat index: ");
   Serial.print (hic);
   Serial.print (" *C ");
   Serial.print (hif);
   Serial.println (" *F");
}

Код для примечания

Датчик DHT22 имеет четыре контакта (V _cc , DATA, NC, GND), которые подключаются к плате следующим образом:

• Вывод DATA на вывод Arduino номер 2
• _Вывод V _cc на 5 В на плате Arduino
• Вывод GND на землю платы Arduino
• Нам нужно подключить резистор 10 кОм (подтягивающий резистор) между DATA и выводом V _cc.

После подключения оборудования вам необходимо добавить библиотеку DHT22 в файл библиотеки Arduino, как описано ранее.

Результат

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

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

Устройство LM35 имеет преимущество перед линейными датчиками температуры, откалиброванными в градусах Кельвина, поскольку пользователю не требуется вычитать большое постоянное напряжение из выходного сигнала, чтобы получить удобное масштабирование по шкале Цельсия. Устройство LM35 не требует какой-либо внешней калибровки или подстройки для обеспечения типичной точности ± ° C при комнатной температуре и ± ° C во всем диапазоне температур от -55 ° C до 150 ° C.

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

• Калибровка напрямую по Цельсию (Цельсию)
• Линейный масштабный коэффициент + 10 мВ / ° C
• Гарантированная точность 0,5 ° C (при 25 ° C)
• Рассчитан на полный диапазон от −55 ° C до 150 ° C
• Подходит для удаленных приложений

Необходимые компоненты

Вам понадобятся следующие компоненты -

• 1 × Макетная плата
• 1 × Arduino Uno R3
• 1 × датчик LM35

Процедура

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

Эскиз

Откройте программу Arduino IDE на вашем компьютере. Кодирование на языке Arduino будет управлять вашей схемой. Откройте новый файл эскиза, нажав кнопку «Создать».

Код Arduino

float temp;
int tempPin = 0;

void setup() {
   Serial.begin(9600);
}

void loop() {
   temp = analogRead(tempPin);
   // read analog volt from sensor and save to variable temp
   temp = temp * 0.48828125;
   // convert the analog volt to its temperature equivalent
   Serial.print("TEMPERATURE = ");
   Serial.print(temp); // display temperature value
   Serial.print("*C");
   Serial.println();
   delay(1000); // update sensor reading each one second
}

Код для примечания

Датчик LM35 имеет три вывода - V _s , V _out и GND. Подключим датчик следующим образом -

• Подключите + V _s к + 5v на вашем Arduino борту.
• Подключите _выход V к Analog0 или A0 на плате Arduino.
• Подключите GND к GND на Arduino.

Аналого-цифровой преобразователь (АЦП) преобразует аналоговые значения в цифровой аппроксимации, основанной на формуле АЦП Value = образец * 1024 / опорное напряжение (+5 В). Таким образом, со ссылкой на +5 вольт, цифровое приближение будет равно входное напряжение * 205.

Результат

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

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

Подключение датчика воды к Arduino - отличный способ обнаружить утечку, разлив, наводнение, дождь и т. Д. Его можно использовать для определения наличия, уровня, объема и / или отсутствия воды. Хотя это можно использовать, чтобы напомнить вам о необходимости поливать растения, для этого есть лучший датчик Grove. Датчик имеет массив открытых следов, которые показывают НИЗКИЙ уровень при обнаружении воды.

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

Необходимые компоненты

Вам понадобятся следующие компоненты -

• 1 × Макетная плата
• 1 × Arduino Uno R3
• 1 × датчик воды
• 1 × светодиод
• Резистор 1 × 330 Ом

Процедура

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

Эскиз

Откройте программу Arduino IDE на вашем компьютере. Кодирование на языке Arduino будет управлять вашей схемой. Откройте новый файл эскиза, нажав кнопку «Создать».

Код Arduino

#define Grove_Water_Sensor 8 // Attach Water sensor to Arduino Digital Pin 8
#define LED 9 // Attach an LED to Digital Pin 9 (or use onboard LED)

void setup() {
   pinMode(Grove_Water_Sensor, INPUT); // The Water Sensor is an Input
   pinMode(LED, OUTPUT); // The LED is an Output
}

void loop() {
   /* The water sensor will switch LOW when water is detected.
   Get the Arduino to illuminate the LED and activate the buzzer
   when water is detected, and switch both off when no water is present */
   if( digitalRead(Grove_Water_Sensor) == LOW) {
      digitalWrite(LED,HIGH);
   }else {
      digitalWrite(LED,LOW);
   }
}

Код для примечания

Датчик воды имеет три контакта - S, V _out (+) и GND (-). Подключите датчик следующим образом -

• Подключите + V _s к + 5v на вашем Arduino борту.
• Подключите S к цифровому контакту 8 на плате Arduino.
• Подключите GND к GND на Arduino.
• Подключите светодиод к цифровому контакту 9 на плате Arduino.

Когда датчик обнаруживает воду, контакт 8 на Arduino становится LOW, а затем светодиод на Arduino включается.

Результат

Вы увидите, что светодиодный индикатор загорится, когда датчик обнаружит воду.

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

Ниже приведены преимущества датчиков PIR:

• Маленький размер
• Широкий диапазон линз
• Простой интерфейс
• Inexpensive
• Low-power
• Легко использовать
• Не изнашиваются

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

PIR имеют регулируемые настройки и имеют разъем, установленный на 3-контактных площадках заземления / выхода / питания.

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

Необходимые компоненты

Вам понадобятся следующие компоненты -

• 1 × Макетная плата
• 1 × Arduino Uno R3
• 1 × датчик PIR (MQ3)

Процедура

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

Эскиз

Откройте программу Arduino IDE на вашем компьютере. Кодирование на языке Arduino будет управлять вашей схемой. Откройте новый файл эскиза, нажав кнопку «Создать».

Код Arduino

#define pirPin 2
int calibrationTime = 30;
long unsigned int lowIn;
long unsigned int pause = 5000;
boolean lockLow = true;
boolean takeLowTime;
int PIRValue = 0;

void setup() {
   Serial.begin(9600);
   pinMode(pirPin, INPUT);
}

void loop() {
   PIRSensor();
}

void PIRSensor() {
   if(digitalRead(pirPin) == HIGH) {
      if(lockLow) {
         PIRValue = 1;
         lockLow = false;
         Serial.println("Motion detected.");
         delay(50);
      }
      takeLowTime = true;
   }
   if(digitalRead(pirPin) == LOW) {
      if(takeLowTime){
         lowIn = millis();takeLowTime = false;
      }
      if(!lockLow && millis() - lowIn > pause) {
         PIRValue = 0;
         lockLow = true;
         Serial.println("Motion ended.");
         delay(50);
      }
   }
}

Код для примечания

Датчик PIR имеет три контакта - V _cc , OUT и GND. Подключите датчик следующим образом -

• Подключите + V _cc к + 5v на плате Arduino.
• Подключите OUT к цифровому выводу 2 на плате Arduino.
• Подключите GND к GND на Arduino.

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

Как только датчик обнаруживает любое движение, Arduino отправляет сообщение через последовательный порт, чтобы сообщить, что движение обнаружено. Движение датчика PIR будет задерживаться на определенное время, чтобы проверить, есть ли новое движение. Если движение не обнаружено, Arduino отправит новое сообщение о том, что движение закончилось.

Результат

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

Ультразвуковой датчик HC-SR04 использует SONAR для определения расстояния до объекта, как это делают летучие мыши. Он предлагает отличное бесконтактное определение дальности с высокой точностью и стабильными показаниями в удобном корпусе от 2 см до 400 см или от 1 дюйма до 13 футов.

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

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

• Электропитание - +5 В постоянного тока
• Ток покоя - <2 мА
• Рабочий ток - 15 мА
• Эффективный угол - <15 °
• Расстояние охвата - 2 см - 400 см / 1 ″ - 13 футов
• Разрешение - 0,3 см
• Угол измерения - 30 градусов

Необходимые компоненты

Вам понадобятся следующие компоненты -

• 1 × Макетная плата
• 1 × Arduino Uno R3
• 1 × УЛЬТРАЗВУКОВЫЙ датчик (HC-SR04)

Процедура

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

Эскиз

Откройте программу Arduino IDE на вашем компьютере. Кодирование на языке Arduino будет управлять вашей схемой. Откройте новый файл эскиза, нажав кнопку «Создать».

Код Arduino

const int pingPin = 7; // Trigger Pin of Ultrasonic Sensor
const int echoPin = 6; // Echo Pin of Ultrasonic Sensor

void setup() {
   Serial.begin(9600); // Starting Serial Terminal
}

void loop() {
   long duration, inches, cm;
   pinMode(pingPin, OUTPUT);
   digitalWrite(pingPin, LOW);
   delayMicroseconds(2);
   digitalWrite(pingPin, HIGH);
   delayMicroseconds(10);
   digitalWrite(pingPin, LOW);
   pinMode(echoPin, INPUT);
   duration = pulseIn(echoPin, HIGH);
   inches = microsecondsToInches(duration);
   cm = microsecondsToCentimeters(duration);
   Serial.print(inches);
   Serial.print("in, ");
   Serial.print(cm);
   Serial.print("cm");
   Serial.println();
   delay(100);
}

long microsecondsToInches(long microseconds) {
   return microseconds / 74 / 2;
}

long microsecondsToCentimeters(long microseconds) {
   return microseconds / 29 / 2;
}

Код для примечания

Ультразвуковой датчик имеет четыре контакта - + 5 В, триггер, эхо и заземление, подключенных следующим образом:

• Подключите вывод + 5V к + 5V на плате Arduino.
• Подключите триггер к цифровому контакту 7 на плате Arduino.
• Подключите Echo к цифровому выводу 6 на плате Arduino.
• Подключите GND к GND на Arduino.

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

Результат

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

Кнопки или переключатели соединяют две разомкнутые клеммы в цепь. В этом примере светодиод на контакте 2 включается при нажатии кнопочного переключателя, подключенного к контакту 8.

Понижающий резистор

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

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

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

Необходимые компоненты

Вам понадобятся следующие компоненты -

• 1 × плата Arduino UNO
• Резистор 1 × 330 Ом
• 1 × 4,7 кОм резистор (понижающий)
• 1 × светодиод

Процедура

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

Эскиз

Откройте программу Arduino IDE на вашем компьютере. Кодирование на языке Arduino будет управлять вашей схемой. Откройте новый файл эскиза, нажав кнопку «Создать».

Код Arduino

// constants won't change. They're used here to
// set pin numbers:
const int buttonPin = 8; // the number of the pushbutton pin
const int ledPin = 2; // the number of the LED pin
// variables will change:
int buttonState = 0; // variable for reading the pushbutton status

void setup() {
   // initialize the LED pin as an output:
   pinMode(ledPin, OUTPUT);
   // initialize the pushbutton pin as an input:
   pinMode(buttonPin, INPUT);
}

void loop() {
   // read the state of the pushbutton value:
   buttonState = digitalRead(buttonPin);
   // check if the pushbutton is pressed.
   // if it is, the buttonState is HIGH:
   if (buttonState == HIGH) {
      // turn LED on:
      digitalWrite(ledPin, HIGH);
   } else {
      // turn LED off:
      digitalWrite(ledPin, LOW);
   }
}

Код для примечания

Когда переключатель разомкнут (кнопка не нажата), нет связи между двумя выводами кнопки, поэтому контакт подключен к земле (через понижающий резистор), и мы читаем НИЗКИЙ. Когда переключатель замкнут (кнопка нажата), он устанавливает соединение между двумя своими выводами, подключая контакт к 5 вольт, так что мы читаем ВЫСОКИЙ.

Результат

Светодиод включается при нажатии кнопки и выключается при отпускании.

В этой главе мы будем сопоставлять различные типы двигателей с платой Arduino (UNO) и покажем вам, как подключить двигатель и управлять им с вашей платы.

Есть три разных типа двигателей -

• Двигатель постоянного тока
• Серводвигатель
• Шаговый двигатель

Двигатель постоянного тока (двигатель постоянного тока) является наиболее распространенным типом двигателя. Двигатели постоянного тока обычно имеют только два вывода, один положительный и один отрицательный. Если вы подключите эти два вывода напрямую к батарее, двигатель будет вращаться. Если поменять местами провода, двигатель будет вращаться в противоположном направлении.

Warning- Не управляйте двигателем напрямую от контактов платы Arduino. Это может повредить доску. Используйте схему драйвера или IC.

Мы разделим эту главу на три части:

• Просто заставь свой мотор крутиться
• Скорость двигателя управления
• Управление направлением вращения двигателя постоянного тока

Необходимые компоненты

Вам понадобятся следующие компоненты -

• 1x плата Arduino UNO
• 1x PN2222 транзистор
• 1x маленький двигатель постоянного тока 6 В
• 1x 1N4001 диод
• 1x 270 Ом резистор

Процедура

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

Меры предосторожности

При подключении соблюдайте следующие меры предосторожности.

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

• Во-вторых, полосатый конец диода должен быть направлен к линии питания + 5В, как показано на рисунке.

Код Spin ControlArduino

int motorPin = 3;

void setup() {

}

void loop() {
   digitalWrite(motorPin, HIGH);
}

Код для примечания

Транзистор действует как переключатель, управляя мощностью двигателя. Вывод 3 Arduino используется для включения и выключения транзистора, и в эскизе ему присвоено имя motorPin.

Результат

Двигатель будет вращаться на полной скорости, когда на контакте 3 Arduino появится высокий уровень.

Контроль скорости двигателя

Ниже представлена ​​принципиальная схема двигателя постоянного тока, подключенного к плате Arduino.

Код Arduino

int motorPin = 9;

void setup() {
   pinMode(motorPin, OUTPUT);
   Serial.begin(9600);
   while (! Serial);
   Serial.println("Speed 0 to 255");
}

void loop() {
   if (Serial.available()) {
      int speed = Serial.parseInt();
      if (speed >= 0 && speed <= 255) {
         analogWrite(motorPin, speed);
      }
   }
}

Код для примечания

Транзистор действует как переключатель, управляя мощностью двигателя. Вывод 3 Arduino используется для включения и выключения транзистора, и в эскизе ему присвоено имя motorPin.

Когда программа запускается, она предлагает вам ввести значения для управления скоростью двигателя. Вам необходимо ввести значение от 0 до 255 в Serial Monitor.

В функции 'loop' команда 'Serial.parseInt' используется для чтения числа, введенного как текст в Serial Monitor, и преобразования его в 'int'. Вы можете ввести здесь любой номер. Оператор if в следующей строке просто выполняет аналоговую запись с этим числом, если число находится в диапазоне от 0 до 255.

Результат

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

Контроль направления вращения

Чтобы контролировать направление вращения двигателя постоянного тока, не меняя местами провода, вы можете использовать схему, называемую H-Bridge. H-мост - это электронная схема, которая может управлять двигателем в обоих направлениях. H-мосты используются во многих различных приложениях. Одно из наиболее распространенных приложений - управление двигателями роботов. Он называется H-мостом, потому что он использует четыре транзистора, соединенных таким образом, что схематическая диаграмма выглядит как «H».

Мы будем использовать здесь микросхему H-Bridge L298. L298 может управлять скоростью и направлением двигателей постоянного тока и шаговых двигателей, а также может управлять двумя двигателями одновременно. Его номинальный ток составляет 2А для каждого двигателя. Однако при таких токах вам потребуется использовать радиаторы.

Необходимые компоненты

Вам понадобятся следующие компоненты -

• 1 × L298 мост IC
• 1 × двигатель постоянного тока
• 1 × Arduino UNO
• 1 × макетная плата
• 10 × перемычки

Процедура

Ниже приведена принципиальная схема интерфейса двигателя постоянного тока с платой Arduino Uno.

На приведенной выше схеме показано, как подключить микросхему L298 для управления двумя двигателями. Для каждого двигателя имеется три входных контакта: Input1 (IN1), Input2 (IN2) и Enable1 (EN1) для Motor1 и Input3, Input4 и Enable2 для Motor2.

Поскольку в этом примере мы будем управлять только одним двигателем, мы подключим Arduino к IN1 (контакт 5), IN2 (контакт 7) и Enable1 (контакт 6) микросхемы L298. Контакты 5 и 7 являются цифровыми, т.е. входами ВКЛ или ВЫКЛ, а контакту 6 требуется сигнал с широтно-импульсной модуляцией (ШИМ) для управления скоростью двигателя.

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

В 1	IN2	Моторное поведение
		Тормоз
1		ВПЕРЕД
	1	НАЗАД
1	1	Тормоз

Контакт IN1 микросхемы L298 подключен к контакту 8 Arduino, а IN2 подключен к контакту 9. Эти два цифровых контакта Arduino управляют направлением двигателя. Контакт EN A микросхемы подключен к контакту 2 PWM Arduino. Это будет контролировать скорость двигателя.

Чтобы установить значения контактов 8 и 9 Arduino, мы использовали функцию digitalWrite (), а чтобы установить значение контакта 2, мы должны использовать функцию analogWrite ().

Шаги подключения

• Подключите 5 В и землю IC к 5 В и земле Arduino соответственно.
• Подключите двигатель к контактам 2 и 3 микросхемы.
• Подключите IN1 микросхемы к контакту 8 Arduino.
• Подключите IN2 микросхемы к выводу 9 Arduino.
• Подключите EN1 IC к контакту 2 Arduino.
• Подключите SENS A контакт IC к земле.
• Подключите Arduino с помощью USB-кабеля Arduino и загрузите программу в Arduino с помощью программного обеспечения Arduino IDE.
• Подайте питание на плату Arduino, используя блок питания, аккумулятор или USB-кабель.

Код Arduino

const int pwm = 2 ; //initializing pin 2 as pwm
const int in_1 = 8 ;
const int in_2 = 9 ;
//For providing logic to L298 IC to choose the direction of the DC motor

void setup() {
   pinMode(pwm,OUTPUT) ; //we have to set PWM pin as output
   pinMode(in_1,OUTPUT) ; //Logic pins are also set as output
   pinMode(in_2,OUTPUT) ;
}

void loop() {
   //For Clock wise motion , in_1 = High , in_2 = Low
   digitalWrite(in_1,HIGH) ;
   digitalWrite(in_2,LOW) ;
   analogWrite(pwm,255) ;
   /* setting pwm of the motor to 255 we can change the speed of rotation
   by changing pwm input but we are only using arduino so we are using highest
   value to driver the motor */
   //Clockwise for 3 secs
   delay(3000) ;
   //For brake
   digitalWrite(in_1,HIGH) ;
   digitalWrite(in_2,HIGH) ;
   delay(1000) ;
   //For Anti Clock-wise motion - IN_1 = LOW , IN_2 = HIGH
   digitalWrite(in_1,LOW) ;
   digitalWrite(in_2,HIGH) ;
   delay(3000) ;
   //For brake
   digitalWrite(in_1,HIGH) ;
   digitalWrite(in_2,HIGH) ;
   delay(1000) ;
}

Результат

Двигатель будет вращаться сначала по часовой стрелке (CW) в течение 3 секунд, а затем против часовой стрелки (CCW) в течение 3 секунд.

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

Сервоприводы чрезвычайно полезны в робототехнике. Двигатели небольшие, имеют встроенную схему управления и чрезвычайно мощны для своего размера. Стандартный сервопривод, такой как Futaba S-148, имеет крутящий момент 42 унции / дюйм, что достаточно для его размера. Он также потребляет мощность, пропорциональную механической нагрузке. Таким образом, слабо загруженный сервопривод не потребляет много энергии.

Внутренности серводвигателя показаны на следующем рисунке. Вы можете увидеть схему управления, двигатель, набор шестерен и корпус. Вы также можете увидеть 3 провода, которые подключаются к внешнему миру. Один для питания (+5 вольт), заземления, а белый провод - это провод управления.

Работа серводвигателя

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

Если вал находится под правильным углом, двигатель отключается. Если схема обнаруживает, что угол неправильный, она поворачивает двигатель до желаемого угла. Выходной вал сервопривода может вращаться примерно на 180 градусов. Обычно он находится в диапазоне 210 градусов, однако он варьируется в зависимости от производителя. Обычный сервопривод используется для управления угловым перемещением от 0 до 180 градусов. Он механически не может поворачиваться дальше из-за механического упора, встроенного в главную ведомую шестерню.

Мощность, подаваемая на двигатель, пропорциональна расстоянию, которое ему необходимо преодолеть. Таким образом, если валу необходимо повернуться на большое расстояние, двигатель будет работать на полной скорости. Если нужно немного повернуть, двигатель будет работать с меньшей скоростью. Это называетсяproportional control.

Как сообщить об угле поворота сервопривода?

Контрольный провод используется для сообщения угла. Угол определяется длительностью импульса, подаваемого на провод управления. Это называетсяPulse Coded Modulation. Сервопривод ожидает увидеть импульс каждые 20 миллисекунд (0,02 секунды). Длина импульса определяет, как далеко вращается двигатель. Например, импульс 1,5 миллисекунды заставит двигатель повернуться в положение на 90 градусов (часто называемое нейтральным положением). Если импульс короче 1,5 миллисекунд, то двигатель повернет вал ближе к 0 градусов. Если импульс длится более 1,5 миллисекунд, вал поворачивается ближе к 180 градусам.

Необходимые компоненты

Вам понадобятся следующие компоненты -

• 1 × плата Arduino UNO
• 1 × серводвигатель
• 1 × ULN2003 вождения IC
• Резистор 1 × 10 кОм

Процедура

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

Эскиз

Откройте программу Arduino IDE на вашем компьютере. Кодирование на языке Arduino будет управлять вашей схемой. Откройте новый файл эскиза, нажав кнопку «Создать».

Код Arduino

/* Controlling a servo position using a potentiometer (variable resistor) */

#include <Servo.h>
   Servo myservo; // create servo object to control a servo
   int potpin = 0; // analog pin used to connect the potentiometer
   int val; // variable to read the value from the analog pin

void setup() {
   myservo.attach(9); // attaches the servo on pin 9 to the servo object
}

void loop() {
   val = analogRead(potpin);
   // reads the value of the potentiometer (value between 0 and 1023)
   val = map(val, 0, 1023, 0, 180);
   // scale it to use it with the servo (value between 0 and 180)
   myservo.write(val); // sets the servo position according to the scaled value
   delay(15);
}

Код для примечания

Серводвигатели имеют три вывода - питание, заземление и сигнал. Провод питания обычно красного цвета и должен быть подключен к выводу 5V на Arduino. Заземляющий провод обычно бывает черным или коричневым и должен быть подключен к одной клемме ULN2003 IC (10–16). Чтобы защитить вашу плату Arduino от повреждений, вам понадобится некоторая микросхема драйвера для этого. Здесь мы использовали ULN2003 IC для управления серводвигателем. Сигнальный контакт обычно желтого или оранжевого цвета и должен быть подключен к контакту 9 Arduino.

Подключение потенциометра

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

$$ V_ {out} = (V_ {in} \ times R_ {2}) / (R_ {1} + R_ {2}) $$

V _out - это выходной потенциал, который зависит от приложенного входного напряжения (V _in ) и резисторов (R ₁ и R ₂ ) в серии. Это означает, что ток, протекающий через R ₁ , также будет течь через R ₂ без разделения. В приведенном выше уравнении, когда значение R ₂ изменяется, V _out масштабируется соответственно входному напряжению V _in .

Как правило, потенциометр представляет собой делитель потенциала, который может масштабировать выходное напряжение схемы в зависимости от значения переменного резистора, которое масштабируется с помощью ручки. Он имеет три контакта: GND, Signal и + 5V, как показано на схеме ниже -

Результат

При изменении положения NOP кастрюли серводвигатель изменит свой угол.

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

Следовательно, шаговые двигатели производятся с шагом 12, 24, 72, 144, 180 и 200 шагов на оборот, в результате чего углы шага составляют 30, 15, 5, 2,5, 2 и 1,8 градуса на шаг. Шаговым двигателем можно управлять с обратной связью или без нее.

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

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

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

Как работает шаговый двигатель?

Обычный двигатель постоянного тока вращается только в одном направлении, тогда как шаговый двигатель может вращаться с точными приращениями.

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

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

Необходимые компоненты

Вам понадобятся следующие компоненты -

• 1 × плата Arduino UNO
• 1 × небольшой биполярный шаговый двигатель, как показано на изображении ниже
• 1 × LM298 управляющая микросхема

Процедура

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

Эскиз

Откройте программу Arduino IDE на вашем компьютере. Кодирование на языке Arduino будет управлять вашей схемой. Откройте новый файл эскиза, нажав кнопку «Создать».

Код Arduino

/* Stepper Motor Control */

#include <Stepper.h>
const int stepsPerRevolution = 90;
// change this to fit the number of steps per revolution
// for your motor
// initialize the stepper library on pins 8 through 11:
Stepper myStepper(stepsPerRevolution, 8, 9, 10, 11);

void setup() {
   // set the speed at 60 rpm:
   myStepper.setSpeed(5);
   // initialize the serial port:
   Serial.begin(9600);
}

void loop() {
   // step one revolution in one direction:
   Serial.println("clockwise");
   myStepper.step(stepsPerRevolution);
   delay(500);
   // step one revolution in the other direction:
   Serial.println("counterclockwise");
   myStepper.step(-stepsPerRevolution);
   delay(500);
}

Код для примечания

Эта программа управляет униполярным или биполярным шаговым двигателем. Двигатель подключается к цифровым контактам 8-11 Arduino.

Результат

Двигатель сделает один оборот в одном направлении, затем один оборот в другом направлении.

В этой главе мы будем использовать библиотеку тонов Arduino. Это не что иное, как библиотека Arduino, которая выдает прямоугольный сигнал определенной частоты (и 50% рабочего цикла) на любой вывод Arduino. При желании можно указать длительность, в противном случае волна продолжается до вызова функции stop (). Штырь можно подключить к пьезозуммеру или динамику для воспроизведения тонов.

Warning- Не подключайте контакт напрямую к любому аудиовходу. Напряжение значительно выше, чем стандартные линейные напряжения, и может повредить входы звуковой карты и т. Д. Вы можете использовать делитель напряжения для понижения напряжения.

Необходимые компоненты

Вам понадобятся следующие компоненты -

• 1 × 8-омный динамик
• Резистор 1 × 1 кОм
• 1 × плата Arduino UNO

Процедура

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

Эскиз

Откройте программу Arduino IDE на вашем компьютере. Кодирование на языке Arduino будет управлять вашей схемой. Откройте новый файл эскиза, нажав кнопку «Создать».

Чтобы создать файл pitches.h, либо нажмите кнопку чуть ниже значка монитора последовательного порта и выберите «Новая вкладка», либо используйте Ctrl + Shift + N.

Затем вставьте следующий код -

/*************************************************
* Public Constants
*************************************************/

#define NOTE_B0 31
#define NOTE_C1 33
#define NOTE_CS1 35
#define NOTE_D1 37
#define NOTE_DS1 39
#define NOTE_E1 41
#define NOTE_F1 44
#define NOTE_FS1 46
#define NOTE_G1 49
#define NOTE_GS1 52
#define NOTE_A1 55
#define NOTE_AS1 58
#define NOTE_B1 62
#define NOTE_C2 65
#define NOTE_CS2 69
#define NOTE_D2 73
#define NOTE_DS2 78
#define NOTE_E2 82
#define NOTE_F2 87
#define NOTE_FS2 93
#define NOTE_G2 98
#define NOTE_GS2 104
#define NOTE_A2 110
#define NOTE_AS2 117
#define NOTE_B2 123
#define NOTE_C3 131
#define NOTE_CS3 139
#define NOTE_D3 147
#define NOTE_DS3 156
#define NOTE_E3 165
#define NOTE_F3 175
#define NOTE_FS3 185
#define NOTE_G3 196
#define NOTE_GS3 208
#define NOTE_A3 220
#define NOTE_AS3 233
#define NOTE_B3 247
#define NOTE_C4 262
#define NOTE_CS4 277
#define NOTE_D4 294
#define NOTE_DS4 311
#define NOTE_E4 330
#define NOTE_F4 349
#define NOTE_FS4 370
#define NOTE_G4 392
#define NOTE_GS4 415
#define NOTE_A4 440
#define NOTE_AS4 466
#define NOTE_B4 494
#define NOTE_C5 523
#define NOTE_CS5 554
#define NOTE_D5 587
#define NOTE_DS5 622
#define NOTE_E5 659
#define NOTE_F5 698
#define NOTE_FS5 740
#define NOTE_G5 784
#define NOTE_GS5 831
#define NOTE_A5 880
#define NOTE_AS5 932
#define NOTE_B5 988
#define NOTE_C6 1047
#define NOTE_CS6 1109
#define NOTE_D6 1175
#define NOTE_DS6 1245
#define NOTE_E6 1319
#define NOTE_F6 1397
#define NOTE_FS6 1480
#define NOTE_G6 1568
#define NOTE_GS6 1661
#define NOTE_A6 1760
#define NOTE_AS6 1865
#define NOTE_B6 1976
#define NOTE_C7 2093
#define NOTE_CS7 2217
#define NOTE_D7 2349
#define NOTE_DS7 2489
#define NOTE_E7 2637
#define NOTE_F7 2794
#define NOTE_FS7 2960
#define NOTE_G7 3136
#define NOTE_GS7 3322
#define NOTE_A7 3520
#define NOTE_AS7 3729
#define NOTE_B7 3951
#define NOTE_C8 4186
#define NOTE_CS8 4435
#define NOTE_D8 4699
#define NOTE_DS8 4978

Сохраните приведенный выше код как pitches.h

Код Arduino

#include "pitches.h"
// notes in the melody:
int melody[] = {
NOTE_C4, NOTE_G3,NOTE_G3, NOTE_GS3, NOTE_G3,0, NOTE_B3, NOTE_C4};
// note durations: 4 = quarter note, 8 = eighth note, etc.:

int noteDurations[] = {
   4, 8, 8, 4,4,4,4,4 
};

void setup() {
   // iterate over the notes of the melody:
   for (int thisNote = 0; thisNote < 8; thisNote++) {
      // to calculate the note duration, take one second
      // divided by the note type.
      //e.g. quarter note = 1000 / 4, eighth note = 1000/8, etc.
      int noteDuration = 1000/noteDurations[thisNote];
      tone(8, melody[thisNote],noteDuration);
      //pause for the note's duration plus 30 ms:
      delay(noteDuration +30);
   }
}

void loop() {
   // no need to repeat the melody.
}

Код для примечания

В коде используется дополнительный файл pitches.h. Этот файл содержит все значения высоты тона для типичных нот. Например, NOTE_C4 - средний C. NOTE_FS4 - F-диез и т. Д. Эта таблица заметок была первоначально написана Бреттом Хагманом, на чьей работе была основана команда tone (). Вы можете найти его полезным, когда захотите делать музыкальные ноты.

Результат

Вы услышите музыкальные ноты, сохраненные в pitch.h. файл.

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

Note- Эти модули неизбирательны и получают изрядный шум. И передатчик, и приемник работают на общих частотах и ​​не имеют идентификаторов.

Технические характеристики модуля приемника

• Модель продукта - MX-05V
• Рабочее напряжение - DC5V
• Ток покоя - 4 мА
• Частота приема - 315 МГц
• Чувствительность приемника - -105 дБ
• Размер - 30 * 14 * 7 мм

Технические характеристики модуля передатчика

• Модель продукта - MX-FS-03V
• Дальность пуска - 20-200 метров (разное напряжение, разные результаты)
• Рабочее напряжение - 3,5-12 В
• Размеры - 19 * 19мм
• Режим работы - AM
• Скорость передачи - 4KB / S
• Мощность передачи - 10 мВт
• Частота передачи - 315 МГц
• Внешняя антенна - обычная многожильная или одножильная линия 25см
• Распиновка слева → справа - (DATA; V _CC ; GND)

Необходимые компоненты

Вам понадобятся следующие компоненты -

• 2 × плата Arduino UNO
• 1 × передатчик линии RF
• 1 × приемник связи RF

Процедура

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

Эскиз

Откройте программу Arduino IDE на вашем компьютере. Кодирование на языке Arduino будет управлять вашей схемой. Откройте новый файл эскиза, нажав кнопку «Создать».

Note- Вы должны включить библиотеку клавиатуры в файл библиотеки Arduino. Скопируйте и вставьте файл VirtualWire.lib в папку с библиотеками, как показано на скриншоте ниже.

Код Arduino для передатчика

//simple Tx on pin D12
#include <VirtualWire.h>
char *controller;

void setup() {
   pinMode(13,OUTPUT);
   vw_set_ptt_inverted(true);
   vw_set_tx_pin(12);
   vw_setup(4000);// speed of data transfer Kbps
}

void loop() {
   controller="1" ;
   vw_send((uint8_t *)controller, strlen(controller));
   vw_wait_tx(); // Wait until the whole message is gone
   digitalWrite(13,1);
   delay(2000);
   controller="0" ;
   vw_send((uint8_t *)controller, strlen(controller));
   vw_wait_tx(); // Wait until the whole message is gone
   digitalWrite(13,0);
   delay(2000);
}

Код для примечания

Это простой код. Сначала он отправит символ «1», а через две секунды отправит символ «0» и так далее.

Код Arduino для приемника

//simple Rx on pin D12
#include <VirtualWire.h>

void setup() {
   vw_set_ptt_inverted(true); // Required for DR3100
   vw_set_rx_pin(12);
   vw_setup(4000); // Bits per sec
   pinMode(5, OUTPUT);
   vw_rx_start(); // Start the receiver PLL running
}

void loop() {
   uint8_t buf[VW_MAX_MESSAGE_LEN];
   uint8_t buflen = VW_MAX_MESSAGE_LEN;
   if (vw_get_message(buf, &buflen)) // Non-blocking {
      if(buf[0]=='1') {
         digitalWrite(5,1);
      }
      if(buf[0]=='0') {
         digitalWrite(5,0);
      }
   }
}

Код для примечания

Светодиод, подключенный к контакту 5 на плате Arduino, включается при получении символа «1» и выключается при получении символа «0».

Модуль CC3000 WiFi от Texas Instruments представляет собой небольшую серебряную упаковку, которая, наконец, привносит простые в использовании и доступные функции WiFi в ваши проекты Arduino.

Он использует SPI для связи (а не UART!), Поэтому вы можете передавать данные так быстро, как хотите, или так медленно, как хотите. Он имеет надлежащую систему прерывания с выводом IRQ, поэтому вы можете иметь асинхронные соединения. Он поддерживает 802.11b / g, безопасность open / WEP / WPA / WPA2, TKIP и AES. Встроенный стек TCP / IP с интерфейсом «сокет BSD» поддерживает TCP и UDP как в клиентском, так и в серверном режиме.

Необходимые компоненты

Вам понадобятся следующие компоненты -

• 1 × Arduino Uno
• 1 × коммутационная плата Adafruit CC3000
• Реле 1 × 5 В
• 1 × выпрямительный диод
• 1 × светодиод
• 1 × 220 Ом резистор
• 1 × Макетная плата и несколько перемычек

Для этого проекта вам просто понадобится обычная среда разработки Arduino, библиотека CC3000 от Adafruit и библиотека MDNS CC3000. Мы также собираемся использовать библиотеку aREST для отправки команд на реле через Wi-Fi.

Процедура

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

Конфигурация оборудования для этого проекта очень проста.

• Подключите контакт IRQ платы CC3000 к контакту номер 3 платы Arduino.
• VBAT к контакту 5 и CS к контакту 10.
• Подключите контакты SPI к плате Arduino: MOSI, MISO и CLK к контактам 11, 12 и 13 соответственно.
• V _in подключен к Arduino 5V, а GND - к GND.

Давайте теперь подключим реле.

Поместив реле на макетную плату, вы можете начать определять две важные части на вашем реле: часть катушки, которая управляет реле, и часть переключателя, к которой мы прикрепим светодиод.

• Сначала подключите контакт номер 8 платы Arduino к одному контакту катушки.
• Подключите другой контакт к земле платы Arduino.

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

• Подключите + 5V платы Arduino к общему контакту переключателя реле.

• Наконец, подключите один из других контактов переключателя (обычно тот, который не подключен, когда реле выключено) к светодиоду последовательно с резистором 220 Ом, а другую сторону светодиода подключите к земле Arduino. доска.

Тестирование отдельных компонентов

Вы можете проверить реле с помощью следующего эскиза -

const int relay_pin = 8; // Relay pin

void setup() {
   Serial.begin(9600);
   pinMode(relay_pin,OUTPUT);
}

void loop() {
   // Activate relay
   digitalWrite(relay_pin, HIGH);
   // Wait for 1 second
   delay(1000);
   // Deactivate relay
   digitalWrite(relay_pin, LOW);
   // Wait for 1 second
   delay(1000);
}

Код для примечания

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

Добавление подключения к Wi-Fi

Давайте теперь будем управлять реле по беспроводной сети с помощью WiFi-чипа CC3000. Программное обеспечение для этого проекта основано на протоколе TCP. Однако для этого проекта на плате Arduino будет работать небольшой веб-сервер, поэтому мы можем «слушать» команды, поступающие с компьютера. Сначала мы займемся скетчем Arduino, а затем посмотрим, как написать код на стороне сервера и создать приятный интерфейс.

Во-первых, скетч Arduino. Цель здесь - подключиться к вашей сети WiFi, создать веб-сервер, проверить, есть ли входящие TCP-соединения, а затем соответствующим образом изменить состояние реле.

Важные части Кодекса

#include <Adafruit_CC3000.h>
#include <SPI.h>
#include <CC3000_MDNS.h>
#include <Ethernet.h>
#include <aREST.h>

Вам необходимо определить внутри кода, что является специфическим для вашей конфигурации, например, имя и пароль Wi-Fi, а также порт для TCP-связи (здесь мы использовали 80).

// WiFi network (change with your settings!)
   #define WLAN_SSID "yourNetwork" // cannot be longer than 32 characters!
   #define WLAN_PASS "yourPassword"
   #define WLAN_SECURITY WLAN_SEC_WPA2 // This can be WLAN_SEC_UNSEC, WLAN_SEC_WEP, 
   // WLAN_SEC_WPA or WLAN_SEC_WPA2

// The port to listen for incoming TCP connections
   #define LISTEN_PORT 80

Затем мы можем создать экземпляр CC3000, сервер и экземпляр aREST -

// Server instance
   Adafruit_CC3000_Server restServer(LISTEN_PORT); // DNS responder instance
   MDNSResponder mdns; // Create aREST instance
   aREST rest = aREST();

В части скетча setup () теперь мы можем подключить чип CC3000 к сети -

cc3000.connectToAP(WLAN_SSID, WLAN_PASS, WLAN_SECURITY);

Как компьютер узнает, куда отправлять данные? Один из способов - запустить скетч один раз, затем получить IP-адрес платы CC3000 и снова изменить код сервера. Однако мы можем добиться большего, и именно здесь в игру вступает библиотека CC3000 MDNS. С помощью этой библиотеки мы назначим нашей плате CC3000 фиксированное имя, чтобы мы могли записать это имя прямо в код сервера.

Это делается с помощью следующего фрагмента кода -

if (!mdns.begin("arduino", cc3000)) {
   while(1);
}

Нам также необходимо прослушивать входящие соединения.

restServer.begin();

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

mdns.update();

Сервер, работающий на плате Arduino, будет ждать входящих соединений и обрабатывать запросы.

Adafruit_CC3000_ClientRef client = restServer.available();
rest.handle(client);

Теперь протестировать проекты через Wi-Fi стало довольно просто. Убедитесь, что вы обновили скетч своим собственным именем и паролем WiFi, и загрузите скетч на свою плату Arduino. Откройте монитор последовательного порта Arduino IDE и найдите IP-адрес своей платы.

Для остальных предположим, что это что-то вроде 192.168.1.103.

Затем просто перейдите в свой любимый веб-браузер и введите -

192.168.1.103/digital/8/1

Вы должны увидеть, что ваше реле автоматически включается.

Создание релейного интерфейса

Теперь мы напишем код интерфейса проекта. Здесь будет две части: HTML-файл, содержащий интерфейс, и клиентский Javascript-файл для обработки щелчков по интерфейсу. Интерфейс здесь основан наaREST.js проект, созданный для удобного управления WiFi-устройствами с вашего компьютера.

Давайте сначала посмотрим на файл HTML с именем interface.html. Первая часть состоит из импорта всех необходимых библиотек для интерфейса -

<head>
   <meta charset = utf-8 />
   <title> Relay Control </title>
   <link rel = "stylesheet" type = "text/css" 
      href = "https://maxcdn.bootstrapcdn.com/bootstrap/3.3.4/css/bootstrap.min.css">
   <link rel="stylesheet" type = "text/css" href = "style.css">
   <script type = "text/javascript" 
      src = "https://code.jquery.com/jquery-2.1.4.min.js"></script>
   <script type = "text/javascript" 
      src = "https://cdn.rawgit.com/Foliotek/AjaxQ/master/ajaxq.js"></script>
   <script type = "text/javascript" 
      src = "https://cdn.rawgit.com/marcoschwartz/aREST.js/master/aREST.js"></script>
   <script type = "text/javascript" 
      src = "script.js"></script>
</head>

Затем мы определяем две кнопки внутри интерфейса: одну для включения реле, а другую - для его повторного выключения.

<div class = 'container'>
   <h1>Relay Control</h1>
   <div class = 'row'>
      <div class = "col-md-1">Relay</div>
      <div class = "col-md-2">
         <button id = 'on' class = 'btn btn-block btn-success'>On</button>
      </div>
      <div class = "col-md-2">
         <button id = 'off' class = 'btn btn-block btn-danger'>On</button>
      </div>
   </div>
</div>

Теперь нам также нужен клиентский Javascript-файл для обработки щелчков по кнопкам. Мы также создадим устройство, которое мы свяжем с именем mDNS нашего устройства Arduino. Если вы изменили это в коде Arduino, вам также нужно будет изменить это здесь.

// Create device
var device = new Device("arduino.local");
// Button

$('#on').click(function() {
   device.digitalWrite(8, 1);
});

$('#off').click(function() {
   device.digitalWrite(8, 0);
});

Полный код этого проекта можно найти на GitHubрепозиторий. Зайдите в папку интерфейса и просто откройте HTML-файл в своем любимом браузере. Вы должны увидеть нечто подобное в своем браузере -

Попробуйте нажать кнопку в веб-интерфейсе; он должен практически мгновенно изменить состояние реле.

Если вам удалось заставить его работать, браво! Вы только что создали выключатель света с управлением по Wi-Fi. Конечно, с этим проектом вы можете управлять не только светом. Просто убедитесь, что ваше реле поддерживает мощность, необходимую для устройства, которым вы хотите управлять, и все готово.