Многозадачная ардуина: таймеры без боли

Содержание

Важные страницы

  • Набор GyverKIT – большой стартовый набор Arduino моей разработки, продаётся в России
  • Каталог ссылок на дешёвые Ардуины, датчики, модули и прочие железки с AliExpress у проверенных продавцов
  • Подборка библиотек для Arduino, самых интересных и полезных, официальных и не очень
  • Полная документация по языку Ардуино, все встроенные функции и макро, все доступные типы данных
  • Сборник полезных алгоритмов для написания скетчей: структура кода, таймеры, фильтры, парсинг данных
  • Видео уроки по программированию Arduino с канала “Заметки Ардуинщика” – одни из самых подробных в рунете
  • Поддержать автора за работу над уроками
  • Обратная связь – сообщить об ошибке в уроке или предложить дополнение по тексту (alex@alexgyver.ru)

Резюме

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

«>

Таймер

Диапазон таймера можно регулировать вверх или вниз от 14400 с помощью переменной задержки.

Максимальное время ожидания составляет примерно 4 часа. Также можно настроить уровень освещенности, при котором срабатывает реле. Изначально значение переменной (яркость) было установлено на 5, но при повышении этого значения свет будет активироваться при более высоком уровне освещенности.

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

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

Затем он преобразуется с помощью функции » map » в диапазон от 0 до 100. Вы можете попробовать варьировать диапазон до (0-50) с помощью этого кода:

или (0-250) с помощью этого:

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

Модифицированные библиотеки от Paul Stoffregen

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

Плата ШИМ выводы TimerOne ШИМ выводы TimerThree
Teensy 3.1 3, 4 25, 32
Teensy 3.0 3, 4  
Teensy 2.0 4, 14, 15 9
Teensy++ 2.0 25, 26, 27 14, 15, 16
Arduino Uno 9, 10  
Arduino Leonardo 9, 10, 11 5
Arduino Mega 11, 12, 13 2, 3, 5
Wiring-S 4, 5  
Sanguino 12, 13  

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

Возобновляет работу остановленного таймера. Новый период не начинается.

Step 5: Example 3: DAC

In this project I used a timer interrupt to output a sine wave of a specific frequency from the Arduino. I soldered a simple 8 bit R2R DAC to digital pins 0-7.  This DAC was constructed from 10k and 20k resistors arranged in a multi-leveled voltage divider.  I’ll be posting more about the construction of the DAC in another instructable, for now I’ve included the photo’s above.
I connected the output from the DAC up to an oscilloscope.  If you need help understanding how to use/read the oscilloscope check out this tutorial.  I loaded the following code onto the Arduino:

//63Hz sine wave
//by Amanda Ghassaei 2012
//https://www.instructables.com/id/Arduino-Timer-Interrupts/

/*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
*/

//sends 63Hz sine wave to arduino PORTD DAC
float t = 0;

void setup() {
  //set port/pin  mode. see http://www.arduino.cc/en/Reference/PortManipulation for more info
  DDRD = 0xFF;//port d (digital pins 0-7) all outputs
 
  cli();//stop interrupts

  //set timer2 interrupt at 40kHz
  TCCR2A = 0;// set entire TCCR2A register to 0
  TCCR2B = 0;// same for TCCR2B
  TCNT2  = 0;//initialize counter value to 0
  // set compare match register for 40khz increments
  OCR2A = 49;// = (16*10^6) / (8*40000)-1
  // turn on CTC mode
  TCCR2A |= (1 << WGM21);
  // Set CS21 bit for 8 prescaler
  TCCR2B |= (1 << CS21);  
  // enable timer compare interrupt
  TIMSK2 |= (1 << OCIE2A);
 
  sei();//allow interrupts
}

ISR(TIMER2_COMPA_vect) {
  //increment t
  t+=1;
  if (t==628){//40kHz/628 =~ 63Hz
    t=0;
  }
}


void loop(){
  //sine wave of frequency ~63Hz
  //send sine values to PORTD between 0 and 255
  PORTD=byte(127+127*sin(t/100));
}

