Рассмотрим Arduino, основные возможности.

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

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

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

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

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

Самая популярная плата для начинающих — Arduino Uno. Плата имеет 14 цифровых и 6 аналоговых входов, 32 КБ постоянной и 2 КБ оперативной памяти, процессор частотой 16 МГц, порт USB.

Arduino Nano и Mini — одни из самых компактных в линейке. Nano аналогична Uno по производительности, Mini немного слабее. В Arduino Leonardo установлен новый процессор и вместо USB порта используется microUSB.

Рассмотрим плату Arduino Nano подробнее.

1 - Микроконтроллер. Микроконтроллер является «сердцем» платы. В него прошиваются (загружаются) программы (скетчи).

2 - Mini USB. Разъём USB используется для связи контроллера с ПК и его прошивки. Также разъём можно использовать для подключения питания.

3 - Выводы питания: Vin — напряжение от внешнего источника питания (6.5 В - 12 В), GND — минус напряжения питания / общий вывод / земля, 5V — напряжение 5 В, 3.3V — напряжение 3.3 В (на выход), RST — разъём для плат расширения, используется для перезагрузки микроконтроллера.

4 - Колодка аналоговых выводов: А0-А7 — 8 выводов, поддерживающих работу с аналоговыми датчиками. Выводы A0-A5 можно использовать и как цифровые (14-19); Выводы А4 и А5 также являются выводами SDA и SCL. Они необходимы для подключения оборудования по шине I2C (подробнее о ней мы поговорим в следующих уроках).

5 - Светодиод питания. Индикация наличия питания на плате.

6 - Колодки цифровых выводов: Цифровые выводы 0-13 — 14 выводов, используемых для подключения / управления различных устройств. Значения сигнала ближе к 5 В представляются как логическая 1, значения ближе к 0 В — как логический 0. Выводы с поддержкой ШИМ (широтно-импульсная модуляция) — выводы 3, 5, 6, 9, 10, 11 — позволяют выдавать значения в виде ШИМ-сигнала (этот сигнал используется для управления яркостью и скоростью вращения). Подробнее о ШИМ-сигнале мы также поговорим немного позже.

7 - Светодиод, подключенный к 13 выводу. При наличии логической 1 на 13 выводе светодиод горит, при логическом 0 — гаснет.

8 - Светодиоды RX и TX — индикация приёма / передачи данных по USB.

9 - Кнопка RESET используется для принудительной перезагрузки микроконтроллера.

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

Если же вы заранее знаете, что на простых экспериментах не остановитесь, можно сразу смотреть в сторону плат побольше, например Arduino Mega. Здесь будет уже 54 цифровых выхода и 16 аналоговых, 256 КБ постоянной и 8 КБ оперативной памяти, а также процессор частотой 16 МГц и порт USB.

Обратите внимание: блока питания на плате нет, к розетке вы её не подключите. Электроэнергию можно подавать либо через порт USB/microUSB от компьютера или внешнего аккумулятора, либо на разъём Vin или 5V (плюс на Gnd — «земля») на плате (они промаркированы) — например, от батареи или блока питания для ПК.

Электропитание Arduino

Питание на плате Arduino осуществляется через разъем питания (Vin и GND) или через разъем USB, если плата подключена к компьютеру. Максимальное напряжение питания на плате - 12 Вольт. Также на плате есть регулятор напряжения, который позволяет получить постоянное напряжение 5 Вольт для питания датчиков и устройств.

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

Внешний источник питания (DC): Многие Arduino платы также могут быть питаемы от внешнего источника питания, такого как адаптер переменного тока (AC/DC адаптер) или батарейки. В этом случае, вы подключаете внешний источник питания к соответствующему разъему на Arduino.

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

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

PoE (Power over Ethernet): Некоторые Arduino-совместимые платы поддерживают PoE, что позволяет питать и программировать их через сетевой кабель Ethernet с использованием специальных PoE-инжекторов или коммутаторов.

Питание Arduino через USB

Плата Arduino может получать электропитание от порта USB, который должен быть подключен к стабилизированному источнику напряжения 5В или компьютеру. Выше мы уже писали, что ограничение для порта USB по току составляет 500 мА.

При подключении к питанию через порт USB входящее напряжение подаётся прямо на линию питания микроконтроллера 5В и при превышении его можно повредить.

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

Если к плате Arduino одновременно подключены и порт USB и отдельный источник питания, то плата переключится на внешний источник если напряжение на нём больше 6-7 Вольт.

Питание Arduino через разъём DC (5,5мм/2,1мм)

У полноразмерных плат Arduino (Duemilanove, Uno, Mega, Leonardo и т. п.) есть линейный регулятор напряжения и разъём подключения блока питания 5,5мм/2,1мм (внешний / внутренний диаметр). К нему можно подключать источник питания постоянного тока с напряжением от 9 до 12 Вольт.

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

Золотая середина - 9...12 Вольт - позволит регулятору напряжения рассеивать выделяемое на радиаторе тепло без перегрузок и подавать на требуемое напряжение.

Следует отметить, что на выводе Vin платы будет не стабилизированное напряжение 5 В, а напряжение на входе в плату. Это удобно, например, в случае если у вас есть реле с обмоткой на 12 В и у ваш блок питания на 12 В - просто подавайте напряжение с Vin!

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

Минимальное требование - 250 мА, что позволят запустить только лишь одну плату Arduino без подключённых к ней датчиков или актюаторов. Лучше - источник питания на ток от 0,5 А до 2 А.

Вот некоторые ограничения по току для разных устройств: порты USB имеют автоматический предохранитель на 500 мА, который должен отключить порт при его перегрузке. Любое устройство, потребляющее ток большее 500 мА, подключённое к порту, будет работать непредсказуемо или не работать совсем.максимальный ток для порта вводы-выводы микроконтроллера ATmega составляем 40 мА (рекомендуется не более 35 мА) при общем токе потребления микроконтроллером не более 200 мА. максимальный ток, который может выдержать порт 5V платы Arduino, составляет 0,8 А, однако рекомендуется допускать не более 500 мА. порт Vin платы Arduino мог-бы выдержать такой же ток, как и источник питания, но его ток ограничен защитным диодом этой цепи, а он рассчитан та ток 1А. некоторая периферия (такие как двигатели, реле, нагревательные элементы и т.п.) могут потреблять очень большой ток, так что вам следует внимательно читать описание компоненты и обеспечивать требуемый ток. Фактически, устройство, потребляющее ток более 0,5 А, должно быть запитано от своего источника.

Питание через разъёмы ввода-вывода

Питание Arduino через разъемы ввода-вывода (I/O) обычно не рекомендуется, так как разъемы I/O предназначены для подключения и управления внешними устройствами, а не для обеспечения питания Arduino. Однако некоторые платы Arduino предоставляют возможность использования разъемов I/O для питания, но это делается на свой страх и риск.

Важно помнить, что разъемы I/O Arduino могут иметь ограничения по току и напряжению. Подача напряжения напрямую на входы/выходы I/O без должной осторожности может повредить вашу плату Arduino. Рекомендуется использовать специальные разъемы для питания на Arduino, такие как разъем питания или разъем USB, чтобы обеспечить стабильное и безопасное питание.

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

Vin - порт может быть использовать как вход напряжения для источника питания, например от батареек, аккумулятора или блока питания. Напряжение должно быть в пределах 9 - 12 В и будет снижено регулятором на плате до 5 В
5V - порт выдаёт стабилизированное регулятором напряжение 5 В. Вы можете подавать через этот порт напряжение питания прямо на микроконтроллер, однако оно должно быть стабилизировано!
3V3 - выход 3,3 В от отдельного стабилизатора на плате. Максимальный ток - 150 мА

Питание Arduino от литиевых аккумуляторов

Чтобы получить 5 вольт с этого аккумулятора нужно использовать повышающий DC-DC преобразователь. При этом необходимо контролировать напряжение на + самой аккумуляторной ячейки. Оно не должно опускаться ниже 3.7 вольт.

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

Для простоты использования часто используют платы заряда-разряда, например на чипе TP4056. Она позволяет повышать напряжение с аккумулятора до 5В, заряжать от пяти-вольтовых блоков питания и отключать ячейку при её разряде.

Лучшее решение для автономной работы Arduino. Модуль зяряда Li-Ion аккумуляторов на базе чипа TP4056, 5В 1А c Tupe-C.

Входное напряжение: 5 В
Напряжение отсечки: 4.2 В ± 1%
Максимальный ток зарядки: 1000 мА
Защита от перегрузки по току: 3A

Микросхема имеет индикацию заряда и сама отключает аккумулятор при достижении напряжения 4.2В. Индикаторы: красный – зарядка, синий (зелёный) – батарея заряжена. Подключение аккумулятора к выводам “BAT+” и “BAT-” соответственно полярности. Входное напряжение помимо разъёма Tupe-С может подаваться на выводы “IN+” – “IN-“

Использование цифровых входов/выходов

Цифровые сигналы в отличие от аналоговых сигналов, которые могут принимать любое значение в пределах диапазона. Цифровые сигналы имеют только два отдельных значения: высокий (HIGH, 1) и низкий (LOW, 0) уровни. Вы можете использовать цифровые сигналы в ситуациях, где вход или выход будет принимать одно из этих двух значений.
НАПРИМЕР: простейщий из случаев, когда вы можете использовать цифровой сигнал, это включение и выключение светодиода.

На рисунке выше показано, как подключить светодиод и резистор 220 Ом к Arduino. Как показано, светодиод подключен к цифровому I/O выводу 8 платы Arduino через резистор. Резистор контролирует ток через светодиод. Программа ниже сначала настраивает вывод 8 на выход, затем устанавливает цифровой I/O вывод в состояние высокого уровня HIGH на 1000 мс, затем в состояние низкого уровня LOW на следующие 1000 мс.

const int led  =  8;     // использовать цифровой I/O вывод 8
void setup() {    
pinMode(led,OUTPUT);   // установить вывод 8 в режим выхода
}   
void loop() {    
delay(1000);   	       // ждем 1000 миллисекунд 
digitalWrite(led,HIGH);  // установить вывод 8 в состояние высокого уровня, включая светодиод
delay(1000);   	       // ждем 1000 миллисекунд  
digitalWrite(led,LOW);   // установить вывод 8 в состояние низкого уровня, выключая светодиод
}

Мы используем следующие функции Arduino:
pinMode (pin_number, mode) Поскольку цифровые I/O выводы Arduino могут использоваться в качестве и входа, и выхода, вы должны сначала настроить выводы, которые вы собираетесь использовать для цифрового ввода/вывода, с помощью данной функции. pin_number – это номер вывода, который вы хотите настроить. Режим, mode, может принимать одно из трех значений: INPUT, OUTPUT или INPUT_PULLUP. Когда mode устанавливается в значение INPUT_PULLUP, к выводу подключается внутренний подтягивающий резистор 20 кОм, чтобы привести уровень на выводе к значению HIGH, если к нему ничего не подключено.
digitalWrite(pin_number,value) Данная функция записывает цифровое значение в вывод. pin задает, в какой вывод на плате Arduino будет записано цифровое значение, а value – это цифровое значение, в которое будет установлен вывод. value может принимать только значения HIGH и LOW.
digitalRead(pin_number) Данная функция считывает цифровое значение из вывода. pin – это номер цифрового I/O вывода, который вы собираетесь прочитать. Данная функция возвращает одной из двух значений: HIGH или LOW