I set up a timer interrupt that increments the variable t at a frequency of 40kHz.  Once t reaches 627 it resets back to zero (this happens with a frequency of 40,000/628 = 63Hz).  Meanwhile, in the main loop the Arduino sends a value between 0 (00000000 in binary) and 255 (11111111 in binary) to digital pins 0 through 7 (PORTD).  It calculates this value with the following equation:PORTD=byte(127+127*sin(t/100));
So as t increments from 0 to 627 the sine function moves through one complete cycle.  The value sent to PORTD is a sine wave with frequency 63Hz and amplitude 127, oscillating around 127.  When this is sent through the 8 bit resistor ladder DAC it outputs an oscillating signal around 2.5V with an amplitude of 2.5V and frequency of 63Hz.
The frequency of the sine wave can be doubled by multiplying the (t/100) term by 2, quadrupled by multiplying by 4, and so on…
Also notice that if you increase the frequency of the timer interrupt too much by decreasing the prescaler or OCR2A the sine wave will not output correctly.  This is because the sin() function is computationally expensive, and at high interrupt frequencies it does not have enough time to execute.  If you are using high frequency interrupts, instead of performing a computation during the interrupt routine, considering storing values in an array and simply calling these values using some kind of index.  You can find an example of that in my arduino waveform generator- by storing 20,000 values of sin in an array, I was able to output sine waves with a sampling frequency of 100kHz.

Прерывания в языке Arduino

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

Синтаксис attachInterrupt()

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

Синтаксис вызова: attachInterrupt(interrupt, function, mode)

Аргументы функции:

interrupt – номер вызываемого прерывания (стандартно 0 – для 2-го пина, для платы Ардуино Уно 1 – для 3-го пина),
function – название вызываемой функции при прерывании(важно – функция не должна ни принимать, ни возвращать какие-либо значения),
mode – условие срабатывания прерывания.

Возможна установка следующих вариантов условий срабатывания:

  • LOW – выполняется по низкому уровню сигнала, когда на контакте нулевое значение. Прерывание может циклично повторяться – например, при нажатой кнопке.
  • CHANGE – по фронту, прерывание происходит при изменении сигнала с высокого на низкий или наоборот. Выполняется один раз при любой смене сигнала.
  • RISING – выполнение прерывания один раз при изменении сигнала от LOW к HIGH.
  • FALLING – выполнение прерывания один раз при изменении сигнала от HIGH к LOW.4

Важные замечания

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

  • Функция – обработчик не должна выполняться слишком долго. Все дело в том, что Ардуино не может обрабатывать несколько прерываний одновременно. Пока выполняется ваша функция-обработчик, все остальные прерывания останутся без внимания и вы можете пропустить важные события. Если надо делать что-то большое – просто передавайте обработку событий в основном цикле loop(). В обработчике вы можете лишь устанавливать флаг события, а в loop – проверять флаг и обрабатывать его.
  • Нужно быть очень аккуратными с переменными. Интеллектуальный компилятор C++ может “пере оптимизировать” вашу программу – убрать не нужные, на его взгляд, переменные. Компилятор просто не увидит, что вы устанавливаете какие-то переменные в одной части, а используете – в другой. Для устранения такой вероятности в случае с базовыми типами данных можно использовать ключевое слово volatile, например так: volatile boolean state = 0. Но этот метод не сработает со сложными структурами данных. Так что надо быть всегда на чеку.
  • Не рекомендуется использовать большое количество прерываний (старайтесь не использовать более 6-8). Большое количество разнообразных событий требует серьезного усложнения кода, а, значит,   ведет к ошибкам. К тому же надо понимать, что ни о какой временной точности исполнения в системах с большим количеством прерываний речи быть не может – вы никогда точно не поймете, каков промежуток между вызовами важных для вас команд.
  • В обработчиках категорически нельзя использовать delay(). Механизм определения интервала задержки использует таймеры, а они тоже работают на прерываниях, которые заблокирует ваш обработчик. В итоге все будут ждать всех и программа зависнет. По этой же причине нельзя использовать протоколы связи, основанные на прерываниях (например, i2c).

Blinking LED with timer overflow interrupt

same example like before but now we use the timer overflow interrupt. In this case Timer1 is running in normal mode.

The timer must be pre loaded every time in the interrupt service routine.

/*
* timer and interrupts
* Timer1 overflow interrupt example
* more infos: https://oscarliang.com
*/

#define ledPin 13

void setup()
{
pinMode(ledPin, OUTPUT);

// initialize Timer1
noInterrupts(); // disable all interrupts
TCCR1A = 0;
TCCR1B = 0;

TCNT1 = 34286; // preload timer 65536-16MHz/256/2Hz
TCCR1B |= (1 &lt;&lt; CS12); // 256 prescaler
TIMSK1 |= (1 &lt;&lt; TOIE1); // enable timer overflow interrupt
interrupts(); // enable all interrupts
}

ISR(Timer1_OVF_vect) // interrupt service routine that wraps a user defined function supplied by attachInterrupt
{
TCNT1 = 34286; // preload timer
digitalWrite(ledPin, digitalRead(ledPin) ^ 1);
}

void loop()
{
// your program here…
}

Схема таймера на двух транзисторах

Нетрудно собрать реле времени своими руками на двух транзисторах. Оно начинает работать, если подать питание на конденсатор С1, после чего начнется его зарядка. При этом ток базы открывает транзистор VT1. Вслед за ним откроется VT2, и электромагнит замыкает контакт, подавая питание на светодиод. По его свечению будет видно, что сработало реле времени. Схема обеспечивает переключение нагрузки R4.

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

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

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

Минимальные частоты и разрядность таймеров

Варианты вызовов timer_init_ISR_2Hz (2Гц, период 500мс) и timer_init_ISR_1Hz (1Гц, период 1с) на PIC32MX 80МГц будут работать только с 32-битными таймерами (_TIMER2_32BIT и _TIMER4_32BIT; TIMER_DEFAULT — по умолчанию = _TIMER4_32BIT), т.к. при 16-битных режимах таймеров PIC32MX 80МГц комбинация «делитель частоты» (prescaler — максимальный вариант 1/256) + «поправка периода» (adjustment — максимальный вариант 2^16=65536-1) дают минимальную частоту 5Гц (период — 200мс):
80000000/256/65536 = 4.8Гц

На PIC32 32-битные таймеры создаются комбинацией 2х 16-битных таймеров:

  • Timer4(32бит) = Timer4(16бит)+Timer5(16бит)
  • Timer2(32бит) = Timer2(16бит)+Timer3(16бит)

поэтому при использовании таймера _TIMER2_32BIT, обычные таймеры _TIMER2 и _TIMER3 будут заняты, при использовании _TIMER4_32BIT — заняты будут _TIMER4 и _TIMER5.

На AVR/Arduino можно получить частоту 1Гц стандартными делителями на 16-битном таймере.

На SAM/Arduino Due все таймеры 32-битные.

Тип данных для параметра adjustment — unsigned int.

  • На PIC32 разрядность int — 32 бит, этого хватит и для 16-тибитного режима таймера (если не закладывать значение более 2^16=65536-1) и для 32-битного (пойдет любое значение до 2^32=4294967296-1).
  • На SAM разрядность int — 32 бит, все таймеры 32-битные.
  • На AVR разрядность int — 16 бит, это опять же, как раз достаточно для 16-битных таймеров.

Таким образом, хотя разрядность параметра adjustment с типом int будет разной на разных платформах, во всех случаях значение будет соответствовать аппаратным свойствам таймеров.

Простейший вариант

Пример конструктора для самодельной сборки таймера задержки отключения:

При желании возможно самостоятельно собрать реле времени по следующей схеме:

Времязадающим элементом является конденсатор С1, в стандартной комплектации КИТ-набора он имеет следующие характеристики: 1000 мкФ/16 В, время задержки в этом случае составляет приблизительно 10 минут. Регулировка времени осуществляется переменным резистором R1. Питание платы 12 Вольт. Управление нагрузкой производится через контакты реле. Плату можно не делать, а собрать на макетной плате или навесным монтажом.

Для того, чтобы сделать реле времени, нам понадобятся следующие детали:

Правильно собранное устройство не нуждается в настройке и готово к работе. Данное самодельное реле задержки времени было описано в журнале «Радиодело» 2005.07.

Выбор таймера

На всех платформах доступно значение TIMER_DEFAULT, которое указывает на рабочий таймер по умолчанию.