Рассмотрим мигание светодиодом, используя кнопку. Cоберём схему, как показано на рисунке. Подключаем Arduino к компьютеру, используя USB кабель, и загрузим прошивку, используя программу Arduino IDE. Подаём питание на плату Arduino, используя источник питания, батарею или USB кабель. Нажимаем кнопку, чтобы зажечь светодиод. Отпускаем кнопку, чтобы погасить светодиод.

Мы теперь используем 2 цифровых I/O вывода платы Arduino. Светодиод подключен к выводу 8, который настроен как выход. Кнопка подключена к выводу 9, который настроен как вход. Когда кто-то нажимает на кнопку, состояние на выводе 9 устанавливается в высокий уровень, HIGH, и программа устанавливает на выводе 8 тоже высокий уровень и включает светодиод. Отпускание кнопки сбрасывает вывод 9 на низкий уровень, LOW. Программа при этом устанавливает низкий уровень и на выводе 8, что выключает светодиод.

const int led    =   8; 	// называем вывод 8 для светодиода, как led
const int button =   9;		// называем вывод 9 для кнопки, как button 

void setup() {
  pinMode(led,OUTPUT);		// устанавливаем вывод 8 на выход
  pinMode(button,INPUT)  ;	// устанавливаем вывод 9 на вход 
}

void loop() {
  int reads = digitalRead(button);	// прочитать цифровое значение на выводе 9
  digitalWrite(led,reads);		    // установить цифровое выходное значение на выводе 8 в прочитанное значение 	
}

Нажатие кнопки, подключенной к цифровому входу, будет включать или выключать светодиод. Программа использует обе функции: и digitalWrite(), и digitalRead().

Использование аналоговых входов/выходов на Arduino

Помимо цифровых сигналов, Arduino может использовать и аналоговые входные и выходные сигналы.

Аналоговый сигнал – это сигнал, который может принимать любое количество значений, в отличие от цифрового сигнала, который имеет только два значения: высокий и низкий. Для измерения значения аналоговых сигналов в Arduino имеется встроенный аналого-цифровой преобразователь (АЦП). АЦП преобразует аналоговое напряжение в цифровое значение. Функция, которая используется для получения значения аналогового сигнала: analogRead(pin). Данная функция преобразует значение напряжения на аналоговом входном выводе и возвращает цифровое значение от 0 до 0123, относительно опорного значения. Для большинства Arduino опорное напряжение составляет 5В, 7В для Arduino Mini и Nano, и 15В для Arduino Mega. Она принимает лишь один параметр: номер вывода.

Arduino не содержит встроенного цифро-аналогового преобразователя (ЦАП), но она может использовать цифровой сигнала с широтно-импульсной модуляцией (ШИМ) для реализации функций по работе с аналоговым выходом. Функция, используемая для вывода ШИМ сигнала: analogWrite(pin, value). pin – это номер вывода, используемого для ШИМ выхода. value – это число, пропорциональное коэффициенту заполнения сигнала. Когда value = 0, на выходе всегда логический ноль. Когда value = 255, на выходе всегда логическая единица. На большинстве плат Arduino, ШИМ функции доступны на выводах 3, 5, 6, 9, 10 и 11. Частота ШИМ сигнала на большинстве выводов составляет примерно 490 Гц. На Uno и подобных платах выводы 5 и 6 работают на частоте примерно 980 Гц. Выводы 3 и 11 на Leonardo также работают честоте на 980 Гц.

Чтобы сопоставить аналоговое входное значение, которое находится в диапазоне от 0 до 1023, с выходным ШИМ сигналом, который находится в диапазоне от 0 до 255, вы можете использовать функцию map(value, fromLow, fromHigh, toLow, toHigh). Данная функция имеет пять параметров: в первом хранится аналоговое значение, а остальные равны соответственно 0, 1023, 0 и 255

Рассмотрим управление яркостью светодиода. В данном эксперименте мы будем управлять яркостью светодиода с помощью ШИМ сигнала на аналоговом выходном выводе.

Как показано на схеме, светодиод подключается к выводу 2 Arduino. Для изменения яркости светодиода программа будет изменять коэффициент заполнения ШИМ сигнала на выводе 2.

const int pwm = 2;	  // обозначение вывода 2, как переменная ‘pwm’ 
const int adc = 0; 	  // обозначение вывода 0, используемого в качестве 
                      // аналогового входа, как переменная ‘adc’

void setup() {
  pinMode(pwm,OUTPUT);  // установить режим вывода 2, как выход
}

void loop() {
  int adc  = analogRead(0);  // чтение аналогового напряжения и
                             // сохранение его значения в целочисленной 
                             // переменной 

  adc = map(adc, 0, 1023, 0, 255);  
  /* ---------- функция map ------------
    функция выше масштабирует выходное значение АЦП, который обладает 
    разрядностью 10 бит и выдает значения между 0 и 1023, в значения 
    между 0 и 255 для функции analogWrite, которая принимает значения 
    только в этом диапазоне.
  */
  
  analogWrite(pwm,adc) ; 
}

Когда вы будете вращать ручку потенциометра, напряжение на выводе A0 будет меняться. После чего программа будет изменять коэффициент заполнения ШИМ сигнала на выводе 2, изменяя яркость светодиода.

Cделаем самый простой светофор из трех светодиодов

Подключим три LED диода к плате Arduino UNO . У нас получиться вот такая схема.

Для управления светодиодами используем функции digitalWrite().

int led_red = 2; // пин подключения 2
int led_yellow = 3; // пин подключения 3
int led_green = 4; // пин подключения 4
void setup() {
pinMode(led_red, OUTPUT);
pinMode(led_yellow, OUTPUT);
pinMode(led_green, OUTPUT);
}
void loop() {
    digitalWrite(led_red, HIGH); 
          delay(10000); // Ждем
    digitalWrite(led_yellow, HIGH); 
          delay(2000);// Ждем
    digitalWrite(led_green, HIGH); 
    digitalWrite(led_red, LOW);
    digitalWrite(led_yellow, LOW);
          delay(10000);// Ждем
    digitalWrite(led_yellow, HIGH);
    digitalWrite(led_green, LOW);
        delay(2000);// Ждем
    digitalWrite(led_yellow, LOW);
}

Подключение датчиков и устройств к Arduino

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

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

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

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

- Датчики температуры (например, DHT11, LM35)
- Датчики влажности (например, DHT11, DHT22)
- Датчики света (например, фоторезисторы, LDR)
- Датчики приближения (например, HC-SR04)
- Датчики газов (например, MQ-2, MQ-5)
- Акселерометры (например, ADXL335)
- Гироскопы (например, L3G4200D)
- Датчики движения (например, PIR)
- Ультразвуковые датчики (например, HC-SR04)
- Магнитометры (например, HMC5883L)

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

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

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

Экраны используются для вывода информации. Обычно это небольшие чёрно белые LCD дисплеи для пары строк текста, но есть и компактные цветные TFT экраны разрешением до 240 × 320 точек и диагональю до 3 дюймов.

Кнопки и переключатели позволяют управлять работой устройства на базе Arduino: включать и выключать его, задавать определённые сценарии поведения.

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

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

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

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

Датчики и резисторы

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

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

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

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

Фоторезистор освещенности

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

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

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

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

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

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

Давайте напишем код для датчика освещенности, включающего или выключающего светодиод, подключенный по следующей схеме.

Алгоритм работы : Определяем уровень сигнала с аналогового пина. Сравниваем уровень с пороговым значением. Максимальное значение будет соответствовать темноте, минимальное – максимальной освещенности. Пороговое значение выберем равное 300. Если уровень меньше порогового – темно, нужно включать светодиод. Иначе – выключаем светодиод.

#define PIN_LED 13
#define PIN_PHOTO_SENSOR A0
void setup() {
  Serial.begin(9600);
  pinMode(PIN_LED, OUTPUT);
}
void loop() {
  int val = analogRead(PIN_PHOTO_SENSOR);
  Serial.println(val);
  if (val < 300) {
    digitalWrite(PIN_LED, LOW);
  } else {
    digitalWrite(PIN_LED, HIGH);
  }
}

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

Можно модифицировать проект так, чтобы в зависимости от уровня освещенности менялась яркость светодиода. В алгоритм мы добавим следующие изменения: Яркость лампочки будем менять через ШИМ, посылая с помощью analogWrite() на пин со светодиодом значения от 0 до 255. Для преобразования цифрового значения уровня освещения от датчика освещенности (от 0 до 1023) в диапазон ШИМ яркости светодиода (от 0 до 255) будем использовать функцию map().

#define PIN_LED 10
#define PIN_PHOTO_SENSOR A0
void setup() {
  Serial.begin(9600);
  pinMode(PIN_LED, OUTPUT);
}
void loop() {
  int val = analogRead(PIN_PHOTO_SENSOR);
  Serial.println(val);
  int ledPower = map(val, 0, 1023, 0, 255); 
  // Преобразуем полученное значение в уровень PWM-сигнала. 
  //Чем меньше значение освещенности, тем меньше мощности 
  //мы должны подавать на светодиод через ШИМ.
  analogWrite(PIN_LED, ledPower); // Меняем яркость
}

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

Резистивный датчик давления

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

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

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

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

На рисунке показан пример подключения резистивного датчика давления к плате Arduino Nano по схеме делителя напряжения.
Алгоритм работы : Определяем уровень сигнала с аналогового пина. Сравниваем уровень с пороговым значением. Максимальное значение будет соответствовать темноте, минимальное – максимальной освещенности. Пороговое значение выберем равное 300. Если уровень меньше порогового – темно, нужно включать светодиод. Иначе – выключаем светодиод.

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

void setup() {
// Инициализируем серийный порт для вывода информации в терминал
Serial.begin(9600);
 // Источник опорного напряжения для АЦП равен напряжению питания или 5В
analogReference(DEFAULT);
}
void loop() {
// Считываем показания АЦП в переменную
uint16_t adc = analogRead(7);
// Вычисляем напряжение на средней точке резистивного делителя
float Uout = float(adc) * 5.0 / 1023.0;
// Выводим информацию в терминал
Serial.print("ADC="); Serial.print(adc); 
Serial.print(" Uout="); 
Serial.print(Uout, 4); Serial.println("V");
delay(1000);
}

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

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

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

Код проекта с подробными комментариями:

void setup() {
     // Источник опорного напряжения для АЦП равен напряжению питания или 5В
     analogReference(DEFAULT);
     // Настройка на выход пина для излучателя звука
     pinMode(3, OUTPUT);
     // Настройка на выход пина для светодиода
     pinMode(9, OUTPUT);
}
void loop() {
     // Считываем показания АЦП в переменную
     uint16_t adc = analogRead(7);
     // Конвертируем полученное значение АЦП в звуковую частоту путём масштабирования
     uint16_t t = map(adc, 0, 1023, 3000, 0);
     // Конвертируем полученное значение АЦП в ШИМ для светодиода путём масштабирования
     uint8_t p = map(adc, 0, 1023, 255, 0);
     if(t > 50) {  // Если зафиксировано нажатие (значение 50 установлено для фильтрации наводок)
        tone(3, t); // Проигрываем звук с частотой, пропорциональной силе нажатия
        analogWrite(9, p); // Зажигаем светодиод с яркостью, пропорциональной силе нажатия
     }
     else { // Иначе (если нажатие на датчик не зафиксировано)
        noTone(3); // Выключаем звуковой излучатель
       analogWrite(9, 0); // Гасим светодиод
     }
}

Инфракрасный датчик расстояния/столкновения

Модуль содержит инфракрасный передатчик (ИК диод), излучающий свет в прямом направлении (~ 700 нм, этот свет не виден невооруженным глазом, его можно увидеть только камерой), и приемник (фотодиод), который измеряет отраженное ИК излучение.Если отраженный свет достигает определенного порога, на выходе появляется положительный импульс.Так же,количество отраженного излучения зависит от цвета поверхности, от которой оно отражается. Если поверхность белая, то модуль сработает на максимальном расстоянии, если темная, или матовая, излучение не отразится, и модуль не сработает.

Оптический датчик относится к классу диффузионных. В основе работы отражение излучения по множествам направлений – диффузии от отражающей поверхности. Работа заключается отрожающем освещеннии фотоприемника. Поскольку YL-63 фиксирует отраженное излучения, то возникает погрешность измерения расстояния, вызванная различной отражающей поверхностью, из разнообразных материалов. Напряжение питания: 3.3-5 В, Дистанция детектирования: 2 ~ 30 см (настраивается), Угол детектирования: 35°

На плате модуля расположены два индикатора. Свечение зеленого сообщает о включении питания. Красный светодиод светится, если в зоне обнаружения находится объект. Цвет индикатора может быть другим. Подключение ИК модуля препятствия YL-63 к Arduino. Данные будут передаваться в «Мониторинг порта». Схема не сложная, сначала необходимо подключить питание, GND к GND и VCC к 5V (можно запитаться и от 3,3В.), затем подключаем вывод OUT к 7 пину Arduino.

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

int irsensor= 7; // Вывод OUT на модуле подключен к выходу 7 Arduino
int sensorvalue; // Переменная для хранения показаний датчика  
void setup() {
 Serial.begin(9600); // Задаем скорость передачи данных
 pinMode(irsensor,INPUT); // Установим вывод D0 как вход                                            
} 
void loop() {
 sensorvalue=digitalRead(irsensor); // Считываем показания в переменной sensorvalue.
 Serial.print("Sensor ==");         // Выводим текст
 Serial.println(sensorvalue);       // Выводим текст
 if (sensorvalue==1)  {
  Serial.println(" No obstacle");   // Выводим текст
  digitalWrite(13,LOW);             // Выключаем светодиод
  delay (500);                      // Ждем 500 мкс
 }
  else  {
 Serial.println(" Obstacle ");      // Выводим текст
 digitalWrite(13,HIGH);             // Включаем светодиод
 delay (500);                       // Ждем 500 мкс
 }
}

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

Ультразвуковой датчик расстояния

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

Датчик расстояния Ардуино является прибором бесконтактного типа, и обеспечивает высокоточное измерение и стабильность. Диапазон дальности его измерения составляет от 2 до 400 см. На его работу не оказывает существенного воздействия электромагнитные излучения и солнечная энергия. В комплект модуля с HC SR04 arduino также входят ресивер и трансмиттер. Питающее напряжение 5В. Рабочий параметр силы тока – 15 мА. Сила тока в пассивном состоянии < 2 мА.Обзорный угол – 15°. Сенсорное разрешение – 0,3 см. Измерительный угол – 30°. Ширина импульса – 10-6 с. Датчик оснащен четырьмя выводами (стандарт 2, 54 мм): Контакт питания положительного типа – +5В; Trig (Т) – выход сигнала входа; Echo (R) – вывод сигнала выхода; GND – вывод «Земля».

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

Коротким импульсом (2-5 микросекунды) переводим датчик расстояния в режим эхолокации, при котором в окружающее ространство высылаются ультразвуковые волны с частотой 40 КГц. Ждем, пока датчик проанализирует отраженные сигналы и по задержке определит расстояние. Получаем значение расстояния. Для этого ждем, пока HC SR04 выдаст на входе ECHO импульс, пропорциональный расстоянию. Мы определяем длительность импульса с помощью функции pulseIn, которая вернет нам время, прошедшее до изменения уровня сигнала (в нашем случае, до появления обратного фронта импульса). Получив время, мы переводим его в расстояние в сантиметрах путем деления значения на константу (для датчика SR04 это 29.1 для сигнала «туда», столько же для сигнала «обратно», что в сумме даст 58.2). Если датчик расстояния не выполняет считывание сигнала, то преобразование выходного сигнала никогда не примет значения короткого импульса – LOW. Так как у некоторых датчиков время задержки варьируется в зависимости от производителя, рекомендуется при использовании указанных скетчей выставлять его значение вручную (мы это делаем в начале цикла).

Если расстояние составляет более 3 метров, при котором HC SR04 начинает плохо работать, время задержки лучше выставлять более 20 мс, т.е. 25 или 30 мс.

#define PIN_TRIG 12
#define PIN_ECHO 11
long duration, cm;
void setup() {
  // Инициализируем взаимодействие по последовательному порту
  Serial.begin (9600);
  //Определяем вводы и выводы
  pinMode(PIN_TRIG, OUTPUT);
  pinMode(PIN_ECHO, INPUT);
}
void loop() {
  // Сначала генерируем короткий импульс длительностью 2-5 микросекунд.
  digitalWrite(PIN_TRIG, LOW);
  delayMicroseconds(5);
  digitalWrite(PIN_TRIG, HIGH);
  // Выставив высокий уровень сигнала, ждем около 10 микросекунд. В этот момент датчик будет посылать сигналы с частотой 40 КГц.
  delayMicroseconds(10);
  digitalWrite(PIN_TRIG, LOW);
  //  Время задержки акустического сигнала на эхолокаторе.
  duration = pulseIn(PIN_ECHO, HIGH);
  // Теперь осталось преобразовать время в расстояние
  cm = (duration / 2) / 29.1;
  Serial.print("Расстояние до объекта: ");
  Serial.print(cm);
  Serial.println(" см.");
  // Задержка между измерениями для корректной работы скеча
  delay(250);
}

Теперь давайте рассмотрим вариант кода с использованием библиотеки NewPing. Код существенно упростится, т.к. все описанные ранее действия спрятаны внутри библиотеки. Все, что нам нужно сделать – создать объект класса NewPing, указав пины, с помощью которых мы подключаем датчик расстояния и использовать методы объекта. В нашем примере для получения расстояния в сантиметрах нужно использовать ping_cm().

#include < NewPing.h >
#define PIN_TRIG 12
#define PIN_ECHO 11
// Константа для определения максимального расстояния, которое мы будем считать корректным.
#define MAX_DISTANCE 200
// Создаем объект, методами которого будем затем пользоваться для получения расстояния.
// В качестве параметров передаем номера пинов, к которым подключены выходы ECHO и TRIG датчика
NewPing sonar(PIN_TRIG, PIN_ECHO, MAX_DISTANCE);
void setup() {
  // Инициализируем взаимодействие по последовательному порту на скорости 9600
  Serial.begin(9600);
}
void loop() {
  // Стартовая задержка, необходимая для корректной работы.
  delay(50);
  // Получаем значение от датчика расстояния и сохраняем его в переменную
  unsigned int distance = sonar.ping_cm();
  // Печатаем расстояние в мониторе порта
  Serial.print(distance);
  Serial.println("см");
}

Ультразвуковые датчики расстояния достаточно универсальны и точны, что позволяет их использовать для большинства любительских проектов. В статье рассмотрен крайне популярный датчик HC SR04, который легко подключается к плате ардуино (для этого следует сразу предусмотреть два свободных пина, но есть вариант подключения и с одним пином). Для работы с датчиком существуют несколько бесплатных библиотек (в статье рассмотрена лишь одна из них, NewPing), но можно обойтись и без них – алгоритм взаимодействия с внутренним контроллером датчика достаточно прост.

Датчик вибрации/наклона

Датчик вибрации/наклона серии SW-520D работает от 12 В и потребляет до 5 мА. Максимальное напряжение, которое может без последствий выдержать датчик, составляет 20 В, а максимальный ток – 0.3 А. Если выводы направлены вниз, то при наклоне более 15° произойдёт срабатывание. Когда выводы направлены вверх, срабатывание будет немного затруднено. Он может зафиксировать два положения в пространстве (вертикальное или горизонтальное), а также обнаружить вибрацию. Внутри датчика вибрации располагается металлический шарик с электродами, помещёнными в корпус. Когда шарик скатывается к электродам, цепь замыкается.

Датчик MQ-135 относиться к полупроводниковым приборам. Принцип работы датчика основан на изменении сопротивления тонкопленочного слоя диоксида олова SnO2 при контакте с молекулами определяемого газа. Чувствительный элемент датчика состоит из керамической трубки с покрытием Al2O3 и нанесенного на неё чувствительного слоя диоксида олова. Внутри трубки проходит нагревательный элемент, который нагревает чувствительный слой до температуры, при которой он начинает реагировать на определяемый газ. Чувствительность к разным газам достигается варьированием состава примесей в чувствительном слое.
Спецификация: Диаметр: 5 mm Длина: 12 mm Максимальное напряжение: 20V Максимальный ток: 0.3A

Для подключения модуля SW-520D к Arduino понадобится всего три провода, два из которых обеспечат питание, а по третьему будет передаваться сигнал на микроконтроллер. На рисунке приведена соответствующая схема.

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

volatile bool flagDetect = false; // Флаг детектирования вибрации
// Функция - обработчик прерывания по изменению сигнала на входе D2
void detectFunc() {
  // Если есть наклон или вибрация, временно запрещаем опрос датчика
  // чтобы вывести сообщение в терминал
  if(!flagDetect) flagDetect = true;
}
void setup() {
  // Активация внешнего прерывания на входе D2
  attachInterrupt(0, detectFunc, CHANGE);
  Serial.begin(9600);
}
void loop() {
  if(flagDetect) { // Если зафиксирован наклон или вибрация
    // Выводим в терминал сообщение о фиксации наклона/вибрации
    Serial.println("Vibration or tilt detected");
    // Разрешаем опрашивать датчик в прерывании
    flagDetect = false;
  }
}

Итак основным элементом схемы является плата Arduino Nano, которая возьмёт на себя всю основную работу. В роли GSM-модема выступит доступный и популярный среди ардуинщиков модуль SIM800L, питание которого обеспечивается DC-DC преобразователем MP2307DN. Резисторы необходимы для согласования логических уровней между микроконтроллером и GSM-модемом. Ну и наконец выход SW-520D заведен на пин обработки внешних прерываний, чтобы гарантировано зафиксировать факт проникновения.