Если есть необходимость использовать другой таймер, можно указать его имя напрямую: _TIMER1…TIMER9, _TIMER1_32BIT…_TIMER9_32BIT

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

Доступные таймеры:

  • AVR ATmega1280, ATmega2560: _TIMER1, _TIMER3,_TIMER4, _TIMER5; TIMER_DEFAULT = _TIMER5

  • AVR AT90USB646, AT90USB1286, ATmega128, ATmega1281, ATmega1284, ATmega1284P, AVR_ATmega2561: _TIMER1, _TIMER3; TIMER_DEFAULT = _TIMER3

  • AVR ATmega32U4: _TIMER1; TIMER_DEFAULT = _TIMER1

  • AVR другие чипы: _TIMER1; TIMER_DEFAULT = _TIMER1

  • PIC32 (ChipKIT): _TIMER1, _TIMER2, _TIMER3, _TIMER4, _TIMER5, _TIMER2_32BIT, _TIMER4_32BIT; TIMER_DEFAULT = _TIMER4_32BIT

  • SAM (Arduino Due): _TIMER1/_TIMER1_32BIT, _TIMER2/_TIMER2_32BIT, _TIMER3/_TIMER3_32BIT, _TIMER4/_TIMER4_32BIT, _TIMER5/_TIMER5_32BIT, _TIMER6/_TIMER6_32BIT, _TIMER7/_TIMER7_32BIT, _TIMER8/_TIMER8_32BIT, _TIMER9/_TIMER9_32BIT (все таймеры 32-битные, _TIMERX_32BIT == _TIMERX); TIMER_DEFAULT = _TIMER3/_TIMER3_32BIT;

Проблемы с контекстом прерываний

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

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

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

Ардуино задержка включения / выключения

Для этого занятия нам потребуется:

плата Arduino Uno / Arduino Nano / Arduino Mega.

В этой записи мы рассмотрим только основные характеристики функций задержки, а примеры использования представим в виде небольших скетчей. Для работы вам потребуется только сама плата Ардуино. Начнем обзор с delayMicroseconds Arduino, т.к. данную функцию не часто можно встретить в программах, а также рассмотрим, как заменить задержку delay на millis в программировании Arduino IDE.

Ардуино delayMicroseconds()

Команда delayMicroseconds останавливает выполнение программы на заданное количество микросекунд (в 1 секунде 1 000 000 микросекунд). При необходимости задержки в программе более чем на несколько тысяч микросекунд рекомендуется использовать delay(). Продемонстрируем на простом примере использование функции в скетче для мигания встроенным светодиодом на плате Arduino.

// пример использования delayMicroseconds() для мигания светодиодом
void setup() {
   pinMode(13, OUTPUT);
}
 
void loop() {
   digitalWrite(13, HIGH);      // подаем сигнал HIGH на выход
   delayMicroseconds(100);  // задержка 100 микросекунд
   digitalWrite(13, LOW);       // подаем сигнал LOW на выход
   delayMicroseconds(100);  // задержка 100 микросекунд
}

Ардуино delay()

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

// пример использования delay() для мигания светодиодом
void setup() {
   pinMode(13, OUTPUT);
}
 
void loop() {
   digitalWrite(13, HIGH);   // подаем сигнал HIGH на выход
   delay(100);                        // задержка 100 миллисекунд
   digitalWrite(13, LOW);    // подаем сигнал LOW на выход
   delay(100);                        // задержка 100 миллисекунд
}

Ардуино millis()

Команда millis возвращает количество прошедших миллисекунд с момента начала выполнения программы. Счетчик времени сбрасывается на ноль при переполнении значения unsigned long (приблизительно через 50 дней). Функция miilis позволяет сделать многозадачность Ардуино, так как выполнение программы не останавливается и можно выполнять параллельно другие операции в скетче.

// пример использования millis() при мигании светодиодом
unsigned long timer;

void setup() {
   pinMode(13, OUTPUT);
   Serial.begin(9600);         // запускаем монитор порта
}
 