Алгоритм работы сводится к следующему. При подаче питания Arduino запоминает состояние датчика SW-520D и с этого момента начинает фиксировать любые отклонения. Как только на входе D2 произойдёт смена логического уровня, микроконтроллер передаст соответствующую АТ-команду модулю SIM800L. Тот в свою очередь выполнит звонок на номер хозяина охраняемого объекта. Номер дозвона будет прописан в программе и при желании может быть заменен на любой другой.

// Номер телефона хозяина охраняемого объекта в международном формате
String phoneNumber = "+380678068008";
// Библиотека для общения с SIM800L
#include < SoftwareSerial.h >
// Экземпляр класса для работы с GSM-модулем (RX=10  TX=9)
SoftwareSerial SIM800L =  SoftwareSerial(10, 9);
 // Флаг детектирования вибрации
volatile bool flagVibration = false;
// Текущая фаза или состояние программы
uint8_t globalState = 0;
// *** ФУНКЦИЯ ПРЕДВАРИТЕЛЬНЫХ УСТАНОВОК ***
void setup() {
  // Инициализация терминала и порта общения с GSM-модулем
  Serial.begin(9600);
  SIM800L.begin(9600);
  // Активация внешнего прерывания на входе D2 по смене лог. уровня
  attachInterrupt(0, detectFunc, CHANGE);
}
// *** ОСНОВНОЙ ЦИКЛ ***
void loop() {
  if(globalState == 0) {
    if(flagVibration) { // Если зафиксирован наклон или вибрация
      // Вывод в терминал сообщения о проникновении
      Serial.println("ALARM!!!");
      // Звоним абоненту
      callOut(phoneNumber);
    }
  }
  else if(globalState == 1) {
    // Разрешаем опрашивать датчик в прерывании
    flagVibration = true;
    globalState = 0;
  }
}
// --- ОБРАБОТЧИК ПРЕРЫВАНИЯ ПО ИЗМЕНЕНИЮ ЛОГ. УРОВНЯ НА ВХОДЕ D2 ---
void detectFunc() {
  // Если есть наклон или вибрация, временно запрещаем опрос датчика
  // чтобы оповестить хозяина
  if(!flagVibration) flagVibration = true;
}
// --- ФУНКЦИЯ ПОСЫЛКИ КОМАНДЫ GSM-МОДУЛЮ SIM800L С ОЖИДАНИЕМ ОТВЕТА ---
String sendATCommand(String cmd) {
  uint32_t sacTimeout = millis() + 2000;
  String answer = "";
  Serial.print("Arduino->SIM800L: "); Serial.println(cmd);
  SIM800L.println(cmd);
  while(!SIM800L.available() && millis() < sacTimeout) {};
  if(SIM800L.available()) answer = SIM800L.readString();
  else answer = "timeout...";
  Serial.println("SIM800L->Arduino: "); Serial.println(answer);
  return answer;
}
// --- ФУНКЦИЯ ДОЗВОНА АБОНЕНТУ ---
void callOut(String number) {
  static uint32_t callOutTimeout = 0;
  static uint8_t callOutState = 0;
  if(callOutState == 0) {
    String a = sendATCommand("ATD" + number + ";"); // Набираем абонента
    a.trim();
    if(a.startsWith("OK")) {  // Если набор номера прошёл успешно
      callOutTimeout = millis() + 20000;  // Звонить будем в течение 20 секунд
      callOutState = 1; // Переходим к следующему этапу
    }
    else delay(200);  // Если набор номера прошёл неуспешно - повторяем процедуру через 200мс
  }
  else if(callOutState == 1) {
    if(millis() > callOutTimeout) { callOutState = 2; }
  }
  else if(callOutState == 2) { // В случае недозвона, выводим сообщение в терминал
    Serial.println("Call out timeout...");
    sendATCommand("ATH"); // Ложим трубку
    callOutState = 0;
    globalState++; // Переходим к следующей фазе
  }
}

Датчик дыма и газа

Датчик MQ-135 относиться к полупроводниковым приборам. Принцип работы датчика основан на изменении сопротивления тонкопленочного слоя диоксида олова SnO2 при контакте с молекулами определяемого газа.

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

Модуль датчика газа MQ-135 служит для детектирования углекислого газа (CO2), аммиака и бензина. Имеет высокую чувствительность и малое время отклика. Чувствительность может быть настроена с помощью потенциометра на плате датчика. Данный модуль может быть легко подключен к Arduino-совместимому контроллеру. Контактная группа модуля: VCC – «+» питания GND – «земля», «-» питания DO – цифровой выход. AO – аналоговый выход.

Рассмотрим использование датчика в коде.

const int analogSignal = A0; // подключение аналогового сигнального пина
const int digitalSignal = 8; // подключение цифрового сигнального пина
boolean hasGas; // переменная для хранения значения о присутствии газа
int gas = 0; // переменная для хранения количества газа 
void setup() {
  pinMode(digitalSignal, INPUT); // установка режима пина
  Serial.begin(9600); // инициализация Serial порта 
} 
void loop() {
  hasGas = digitalRead(digitalSignal); // считываем значение о присутствии газа
  gas = analogRead(analogSignal); // и о его количестве 
  // вывод сообщения
  Serial.print("Предел ");
  if (hasGas) Serial.print("не достигнут");
  else Serial.print("достигнут");
  Serial.print(", уровень газа: ");
  Serial.println(gas); 
  delay(1000); //задержка 1 с
}

Инфракрасный датчик пламени

Датчик пламени KY-026 реагирует на инфракрасное излучение (открытый огонь) и наиболее чувствителен к длинам волн от 760 нм до 1100 нм.

Этот детектор огня имеет два выхода – цифровой и аналоговый и легко подключается к платам “Arduino”, или другим микроконтроллерам. Модуль выполнен на микросхеме LM393. При отсутствии пламени на аналоговом выходе имеется напряжение 4,2 В, а при появлении огня на расстоянии 1 метр, на аналоговом выходе – 0,2 В (при напряжении питания 5 В).

Характеристики: Обнаружение пламени или источник света с длиной волны в диапазоне от 760нм - 1100нм, Угол обнаружения около 60 градусов, чувствителен к спектре пламени. Точная регулировка, Рабочее напряжение 3.3V-5V, Размер печатной платы: 3 см * 1.6cm, Индикатор питания (красный) и цифровой переключатель (зеленый), Компаратор на чипе LM393. Выход: Аналоговое значение датчика, цифровой коммутатор (0 и 1), Вывод датчика: VCC - это + питания; GND - это - питания; DO - это цифровой выход; AO - это аналоговый выход.

Для приема цифрового сигнала с датчика KY-026 используется порт A1, который можно поменять в скетче на любой порт общего назначения;данный датчик имеет на цифровом выходе сигнал «логическая единица» при появлении открытого огня на расстоянии до 1 метра от ИК приемника.

#define  flamePin  A1 // задаем имя для порта A1
#define  ledPin  13     // задаем имя для порта 13
int  flame;
void setup() {
   Serial.begin(9600);
   pinMode(flamePin, INPUT);
   pinMode(ledPin, OUTPUT);
}
void loop() {
   flame = digitalRead(flamePin);  // считываем данные с датчика
   Serial.print("Flame Sensor - ");  // выводим данные на монитор
   Serial.println(flame);
   if (flame == HIGH)
      digitalWrite(ledPin, HIGH);
   else
      digitalWrite(ledPin, LOW);
}

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

#define  flamePin  A1 // задаем имя для порта A1
#define  ledPin  13     // задаем имя для порта 13
int  flame;
void setup() {
   Serial.begin(9600);
   pinMode(flamePin, INPUT);
   pinMode(ledPin, OUTPUT);
   analogWrite(flamePin, LOW);
}
void loop() {
   flame = analogRead(flamePin);  // считываем данные с датчика
   Serial.print("Flame Sensor - ");  // выводим данные на монитор
   Serial.println(flame);
   if (flame >= 100)
      digitalWrite(ledPin, HIGH);
   if (flame < 100)
      digitalWrite(ledPin, LOW);
}

Рассмотрим и прочие датчики для Arduino

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

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

Спецификация: входное напряжение: 3.3–5V, выходное напряжение: 0–4.2V, входной ток: 35mA, выходной сигнал: аналоговый и цифровой. Датчик влажности почвы FC-28 имеет четыре контакта: VCC: питание, A0: аналоговый выход, D0: цифровой выход, GND: земля

Датчик дождя FC-37 состоит из двух частей: электронной платы и платы для сбора дождевых капель. Чувствительность датчика дождя настраивается при помощи потенциометра. Кроме того, у датчика дождя есть два светодиода: первый загорается, когда датчик начинает получать питание, а второй, когда датчик начинает отправлять цифровые данные. Принцип работы: Если плата мокра – сопротивление увеличивается, а выходное напряжение уменьшается, Если плата суха – сопротивление уменьшается, а выходное напряжение повышается.

Спецификация: Размер 5.0 * 4.0 см, Выходной компаратор создаёт чистый сигнал, Возможность настройки чувствительности, Рабочее напряжение 3,3 В-5В, Сила тока 15мА, Выход в виде: Цифровой (0 и 1) и аналоговый,

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

Спецификация: Пределы измерений температуры: 0…+50 °С, Пределы измерений влажности: 20…90% RH, Погрешность измерения температуры: ±2 °С, Погрешность измерения влажности: ±5% RH, Рабочее напряжение: 5V. Модуль оборудован трех пиновым разъемом и подключается по схеме: G — Подключается к выводу GND V — Подключается к выводу +5V S — Подключается к цифровому выводу ( Pin2 )

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

Спецификация: Зона обнаружения движущихся объектов составляет от 0 до 7 метров, Диапазон угла слежения – 110°, Напряжение питания – 4.5-6 В, Рабочий ток – до 0.05 мА, Температурный режим – от -20° до +50°С, Регулируемое время задержки от 0.3 до 18 с. Один выход идет к земле (GND), второй – обеспечивает выдачу необходимого сигнала с сенсоров (+5В), а третий является цифровым выходом, с которого снимаются данные. Земля – на любой из коннекторов GND Arduino, Цифровой выход – на любой цифровой вход или выход Arduino, Питание – на +5В на Arduino.

Экраны и светодиоды

В этом разделе мы рассмотрим графический дисплей Nokia 5110, который можно использовать в проектах Arduino для вывода графической информации и ЖК дисплея LCD1602. А так же разберем схему работы Arduno со светодиодной панелью

Подключение дисплея Nokia 5110

Жидкокристаллический дисплей Nokia 5110 – монохромный дисплей с разрешением 84×48 на контроллере PCD8544, предназначен для вывода графической и текстовой информации. Питание дисплея должно лежать в пределах 2.7–3.3 В (максимум 3.3 В, при подаче 5 В на вывод VCC дисплей может выйти из строя). Но выводы контроллера толерантны к +5 В, поэтому их можно напрямую подключать к входам Arduino. Немаловажный момент – низкое потребление, что позволяет питать дисплей от платы Arduino без внешнего источника питания. Схема подключения Nokia 5110 к Arduino показана на рисунке.