void loop() {
   timer = millis();                 // запускаем отсчет времени

   digitalWrite(13, HIGH);   // подаем сигнал HIGH на выход
   delay(1000);                      // задержка 1 секунда
   digitalWrite(13, LOW);    // подаем сигнал LOW на выход
   delay(1000);                      // задержка 1 секунда

   // выводим количество миллисекунд прошедших с момента начала программы
   Serial.print("Time: ");
   Serial.println(timer);
}

Arduino команды millis, delay, delaymicroseconds

Кухонный таймер Ардуино с энкодером

Сейчас рассмотрим, как сделать таймер на Ардуино своими руками с энкодером и LCD. Принцип управления, подобен предыдущему варианту. Поворотом ручки энкодера можно задать необходимый временной интервал, а нажатием на ручку можно запускать и останавливать обратный отсчет времени. Далее размещена схема сборки проекта на Arduino Nano, этот проект можно собрать и на плате Arduino Uno.

Скетч таймера обратного отсчета времени

#include <Wire.h>                              // библиотека для протокола I2C
#include <LiquidCrystal_I2C.h>        // библиотека для LCD 1602 
LiquidCrystal_I2C LCD(0x27, 20, 2);  // присваиваем имя дисплею

#include <RotaryEncoder.h>                // библиотека для энкодера
RotaryEncoder encoder(4, 2);       // пины подключение энкодера (DT, CLK)

// задаем шаг энкодера, максимальное и минимальное значение
#define STEPS  1
#define POSMIN 0
#define POSMAX 30

int lastPos, newPos;
boolean buttonWasUp = true;

byte w = 0;

int SEC = 0;
int MIN = 0;
unsigned long timer;

void setup() {
   pinMode(6, INPUT_PULLUP);   // пин для кнопки энкодера
   encoder.setPosition(0 / STEPS);

   pinMode(10, OUTPUT);   // подключаем светодиод и зуммер
   pinMode(12, OUTPUT);
   digitalWrite(10, HIGH);

   LCD.init();                        // инициализация дисплея
   LCD.backlight();              // включение подсветки

   LCD.setCursor(2, 0);
   LCD.print("TIMER  STOP");
   LCD.setCursor(5, 1);
   LCD.print(MIN);
   LCD.print(" : ");
   LCD.print(SEC);
}

void loop() {

   // проверяем положение ручки энкодера
   encoder.tick();
   newPos = encoder.getPosition() * STEPS;
   if (newPos < POSMIN) {
      encoder.setPosition(POSMIN / STEPS);
      newPos = POSMIN;
   }
   else if (newPos > POSMAX) {
      encoder.setPosition(POSMAX / STEPS);
      newPos = POSMAX;
   }

   // если положение изменилось - меняем переменную MIN и выводим на дисплей
   if (lastPos != newPos) {
      MIN = newPos;
      lastPos = newPos;
      LCD.clear();
      LCD.setCursor(2, 0);
      LCD.print("TIMER  STOP");
      LCD.setCursor(5, 1);
      LCD.print(MIN);
      LCD.print(" : ");
      LCD.print(SEC);
   }

   // если была нажата кнопка энкодера запускаем отсчет времени
   boolean buttonIsUp = digitalRead(6);
   if (buttonWasUp && !buttonIsUp && MIN > 0) {
      delay(10);
      buttonIsUp = digitalRead(6);
      if (!buttonIsUp) {
         if (SEC == 0) { SEC = 60; MIN = MIN - 1; }
         if (MIN < 0 ) { MIN = 0; }
         digitalWrite(10, LOW);
         w = 1;
      }
   }
   buttonWasUp = buttonIsUp; // запоминаем состояние кнопки

   while (w == 1 ) {
      // если прошло 995 мс - вычитаем одну секунду от переменной SEC
      if (millis() - timer > 993) {
         timer = millis();
         SEC = SEC - 1;
 
      // если отсчет закончился - обнуляемся, включаем сигнал и выходим из цикла
      if (SEC == 0 && MIN == 0) {
         lastPos = 0; newPos = 0; MIN = 0; SEC = 0;
         LCD.clear();
         LCD.setCursor(2, 0);
         LCD.print("TIMER  STOP");
         LCD.setCursor(5, 1);
         LCD.print(MIN);
         LCD.print(" : ");
         LCD.print(SEC);
         digitalWrite(10, HIGH);
         tone(12, 100);
         delay(500);
         noTone(12);
         w = 0;
      }

      // если секунды дошли до нуля - вычитаем одну минуту
      if (SEC == 0 && w==1) {
         SEC = 59; MIN = MIN - 1;
         if (MIN < 0 ) { MIN = 0; }
      }

      // если из цикла while еще не вышли - выводим информацию на дисплей
      if (w == 1) {
         LCD.clear();
         LCD.setCursor(2, 0);
         LCD.print("TIMER START");
         LCD.setCursor(5, 1);
         LCD.print(MIN);
         LCD.print(" : ");
         LCD.print(SEC);
      }
    }

    // если была нажата кнопка - обнуляем переменные и выходим из цикла
    buttonIsUp = digitalRead(6);
    if (buttonWasUp && !buttonIsUp) {
       delay(10);
       buttonIsUp = digitalRead(6);
       if (!buttonIsUp) {
          lastPos = 0; newPos = 0; MIN = 0; SEC = 0;
          LCD.clear();
          LCD.setCursor(2, 0);
          LCD.print("TIMER  STOP");
          LCD.setCursor(5, 1);
          LCD.print(MIN);
          LCD.print(" : ");
          LCD.print(SEC);
          digitalWrite(10, HIGH);
          w = 0;
       }
    }
    buttonWasUp = buttonIsUp; // запоминаем состояние кнопки
  }
}