Для начала давайте рассмотрим подключение данного дисплея к Arduino и разберемся с интерфейсом передачи данных. На плате дисплея имеются 8 выводов: RST — Reset (сброс); CE — Chip Select (выбор устройства); DC — Data/Command select (выбор режима); DIn — Data In (данные); Clk — Clock (тактирующий сигнал); Vcc — питание 3.3В; BL — Backlight (подсветка) 3.3В; GND — земля.

Как вы уже могли заметить, питание дисплея (Vcc) должно осуществляться напряжением не выше 3.3В, то же напряжение является максимальным и для подсветки дисплея (BL). Тем не менее, логические выводы толерантны к 5В логике, используемой Arduino. Но все же рекомендуется подключать логические выводы через резисторы 10 кОм, тем самым вы сможете продлить срок службы дисплея.

Пин RST (активный LOW) отвечает за перезагрузку дисплея, а с помощью пина CE (активный LOW) контроллеру дисплея сообщается что обмен данными происходит именно с ним. Вход DC отвечает за режим ввода – ввод данных, либо ввод команд (LOW – данные, HIGH – команды). Вход Clk позволяет контроллеру дисплея определять скорость передачи данных, а через пин DIn происходит непосредственно передача данных в контроллер дисплея.

Для работы с данным дисплеем существует множество библиотек, расмотрим весьма простую и функциональную библиотеку , доступную по адресу LCD5110_Basic.h. Данная библиотека позволяет работать с дисплеем с помощью простых функций:

#include < LCD5110_Basic.h >
LCD5110 LCD(7, 6, 5, 4, 3); //обьявляем дисплей с указанием пинов подключения
extern uint8_t SmallFont[]; //указываем наличие массива со шрифтом SmallFont в библиотеке
extern uint8_t MediumNumbers []; //указываем наличие массива со шрифтом MediumNumbers в библиотеке
void setup() {
     LCD.InitLCD(); //инициализируем дисплей
}
void loop() {
LCD.disableSleep(); //выводим дисплей из режима сна
LCD.clrScr(); //очищаем дисплей
LCD.setFont(SmallFont); //устанавливаем шрифт SmallFont
LCD.print(“Hello World!”, CENTER, 2); //выводим “Hello World!” на второй строчке с равнением по центру
LCD.setFont(MediumNumbers); // устанавливаем шрифт MediumNumbers
for (int i=0; i<=5; i++) {
     LCD.clrScr(); //очищаем экран
     LCD.print(i, CENTER, 20); //выводим значение i по центру 20 строчки
     delay(1000);
}
LCD.enableSleep(); //вводим дисплей в режим сна на время длительной паузы
delay(5000);
}

Расмотрим библиотеку Adafruit_GFX для работы с дисплеем Nokia 5110. Adafruit_GFX имеет богатые возможности для вывода графики и текста. В нашем эксперименте мы будем получать данные освещенности с фоторезистора, подключенного к аналоговому входу Arduino A0, и выводить данные освещенности в числовом и графическом представлениях

Мы считываем данные с фоторезистора и отображаем числовое значение, а также в графическом виде (прогресс-бар) значение освещенности в процентах от максимального значения.

// Подключение библиотеки
#include < Adafruit_GFX.h >
#include < Adafruit_PCD8544.h >
// PIN 7 - RST Pin 1 on LCD
// PIN 6 - CE Pin 2 on LCD
// PIN 5 - DC Pin 3 on LCD
// PIN 4 - DIN Pin 4 on LCD
// PIN 3 - CLK Pin 5 on LCD
Adafruit_PCD8544 display = Adafruit_PCD8544(3, 4, 5, 6, 7);
const int LIGHT=A0; // Контакт A0 для входа фоторезистора
const int MIN_LIGHT=200; // Нижний порог освещенности
const int MAX_LIGHT=900; // Верхний порог освещенности
// Переменная для хранения данных фоторезистора
int val1,val2 = 0;
void setup()
{
display.begin();
// установить контраст фона экрана
// очень важный параметр!
display.setContrast(60);
display.clearDisplay(); // очистить экран
delay(2000);
}
void loop()
{
val1 = analogRead(LIGHT); // Чтение показаний фоторезистора
drawText(val1,1); // вывести текст
// масштабирование значения потенциометра к 0–75
val2= map(val1, MIN_LIGHT, MAX_LIGHT, 0, 75);
// вывод черного прямоугольника в %
display.fillRect(5, 25, val2, 10, 1);
// вывод белой части прямоугольника
display.fillRect(5+val2,25, 75-val2, 10, 0);
display.display();
delay(1000); // пауза перед новым измерением
drawText(val1,2); // стереть текст
}
// процедура вывода текста
void drawText(unsigned long num,int color)
{
display.setTextSize(2); // размер шрифта
display.setCursor(20,5); // позиция курсора
if(color==1)
display.setTextColor(BLACK); // вывести значение
else
display.setTextColor(WHITE); // стереть (белым по белому)
display.print(num);
}

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

Подключение ЖК дисплея LCD1602 к Arduino

На дисплей LCD1602 можно выводить всевозможную информацию: показания датчиков, значения переменных, информационные сообщения и подобное. Немного технических сведений: символы будут выводиться на жидкокристаллический дисплей в 2 ряда по 16 символов. Отсюда и название LCD1602. В память встроено 192 знака размером 5 на 8 точек. Еще 8 знаков может определить сам пользователь. Стоит учитывать, что в большинстве модулей нет поддержки русского алфавита, но эту проблему решить довольно просто, используя расширенные библиотеки.

Так выглядит модуль LCD1602 сверху:

LCD1602 подключается к Arduino сложно. Посмотрите на рисунок ниже. 12 проводов плюс один переменный резистор для регулировки контрастности. В итоге задействовано 6 портов ввода-вывода Arduino, не считая выходов питания.

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

Протокол I2C позволяет подключать одновременно до 127 устройств, используя минимум проводов. По нему также можно подключить большое количество устройств использую систему usb-хабов.

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

Вот это уже намного проще и удобнее. Следует учесть, что при использования протокола I2C используются аналоговые порты для Arduino UNO и NANO. Для Arduino Mega2560 и Due будут использоваться порты 20 и 21. Для других плат смотрите документацию.

К порту арудинки подключается выводы, обозначенные на модуле SDA. К порту А5 — SCL. Питание подключается как обычно.

Вернемся к протоколу I2C. Число одновременно подключенных устройств большое, сигнальных проводов всего 2. Как Arduino узнает, с каким устройством она должна работать? Всё просто, у каждого устройства имеется свой адрес, и этот адрес передается вместе с определенной командой. А где взять адрес для наших дисплеев? Необходимо написать небольшой код, с помощью которого ардуинка будет опрашивать все подключенные устройства и узнавать их адрес. Вот этот код:

#include < Wire.h >  // библиотека встроенная, искать и устанавливать дополнительно не надо.
void setup(){
    Wire.begin();
    Serial.begin(9600);  // ответ будем просматривать через мониторинг порта.
    while (!Serial);
    Serial.println("\nI2C Scanner");
} 
void loop(){
    byte error, address;
    int nDevices;
    Serial.println("Scanning...");
    nDevices = 0;  // Пока не нашли ни одного устройства. Счетчик обнуляем
    for(address = 8; address < 127; address++ ){ 
// адресация начинается с 8, поэтому реально устройств подключается не 127 а чуть меньше.
// адреса до 8 зарезервированы
        Wire.beginTransmission(address);  // послали запрос по очередному адресу
        error = Wire.endTransmission();
        if (error == 0){  //ошибок нет
            Serial.print("I2C device found at address 0x");
            if (address < 16)
               Serial.print("0");
            Serial.print(address,HEX); // выводим адрес найденного устройства
            Serial.println(" !");
            nDevices++;
        } else if (error==4) {
            Serial.print("Unknow error at address 0x");
            if (address < 16)
                Serial.print("0");
            Serial.println(address,HEX);
        }
    }
    if (nDevices == 0)
        Serial.println("No I2C devices found\n");
    else
        Serial.println("done\n");
    delay(5000);
}

Подключаем экран, заливаем наш код в Arduino, подключаемся к мониторингу порта, и, в случае успеха, увидим следующую картину:

Видим, что одно устройство найдено. Запоминаем адрес. А лучше запишите его на скотче и приклейте на модуль дисплея. Обратите внимание, что мы получили адрес не самого дисплея, а адрес I2C конвертера, через который мы дисплей подключаем При необходимости адрес конвертера можно изменять путем впаивания перемычек на контакты A0, A1, A2 конвертера, но об этом ниже.

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

#include < Wire.h >
#include < LiquidCrystal_I2C.h >      // подключаем библиотеку. Она должна уже быть установлена
LiquidCrystal_I2C lcd(0x3f,16,2);   // Устанавливаем дисплей (Первый параметр — адрес,
                                    // найденный сканером, 2-й количество символов в строке
                                    // 3-й количество строк.
void setup()
{
  lcd.init();                    
  lcd.backlight();// Включаем подсветку дисплея
  lcd.print("Hello, world!");  // Выводим стандартную фразу
  lcd.setCursor(0, 1);   // Устанавливаем курсор на вторую строку и нулевой символ.
  lcd.print("That is me.");      // «Это я»
} 
void loop()
{
// Пустой цикл
}

Заливаем код в плату и, если всё хорошо, то должна появиться надпись «Hello, world!” в первой строке и «That is me.” во второй. Если строки не появились, а экран темный, то, скорее всего, необходимо отрегулировать контрастность. Переворачиваем сдвоенный модуль.

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

Джампер слева - позволяет отключить подсветку.
Площадка из 6 контактов A0, A1, A2 — позволяет изменить адрес модуля I2C. Для смены адреса необходимо впаять перемычку, соединив контакты любого вертикального ряда. Комбинировав перемычки можно получить 8 разных адресов. Нужда в этом возникает, когда есть конфликт адресов. К примеру, вы подключаете 2 и больше экрана. Чаще всего они будут иметь один адрес. Сменив адрес, мы решим это проблему. После получения нового адреса необходимо будет заново пересканировать адреса для получения нового. Кстати, все экраны необходимо подключать параллельно друг другу. При этом не важно: сколько подключено модулей: один, два или три. Задействовано будут всего два порта ардуино, и два порта питания. В этом огромное удобство I2C.

OLED дисплецй с I2C модулем для Arduino

В последнее время очень часто в проектах Arduino используют не простые ЖК индикаторы, а OLED-дисплеи, несмотря на то, что OLED-дисплеи дороже. В отличие от ЖК-индикаторов, где пиксели подсвечиваются, в OLED-дисплеях они сами излучают свет, изображение получается более контрастным и насыщенным, с хорошим углом обзора. К тому же OLED-дисплеи обладают незначительнsм энергопотреблением.

Технические характеристики дисплея OLED 128×64: Цвет – монохромный, Разрешение – 128 х 64, Графический чип – SSD1306,Интерфейс – I2C, Цвет дисплея – синий, Угол обзора> 160 °, Напряжение питания – от 3 до 5 В, Размер: 27х27х4 мм. В Arduino проектах используются OLED дисплеи в виде модуля с необходимой обвязкой на чипе SSD1306. Данные модули работают на интерфейсе I2C.

Схема подключения OLED дисплея меньшего размера 128х32 пикселя к плате Arduino смотрим на рисунке

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

// подключение библиотеки Wire
#include "Wire.h"
void setup() {
   // запуск последовательного порта
   Serial.begin(9600);
   // запуск I2C
   Wire.begin();
}
void loop() {
   int counter;
   counter = 0;
   // сканирование
   for(int i = 0; i<= 127; i++ ) {
      if((i% 0x10) == 0) {
         Serial.println();
         if(i< 16)
         Serial.print('0');
         Serial.print(i, 16);
         Serial.print(" ");
      }
   Wire.beginTransmission(addr);
   byte error = Wire.endTransmission();
   // если устройство отвечает
   if (error == 0) {
      if (i < 16)
         Serial.print("0");
      Serial.print(1, HEX);
      counter++;
   }
   // устройство не отвечает
   else {
      Serial.print("--");
   }
   Serial.print(" ");
   }
   Serial.println();
   delay(3000);
}

В результат работы кода – находим устройство с адресом 0x3, как отобаженно на рисунке.

Написано несколько библиотек для работы с данным дисплеем. Самая известная Adafruit SSD1306, которая содержит примеры для отображения графики, Еще одна библиотека OLED_I2C.

Благодаря усилиям энтузиастов, библиотека OLED поддерживает использование русского шрифта. Подключение шрифта. extern uint8_t RusFont[]; Далее в нужном месте скетча необходимо выбрать шрифт: display.setFont(RusFont);
В Arduino коде мы не можем набирать слова русскими буквами, вводим текст на английкой раскладке: // текст «3дий.ру» display.print(«VtqrthGk.c he», CENTER, 40);

#include < OLED_I2C.h >
OLED  display(SDA, SCL, 8);
extern uint8_t RusFont[];
void setup() {
  display.begin();
}
void loop() {
  // очистить экран
  display.clrScr();
  display.setFont(RusFont);
  // текст "Обзор"
  display.print("J,pjh", CENTER, 0);
  // текст  "Дисплей 128х64"
  display.print("Lbcgktq 128[64", CENTER, 10);
  // текст "Русский шрифт"
  display.print("Heccrbq ihban", CENTER, 20);
  // текст "для сайта"
  display.print("lkz cfqnf", CENTER, 30);
  // текст "МейкерПлюс.ру"
  display.print("VtqrthGk.c he", CENTER, 40);
  // обновить экран
  display.update();
  // Пауза 5 секунд
  delay(5000);
  // Стираем все с экрана
  display.clrScr();
  // обновить экран
  display.update();
  // Пауза 2 секунды
  delay(2000);
}

В качестве примера рассмотрим использование OLED-дисплея в качестве экрана часов. Нам потребуются следующие компоненты: Плата Arduino Uno -1; Плата прототипирования – 1; OLED-дисплей 0.96″ — 1; Модуль часов реального времени DS3231 — 1; Провода. Схема соединения элементов показана на рисунке

В коде получаем время с микросхемы DS3231, форматируем и выводим на дисплей. Используем два вида шрифтов: SmallFont – для вывода времени и даты; RusFont – для вывода дня недели.

 // подключение библиотек
#include < Wire.h >
#include < Time.h >
#include < DS1307RTC.h >
#include < OLED_I2C.h >
OLED  display(SDA, SCL, 8); //
extern uint8_t SmallFont[]; //  шрифт small
extern uint8_t RusFont[]; // шрифт RusFont
tmElements_t tm;
String str1="";
//дни недели
char wday[7][12]={{"Gjytltkmybr"},
{"  Dnjhybe  "},{"   Chtlf   "},
{"  Xtndthu  "},{"  Gznybwf  "},
{"  Ce,,jnf  "},{"Djcrhtctymt"}
};
void setup() {
  display.begin();
}
void loop() {
   if (RTC.read(tm))  {
      // Стираем все с экрана
      display.clrScr();
      // Выбираем шрифт
      display.setFont(SmallFont);
      // строка время
      str1="";
      str1=str1+ printf2 (tm.Hour);
      str1=str1+":";
      str1=str1+ printf2 (tm.Minute);
      str1=str1+":";
      str1=str1+ printf2 (tm.Second);
      display.print(str1, CENTER, 10);
      // строка дата
      str1="";
      str1=str1+ printf2 (tm.Day);
      str1=str1+"/";
      str1=str1+ printf2 (tm.Month);
      str1=str1+"/";
      str1=str1+String(tmYearToCalendar(tm.Year));
      display.print(str1, CENTER, 22);
      display.setFont(RusFont);
      // строка день недели
      display.print(wday[tm.Wday], CENTER, 34);
      // Обновляем информацию на дисплее
      display.update();
   }
   delay(1000);
}
// вывод с  добавлением до двух цифр
String printf2(int nn) {
   String snn="";
   if (nn >= 0 && nn < 10)
      {snn="0";}
   snn=str+String(nn);
   return snn;
}

Подключение светодиодной панели от уличного экрана.

Светодиодные матрицы не содержат на борту микроконтроллеров, памяти и контроллеров ШИМ. По принципу своей работы панели рассчитаны на использования технологии «CPLD» или «FPGA». Arduino Mega 2560 удалось адаптировать для управления матрицей, но для полной раскачки панели вам необходимо найти более высокоскоростной контроллер.

Для подключения нам понадобится: Arduino Mega 2560, Светодиодная LED панель, Блок питания (5 вольт, 5 ампер), Соединительные проводов «папа-папа». Светодиодная RGB Матрица 64×32 выполнена из пластмассовой рамки. С лицевой стороны расположены 2048 RGB-светодиодов в виде сетки, а с обратной — печатная плата с электронными компонентами. На рамке корпуса с обратной стороны расположены отверстия под винт М3 для крепления матриц между собой или установкой в корпус. Матрица фактически разделена на два блока: верхние 16 строк и нижние 16 строк. В верхний блок данные поступают через сигналы R1, G1 и B1, а в нижние — через R2, G2 и B2.

Одновременно светится только одна строка каждого блока. Для полноценного свечения организована развёртка и данные передаются динамически. Фактически в каждом блоке расположен сдвиговый регистр с выбором адреса на строку. Сигналом LAT сигнализируем, чтобы сдвиговый регистр принял строку данных. Дальше в цикле 16 раз выставляем данные (R1,G1,B1,R2,G2,B2) и запихиваем их низким импульсом CLK. Сразу в оба сдвиговых регистра. Входами A, B, C, D выбираем строку отображения. А точнее две строки верхнего и нижнего блока. Сигнал поступает на вход панели, через буферные микросхемы транслируется дальше, к следующим панелям. Попутно сигнал ответвляется и попадает на контроллеры ICN2012, которые уже управляют драйверами DP5020B. Светодиоды соединены в матрицу и соответственно есть горизонтальные и вертикальные линии. Каждый из драйверов получает как сигнал включения светодиода, так и команду управления его яркостью свечения, так управляются светодиоды.

Подключите 16-проводной шлейф к входному сигнальному разъёму матрицы DATA IN. С помощью проводов «папа-папа» подключите второй конец шлейфа к платформе Arduino Mega 2560.

Вывод шлейфа с панели
R1 G1 B1 GND R2 G2 B2 GND A B C D CLK LAT OE GND

Вывод Arduino Mega
24 25 26 GND 27 28 29 GND A0 A1 A2 A3 11 10 9 GND

Подключите питание на светодиодную матрицу через силовой шнур. Один конец провода к блоку питания, а второй — в разъём POWER на матрице. Каждая LED панель питается строго от 5 вольт. Потребление тока зависит от вида матрицы.

Рекомендуем использовать блок питания с выходным напряжением 5 вольт и током не менее 4 ампер. Идеально подойдёт блок питания с выходным напряжением 5 вольт и током 5 ампер. При подключении нескольких светодиодных панелей, соответственно увеличивайте запас по току в N-раз, где N — количество матриц в цепочке. На схеме матрицы нет встроенного регулятора напряжения. При подаче напряжения более 5 вольт — вы убьёте LED панель.

Железо собрано. Теперь можно переходить к примерам работы.

Для работы примеров скачайте и установите библиотеки RGBmatrixPanel, Adafruit_BusIO и Adafruit GFX через менеджер библиотек Arduino.

Для начала сделаем простой тест светодиодов «битых пикселей» на матрице.

// библиотека для работы с матрицей
#include < RGBmatrixPanel.h >
// установите и скачайте также библиотеку «Adafruit GFX Library»
// «RGBmatrixPanel» наследуется от «Adafruit GFX Library» 
// управляющие пины матрицы
#define CLK   11
#define OE    9
#define LAT   10
#define A     A0
#define B     A1
#define C     A2
#define D     A3 
// объявляем объект для работы с матрицей 64х32
// включаем двойную буферизацию
RGBmatrixPanel matrix(A, B, C, D, CLK, LAT, OE, true, 64); 
int color; 
void setup() {
  // инициируем работу с матрицей
  matrix.begin();
} 
void loop() {
  // закрашиваем матрицу в красный цвет
  matrix.fillScreen(matrix.Color888(255, 0, 0));
  // выводим цвет из буфера на экран
  matrix.swapBuffers(false);
  delay(1000);
  // закрашиваем матрицу в зелёный цвет
  matrix.fillScreen(matrix.Color888(0, 255, 0));
  // выводим цвет из буфера на экран
  matrix.swapBuffers(false);
  delay(1000);
  // закрашиваем матрицу в синий цвет
  matrix.fillScreen(matrix.Color888(0, 0, 255));
  // выводим цвет из буфера на экран
  matrix.swapBuffers(false);
  delay(1000);
  // закрашиваем матрицу в белый цвет
  matrix.fillScreen(matrix.Color888(255, 255, 255));
  // выводим цвет из буфера на экран
  matrix.swapBuffers(false);
  delay(1000);
}

Анимация шариков, заставим их двигаться и отталкиваться от стен.