Пояснения к коду:

  1. частоту звукового сигнала можно изменить через команду tone();
  2. для скетча потребуется установить библиотеку RotaryEncoder.

Работа схемы

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

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


Модуль управления построен на основе платы Arduino UNO, которая используется для управления всем устройством. Выходы компараторов подсоединены к цифровым контактам 14 и 19 Arduino. Плата Arduino считывает сигналы с этих цифровых контактов и на их основе выдает соответствующие управляющие сигналы на реле, которое управляет включением и выключением цепи электрической лампочки (bulb).

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

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

Полная схема устройства представлена на следующем рисунке.


Выходы инфракрасных датчиков непосредственно подключены к цифровым контактам Arduino 14(A0) и 19(A5). База транзистора через резистор подключена к контакту 2 Arduino. ЖК дисплей подсоединен к Arduino в 4-битном режиме. Контакты RS и EN ЖК дисплея подключены к контактам 13 и 12 Arduino. Контакты данных ЖК дисплея D4-D7 подключены к контактам 11-8 Arduino.

Управление реле Ардуино Уно / Нано

Для этого занятия нам потребуется:

  • плата Arduino Uno / Arduino Nano / Arduino Mega;
  • блок питания 12 Вольт;
  • светодиодная лента;
  • провода «папа-папа» и «папа-мама».

Соберите схему, как показано на картинке ниже. Подобная схема использовалась в проекте Светильник с управлением от пульта, где светодиодная лента включалась при помощи реле. Модуль имеет три контакта для управления от микроконтроллера Ардуино и два контакта для подключения мощной электрической цепи. Схема подключения реле к Ардуино УНО, Нано или Ардуино Мега ничем не отличается:

GND — GND
VCC — 5V
In — любой цифровой порт


Схема подключения реле srd-05vdc-sl к Ардуино Уно

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

Скетч для управления реле от Ардуино

void setup() {
pinMode(3, OUTPUT); // объявляем пин 3 как выход
}

void loop() {
digitalWrite(3, HIGH); // замыкаем реле

delay(3000); // ждем 3 секунды

digitalWrite(3, LOW); // размыкаем реле

delay(1000); // ждем 1 секунду
}

После загрузки скетча включите блок питания в цепь. Реле при этом должно устанавливаться в разрыве одного из проводов, идущего к LED ленте. Для безопасности лучше устанавливать реле в провод заземления. К минусам реле следует отнести щелчки при замыкании/размыкании контакта, поэтому для включения LED ленты и других приборов до 40 Вольт удобнее использовать транзисторы.

Похожие записи:

Как выставить зажигание с помощью стробоскопа? Сигнализация действия защиты и автоматики Подключение потолочного светильника со светодиодами Default ThumbnailМаркировка smd компонентов: кодовые обозначения Как сделать веб-приложение для вашего собственного bluetooth low energy девайса? Как подключить усилитель в машине