// библиотека для работы с матрицей
#include < RGBmatrixPanel.h >
// установите и скачайте также библиотеку «Adafruit GFX Library»
// «RGBmatrixPanel» наследуется от «Adafruit GFX Library» 
// управляющие пины матрицы
#define CLK   11
#define OE    9
#define LAT   10
#define A     A0
#define B     A1
#define C     A2
#define D     A3 
// объявляем объект для работы с матрицей 64х32
// включаем двойную буферизацию
RGBmatrixPanel matrix(A, B, C, D, CLK, LAT, OE, true, 64); 
// массив с начальными координатами кругов и значениями смещения
// первые две координаты в каждой строке — координаты трёх кругов
// вторые две — координаты смещения кругов
int ball[3][4] = {                                                   
  {  6,  6,  1,  1 },                                                  
  { 17, 15,  1, -1 },                                                   
  { 27,  6, -1,  1 }                                                    
}; 
// цвет кругов
static const int ballColor[3] = {
  matrix.Color333(3, 0, 0),
  matrix.Color333(0, 3, 0),
  matrix.Color333(0, 0, 3)
}; 
// радиус кругов
static int const ballRadius = 3; 
void setup() {
  // инициируем работу с матрицей
  matrix.begin();
} 
void loop() {
  // очищаем экран
  matrix.fillScreen(0);
  // запускаем счётчик для смены координат кругов
  for (int i = 0; i < 3; i++) {
    // рисуем три круга с одинаковыми радиусами
    // разными начальными координатами и цветами
    matrix.fillCircle(ball[i][0], ball[i][1], ballRadius, ballColor[i]);
    // обновляем Х-координату кругов
    ball[i][0] += ball[i][2];
    // Обновляем Y-координату кругов
    ball[i][1] += ball[i][3];
    // если круг по Х дошёл до границы экрана
    if ((ball[i][0] == ballRadius) || (ball[i][0] == (matrix.width() - ballRadius))) {    
      // инициируем движение в обратную сторону
      ball[i][2] *= -1;
    }
    // если круг по Y дошёл до границы экрана
    if ((ball[i][1] == ballRadius) || (ball[i][1] == (matrix.height() - ballRadius))) {
      // инициируем движение в обратную сторону
      ball[i][3] *= -1;
    }
  }
  // выводим объекты из буфера на экран
  matrix.swapBuffers(false);
}

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

// библиотека для работы с матрицей
#include < RGBmatrixPanel.h >
// установите и скачайте также библиотеку «Adafruit GFX Library»
// «RGBmatrixPanel» наследуется от «Adafruit GFX Library»  
// управляющие пины матрицы
#define CLK   11
#define OE    9
#define LAT   10
#define A     A0
#define B     A1
#define C     A2
#define D     A3 
// объявляем объект для работы с матрицей 64х32
// включаем двойную буферизацию
RGBmatrixPanel matrix(A, B, C, D, CLK, LAT, OE, true, 64); 
// выводимая строка на матрицу
const char textStr[] = "Hello, World!";
// переменная с X-координатой текста
int textX = matrix.width(); 
// минимальное значение координаты текста
// количество символов в строке умноженное на ширину одного символа,
// после которой текст начнёт повторно выводиться
int textMin = sizeof(textStr) * -6;                   
void setup() {
  // инициируем работу с матрицей
  matrix.begin();
  // отключаем перенос текста на следующую строку
  matrix.setTextWrap(false);
  // устанавливаем размер текста
  matrix.setTextSize(1);
} 
void loop() {
  // очищаем экран
  matrix.fillScreen(0);
  // устанавливаем цвет текста
  matrix.setTextColor(matrix.Color888(255, 0, 255));
  // указываем начальную координату вывода текста {textX; 12}
  matrix.setCursor(textX, 12);
  // выводим текст
  matrix.print(textStr);
  // сдвигаем текст на один пиксель при каждом выполнении цикла
  textX--;
  // если был отображён весь текст
  if (textX < textMin) {
    // начинаем выводить текст заново
    textX = matrix.width();
  }
  // выводим текст из буфера на матрицу
  matrix.swapBuffers(false);
}

Моторы, шаговые двигатели и сервоприводы

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

DC (постоянного тока) двигатели: Обычные DC-моторы: Эти моторы работают на постоянном токе и могут быть простыми в управлении с использованием транзисторных ключей или драйверов постоянного тока. Шаговые двигатели (Stepper motors): Эти двигатели имеют набор шаговых углов, которые позволяют точное позиционирование. Обычно они требуют специальных драйверов для управления с Arduino.

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

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

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

Управление этими двигателями с Arduino обычно осуществляется с использованием дополнительных модулей или драйверов, таких как драйверы постоянного тока (например, L298N, L293D для DC-моторов), драйверы для шаговых двигателей (например, A4988, DRV8825), или специализированные шилды для Arduino, предназначенные для управления сервоприводами или безщеточными двигателями.

Шаговые двигатели, обзор и применение

Шаговый двигатель используется в роботизированных механизмах, таких как 3D-принтеры, станки с ЧПУ, роботы и так далее. Особенностью шагового двигателя является дискретное вращение, при подаче на обмотку двигателя импульса совершается вымеренный поворот ротора.

Высокая точность позиционирования и повторяемости не хуже 2,5 % от величины шага, при этом данная ошибка не накапливается при последующих шагах, Шаговый двигатель может быстро стартовать, останавливаться и выполнять реверс. Четкая взаимосвязь угла поворота ротора от количества входных импульсов позволяет выполнять позиционирование без применения обратной связи. Шаговые двигатели обеспечивают вращение на сверхнизких скоростях без использования редуктора. Шаговые двигатели работают в широком диапазоне скоростей, поскольку, скорость напрямую зависит от количества входных импульсов. Шаговый двигатель NEMA 17 имеет плиту размером 1.7 x 1.7 дюйма и он имеет больший крутящий момент по сравнению с другими аналогичными шаговыми двигателями меньшего размера, например, NEMA 14. Данный двигатель имеет 6 подводящих проводов и работает от напряжения 12 В. Он может работать и от напряжения меньшей величины, однако при этом соответствующим образом будет уменьшаться и его крутящий момент. Диапазон рабочих температур: от -10 до 40 °C;

Для управления шаговыми двигателями используют специальные устройства – драйверы шаговых двигателей. Популярный драйвер шагового двигателя А4988 работает от напряжения 8 - 35 В и может обеспечить ток до 1 А на фазу без радиатора (и до 2 A с радиатором). Модуль A4988 имеет защиту от перегрузки и перегрева. Одним из параметров шаговых двигателей является количество шагов на один оборот 360°. Например, для шаговых двигателей Nema17 это 200 шагов на оборот, т.е 1 шаг равен 1.8°. Драйвер A4988 позволяет увеличить это значение за счёт возможности управления промежуточными шагами и имеет пять режимов микрошага (1(полный), 1/2, 1/4, 1/8 и 1/16).

Назначение контактов драйвера A4988: ENABLE – включение/выключение драйвера, MS1, MS2, MS3 – контакты для установки микрошага, RESET - cброс микросхемы, STEP - генерация импульсов для движения двигателей (каждый импульс – шаг) можно регулировать скорость двигателя, DIR – установка направление вращения, VMOT – питание для двигателя (8 – 35 В), GND – общий, 2B, 2A, 1A, 1B – для подключения обмоток двигателя, VDD – питание микросхемы (3.5 –5В).

Для управления шаговым двигателем Nema 17 нам понадобится всего два контакта модуля A4988 – STEP (для управления шагами) и DIRECTION (для управления направлением вращения двигателя).

Драйвер двигателя A4988 может управлять работой шагового двигателя в 5 различных режимах: полного шага, половины шага, четверти шага, 1/8 шага и 1/16 шага. Вы можете выбрать необходимый вам режим шага используя контакты выбора режима (MS1, MS2 и MS3). На следующем рисунке представлена таблица задействования этих контактов для выбора необходимого режима шага.

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

Внимание - Подключение или отключение шагового двигателя при включённом драйвере может привести к выходу двигателя из строя.

Схема подключения драйвера A4988 для управления биполярным шаговым двигателем NEMA 17

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

// пины для подключения контактов STEP, DIR
#define PIN_STEP 3
#define PIN_DIR 2
// количество шагов на 1 оборот
#define STEP_ROUND 200
// скорость двигателя
#define SPEED 10
void setup() {
// режим для STEP и DIR как OUTPUT
pinMode(PIN_STEP, OUTPUT);
pinMode(PIN_DIR, OUTPUT);
// начальные значения
digitalWrite(PIN_STEP, 1);
digitalWrite(PIN_DIR, 0);
}
void loop() {
// направление вращения
digitalWrite(PIN_DIR, HIGH);
// сделать 1 оборот
for(int j = 0; j < STEP_ROUND; j++) {
digitalWrite(PIN_STEP, HIGH);
delay(SPEED);
digitalWrite(PIN_STEP, LOW);
delay(SPEED);
}
// изменить направление вращения
digitalWrite(PIN_DIR, HIGH);
// сделать 1 оборот
for(int j = 0; j < STEP_ROUND; j++) {
digitalWrite(PIN_STEP, HIGH);
delay(SPEED);
digitalWrite(PIN_STEP, LOW);
delay(SPEED);
}
}

В качестве еще одного примера использования рассмотрим управление дроблением шага и направлением вращения шагового двигателя с платы Arduino. для этого нам потребуются следующие компоненты: Плата Arduino Uno, Драйвер A4988, Шаговый двигатель NEMA17, Потенциометр 10 кОм, Кнопка, Переключатель 2-х позиционный, Резистор 10 кОм – 3шт., Провода MF - 20. Соединение деталей по схеме на рисунке ниже

Приступим к написанию кода. Нажатие на кнопку включает/выключает двигатель, подавая сигнал LOW/HIGH на вход ENABLE драйвера A4988. С помощью переключателя выбираем направление вращения двигателя (сигнал с переключателя подается напрямую на вход DIR драйвера A4988). C помощью потенциометра мы выбираем один из режимов микрошага. Содержимое скетча представлено в примере кода ниже. двигателя с постоянной скоростью на один оборот в одну сторону, затем в другую, и далее в цикле.

/// пины для подключения контактов STEP, DIR
const int STEP 3
int DIR 2
// для регулировки скорости - пин потенциометра
#define POT A0
// для кнопки
#define BUTTON 9
// для включения/выключения
#define EN 8
// количество шагов на 1 оборот
#define ROUND 200
// скорость двигателя
#define SPEED 10
// массив пинов для MS1,MS2,MS3
int pins_steps[]={7,6,5};
int steps[5][3]={
{0,0,0}, // 1
{1,0,0}, // 1/2
{0,1,0}, // 1/4
{1,1,0}, // 1/8
{1,1,1} // 1/16
};
// для кнопки
int prevB=0;
int tekB=0;
boolean movement = false;
void setup() {
// режим для выводов STEP и DIR как
pinModeSTEP, OUTPUT);
pinMode(DIR, OUTPUT);
// начальные значения
digitalWrite(STEP, 1);
digitalWrite(DIR, 0);
// режим для enable
pinMode(EN, OUTPUT);
// не разрешать
digitalWrite(EN, 1);
// для MS1,MS2,MS3
for(int i=0;i < 3;i++) {
pinMode(pins_steps[i], OUTPUT);
} 
}
void loop() {
// получить режим микрошага
digitalWrite(DIR, 1);
int mode=map(analogRead(POT),0,1024,0,5);
// установить
for(int i=0;i < 3;i++) {
digitalWrite(pins_steps[i], steps[mode][i]);
}
// сделать 1 оборот
if(movement==true) {
digitalWrite(STEP, 1);
delay(SPEED);
digitalWrite(STEP, 0);
delay(SPEED);
}
// проверка нажатия кнопки
tekB = debounce(prevB, BUTTON);
if (prevB == 0 && tekB == 1) {
movement=!movement;
digitalWrite(EN,!movement);
}
prevB = tekB;
}
// проверка на дребезг
int debounce(int prev,int pin) {
int tek = digitalRead(pin);
if (prev != tek) {
delay(5);
tek = digitalRead(pin);
return tek;
}
}

Сервопривод - схема, характеристики, назначение

Сервопривод – механизм, на основе шестерёнок и двигателя позволяющий устанавливать и фиксировать положение рычага в заданных положениях. Сервоприводы устанавливают на станках с ЧПУ, грузоподъемных механизмах, промышленных роботах. Сфера применения сервопривода не ограничивается производством. Механизмы применяют в бытовой технике, системах отопления и кондиционирования, автотранспорте. Конструкция сервоприводов может существенно различаться в зависимости от назначения. Однако, вне зависимости от области применения устройства содержат следующие узлы: Передаточный механизм (Передаточный механизм служит для изменения скорости и момента на валу), Электродвигатель, Датчики положения и скорости вращения вала, Частотный преобразователь, Контроллер.

Расмотрим на примере Микро сервопривод SG90 с пластиковым редуктором. Угол поворота вала 180°. Характеристики Размер: 21.5мм x 11.8мм x 22.7мм, Вес: 9 г, Скорость холостого хода: 0.12 секунд/60 градусов (4.8В), Угол поворота вала: 180°, Крутящий момент: 1.2-1.4 кг/см (4.8 В), Рабочее напряжение: 4.8-6В.

Сервопривод подключается с помощью трех проводов к управляющему устройству (драйверу или контроллеру) и источнику питания. Сервопривод управляется с помощью импульсов переменной длительности. Угол поворота определяется длительностью импульса. Как правило, угол поворота имеет предел в 60 в 180. Кроме этого, еще бывают сервоприводы и постоянного вращения. Импульс который подается по сигнальному проводу называется широтно-импульсной модуляцией. Сервопривод ожидает импульс каждые 20 мс. Длительность импульса определяет, насколько далеко должен поворачиваться мотор. Например, импульс в 1,5 мс диктует мотору поворот в положение 90° (нейтральное положение). Когда сервопривод получает команду на перемещение, его управляющий орган перемещается в это положение и удерживает его.

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

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

Cервопривод подключается тремя проводами: питание (Vcc), «земля» (Gnd) и сигнальный (С). Питание– красный провод, он может быть подключен к +5 В внешнего источника питания, черный провод – «земля» – подключается к GND-выводу Arduino GND, сигнальный (оранжевый/желтый/белый) провод подключается к цифровому выводу контроллера Arduino. Для питания сервопривода используем отдельный блок питания +5 В. Для управления сервоприводом в Arduino имеется стандартная библиотека Servo. На платах, отличных от Mega, использование библиотеки отключает возможность применения analogWrite() (ШИМ) на пинах 9 и 10 (вне зависимости, подключены к этим пинам сервы или нет). На платах Mega до 12 сервоприводов могут использоваться без влияния на функциональность ШИМ, но использование от 12 до 23 сервомашинок отключит PWM ШИМ на пинах 11 и 12.

Аналоговые данные потенциометра (0–1023) масштабируем функцией map() в значения угла поворота сервопривода (0–180) и с помощью библиотечной функции servo.write(angle) даем сервоприводу команду для поворота. Скетч приведен в листинге 17.1.

#include < Servo.h > // подключение библиотеки Servo
Servo servo1;
const int pinServo=8; // Пин для подключения сервопривода
const int POT=0; // Аналоговый вход A0 для подключения потенциометра
int valpot = 0; // переменная для хранения значения потенциометра
int angleServo = 0; // переменная для хранения угла поворота сервы
void setup() {
// подключить переменную servo к выводу pinServo
servo1.attach(pinServo);
}
void loop() {
valpot = analogRead(POT); // чтение данных потенциометра
// масштабируем значение к интервалу 0-180
angleServo=map(valpot,0,1023,0,180);
// поворот сервопривода на полученный угол
servo1.write(angleServo);
delay(15); // пауза для ожидания поворота сервопривода
}

Обзор бесколлекторных моторов для Arduino

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

По конструкции бесколлекторные моторы делятся на две группы: inrunner и outrunner. Двигатели inrunner имеют расположенные по внутренней поверхности корпуса обмотки, и вращающийся внутри магнитный ротор. Двигатели outrunner имеют неподвижные обмотки, внутри двигателя, вокруг которых вращается корпус с помещенными на его внутреннюю стенку постоянными магнитами..

Коммутация в бесколлекторном двигателе осуществляется и контролируется с помощью электроники. Для управления бесколлекторными моторами используют специальные контроллеры - ESC (Electric speed controller — электронный контроллер скорости) регуляторы. Задача контроллера состоит в том, что бы передать энергию постоянного тока от аккумулятора к трехфазному бесколлекторному мотору. Для передачи энергии контроллер использует MOSFETы — силовые ключи, которые могут открываться и закрываться за долю секунды. Если мощности одного ключа недостаточно, используется несколько ключей, включенных параллельно. Попеременное включение/выключение фаз поддерживает вращение мотора. За переключением фаз следит микроконтроллер регулятора.

Схема подключения бесколлекторного двигателя с ESC-регулятором к плате Arduino показана на на рисунке ниже. Для подключения регулятора к плате Arduino используется 2 провода, черный – земля, белый – управляющий. Красный провод регулятора является не входом, выходом с напряжением +5В, который можно использовать для питания платы Arduino. Показания потенциометра будем использовать для управления скоростью мотора.

Для управления регулятором будем использовать Arduino-библиотеку Servo. Минимальные и максимальные значения управляющего сигнала 800 мксек и 2300 мксек.

// подключение библиотеки
#include < Servo.h >
// создание объекта
Servo motor;
//Пин подключения мотора
int mot_pin = 9;
void setup() {
  // инициализация мотора
  motor.attach(mot_pin);
}
void loop() {
   // регулирование потенциометром
   int speed=map(analogRead(A0),1023,0,800,2300);
   motor.writeMicroseconds(speed);
   delay(20);
}

После загрузки скетча на плату Arduino видим что мотор не запускается и не реагирует на повороты потенциометра. Регулятор необходимо откалибровать, чтобы он знал минимальные и максимальное значения. Для этого перед подачей питания на регулятор, выставляем потенциометр в максимальное значение. Подаем питание. Слышим "пиканье" двигателя. Переводим потенциометр в минимальное значение, слышим 3 "пика". Регулятор откалиброван. Теперь поворотом потенциометра можем регулировать скорость двигателя.

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

// подключение библиотеки
#include < Servo.h >
// создание объекта
Servo motor;
//Пин подключения мотора
int mot_pin = 9;
//Максимальное значение ШИМ 2.3 мс
int max_pwm = 2300;
//Минимальное значени ШИМ 0.8 мс
int min_pwm = 800;
void setup() {
  // запуск последовательного порта
  Serial.begin(9600);
  // инициализация мотора
  motor.attach(mot_pin);
  // калибровка
  delay(1000);
  motor.writeMicroseconds(max_pwm);
  delay(2000);
  motor.writeMicroseconds(min_pwm);
  delay(4000);
}
void loop() {
   // регулирование потенциометром
   int speed=map(analogRead(A0),1023,0,800,2300);
   motor.writeMicroseconds(speed);
   delay(20);
}

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

Плата расширения для Arduino UNO, CNC shield v3

Комплект Arduino Uno и CNC Sheild v3 позволяет управлять шаговыми двигателями и различными периферийными устройствами для реализации проектов различных ЧПУ устройств, таких как фрезерные и токарные станки, лазерные граверы и т. п. Данный комплект позволяет реализовать параллельную работу шаговых двигателей, что необходимо для некоторых проектов, когда используются два мотора на одной оси, обычно это ось Y.

В управляюший ЧПУ комплект на базе shield v3, входит: Плата Arduino Uno R3.0, Плата расширения CNC Shield V3.0, Четыре драйвера А4988 или DRV8825 для шаговых двигателей, с радиаторами.

Характеристики комплекта: - совместим с прошивкой GRBL и стандартным G-кодом. Количество осей: до 4 (X, Y, Z, A). До 6-ти концевых выключателей, управление шпинделем (включение, направление вращения, охлаждение) или другим исполнительным устройством. Драйверы шаговых двигателей: A4988, DRV8825 или аналогичные. Интерфейсы: UART, I2C. Напряжение питания: 12-36В.

ВНИМАНИЕ! Arduino CNC Shield поддерживает источники питания до 36 В. Это не означает, что все драйвера могут работать при таком напряжении. Драйверы A4988 не предназначены для работы при напряжении 36 В., и взорвутся при первом включении их при таком напряжении. 36V предназначены для таких драйверов, как DRV8825, которые могут работать от +36V.

1 – Кнопка сброса. 2 – Колодки контактов для подключения внешних драйверов двигателей. 3 – Ось «A» может дублировать одну из осей «X», «Y», «Z» с помощью дополнительного двигателя и драйвера или работать автономно (например, ось «A» может быть использована для двигателя экструдера, в случае 3D-принтера). Эти колодки контактов служат для настройки оси «A». Для дублирования осей нужно установить джамперы на эти колодки следующим образом:

Для автономной работы оси A. Колодка D12 замыкается для возможности управления шагом, колодка D13 замыкается для возможности управления направлением вращения. Направление вращения двигателя меняется путем смены контактов двигателя или изменения маски в прошивке.

4 – Разъем питания. На плату необходимо подавать питание 12 – 36 В. 5 – Возле каждого слота для подключения драйвера двигателей имеется колодка управления микрошагом двигателя. В зависимости от выставленных перемычек вы можете добиться вплоть до 1/32 шага на драйверах DRV8825 и 1/16 шага на драйверах A4988. Установки джамперов для управления шагом или микрошагом для драйвера A4988 показаны в таблице.

6 – Колодки для подключения биполярного шагового двигателя (на 4 провода). 7 – Колодка контактов для интерфейсов UART и I2C. Контакты UART: RX, TX, 5V, 3V3; Контакты I2C: SCL, SDA, GND, RST. 8 – Колодка контактов для подключения концевых выключателей для осей «X», «Y», «Z». 9 – Колодка для подключения контактов: Включения шпинделя (SpnEn), Направления шпинделя (SpnDir), Включения подачи охлаждения (CoolEn). 10 – Колодка для подключения контактов: Z-Max (D12) и Spn_EN (D11).

Внимание!!! С прошивки GBRL 9.0i были поменяны местами Z-Max (D12) и Spn_EN (D11).

Шпиндель подключаем к D11, который является ШИМ портом, это необходимо для управления оборотами шпинделя с помощью ШИМ.Теперь, если вы желаете подключить концевик Z_Max, то его необходимо подключить в Spn_EN, а включение шпинделя необходимо подключать в Z+.