Arduino delay millis и micros для организации задержки в скетче

Reason One — The Clock Source

Arduino millis() is not accurate and one reason for this is that Arduino
boards sometimes have a 16MHz resonator fitted. This is a cheap oscillation
component that is OK for most applications. it will drift around with
temperature but will always be approximately 16MHz.

If you are looking for accuracy, you will need an Arduino with a crystal on
board (or make up your own bare-bones version with a crystal). You can tell if
yours only has a resonator as resonators are three pin devices whereas crystals
are two pin devices.

The problem is that to retro fit a crystal (it can be done!) to an Arduino
board requires two extra components to make the crystal oscillate correctly
(capacitive loads are required). These are two capacitors, each connected to
one pin of the crystal and then to ground. They range from 12pF to 33pf — check
for the correct capacitor specified by the manufacturer — or just use a couple
of 15pF. You of course also need to attach the crystal to the clock inputs of
the microcontroller (same connections as the resonator — but not the middle
ground one).

A better solution
is to use an external RTC

The accuracy of the crystal is specified as ppm and is usually around 100ppm
(a 32kHz watch crystal can get to 20ppm — not much use for a microcontroller
unless you need low power operation).

If you really want an accurate timestamp then use an ovenised timekeeping
chip (a cheap 2ppm one is the DS3232). This does not output a clock for direct
use by the microcontroller so you could keep the resonator and use the
DS3232 as the accurate timestamp device.

More on the delay() function

Let’s talk a little bit more about this delay function. What have we established so far?

First we’ve said the delay function decreases the tightness of a loop. If you have a tight loop and you add the delay function, it’s going to take more time and make it less tight. That is, the amount of time it takes to get from the start of the loop to the bottom, will increase with the delay function.

We also know that the delay function blocks code. This goes hand in hand with what we just said. When the delay function is running, it is blocking other code from running while it’s delaying.

You might think this delay function is a total slacker! It’s never going to amount to anything in our projects. But for a lot of simple programs that we write, the delay function works fantastic. It’s simple to use, it’s really easy to spell, and it does just what it says.

There is a time when you start to run into issues, however. That has to do with the blocking effect that the delay function has in our program.

In the next lesson in the series, part 3, we’re going to identify where this really becomes an issue. You’ll learn when it makes sense to use the delay() function in a program, and when it’s time to switch to using the millis() function.

Other values of Arduino Crystal Clock

Elsewhere in the code (microsecond delay) it talks about the following
frequencies:

‘Assumes a 1, 8, 12, 16, 20 or 24 MHz’

(the 24MHz clock is for overclocking — doing something not specified by the
data sheet).

The question is: Would millis() be accurate for these crystals?

The following
results show that for most cases the millis() output would be accurate but not
for 12, 20 and 24MHz. You would need to change the operation of the Arduino
code to make millis() output an accurate result.

Microseconds per timer0 overflow:

(64 * 256.0) / 1 = 16384  — 1MHz — no error. 

(64 * 256.0) / 2 = 8192  — 2MHz — no error. 

(64 * 256.0) / 4 = 4096  — 4MHz — no error. 

(64 * 256.0) / 8 = 2048  — 8MHz — no error.  

(64 * 256.0) / 12 = 1365.33 — 12Mhz — millis() would have an error.

(64 * 256.0) / 16 = 1024   — 16MHz — no error.

(64 * 256.0) / 20 = 819.2   — 20MHz — millis() would have an error.

(64 * 256.0) / 24 = 682.66 — 24MHz — millis() would have an error.

The calculation below is FRACT_INC (microseconds_per_interrupt % 1000) >> 3

Note: Observe how FRACT_INC values blow up when the frequency used is not an exact
factor of the Timer0 prescaler and overflow result. Since pre-scalers and timers
use 8 or 16 bits it follows that for this scheme the clock frequency must be a
base2 value i.e. 1,2,4,8,16,32 etc.

Note: At lower crystal frequencies the value of FRACT_INC is
larger but the shifted right value of 1000 ms calculations remains the same —
it has a value of 125 — to fit into a byte) . Therefore the jitter will be far
greater using lower frequences i.e. the millisecond clock will be corrected more
often. e.g. for 16MHz 125/3 is 41.6 but 125/48 is 2.6 — so at 16Mhz the clock
is corrected every 42 ms while at 1MH it is corrected every 3ms.

What happens if
you use Arduino millis long?

If you decide to use a «long» type
definition for the comparison storage variable then you are using a signed
quantity instead of the unsigned quantity output by the millis() function.

If you were to make a timer using «long» and output the value of long using
a Serial command (or any command that converts an integer quality to a string)
such as:

Serial.println(timer);

…where timer is specified as long and updates, perhaps to seconds as:

timer = millis()/1000;

Then at some point in the operation of your code (when the timer reaches the
mid point) the leftmost bit of the unsigned output of millis() will become high
and the print function will interpret this a the sign bit. Therefore it will
output a negative number and Arduino millis() goes negative (or appears to be
negative). For a signed calculation the value is interpreted as negative and
the print function treats long as a signed quality and therefore outputs a
negative number.

Try this of code in Arduino

Example of unsigned long millis overflow

Lets say ledtime is set to the maximum value of the unsigned long:

ledtime = 0xffffffff  or pow(2,32)-1 or 4294967295

That means when the next timeout detection is performed then millis()
will retrurn a positive value and lets say that millis() returns a value of 1 on
the next detection then for normal maths you would have:

millis() — ledtime  == 1 — 4294967295 = -4294967294

The the twos complement and modulo maths means for an unsigned long this represents:

-4294967294 == 2

So this is the right answer even though millis() value is smaller than the
real value of ledtime. Twos complement maths means that $fffffff is
interpreted as a negative number ($fffffff == -1). So:

ledtime (1) — ($ffffffff) == (1) — (-1) == 2.

Time Conversions for
Arduino millis

Millis() Operation

At each interrupt of 1024us the millis() timer is incremented.
Since 1024us is greater than 1000us, the millis() timer is too slow and needs correcting.

The idea is to store the error and
accumulate it until it surpasses a threshold, upon which the
millisecond timer output is corrected.

    So to correct to a 1ms output,    The number of interrupts before a correction is needed is:

        1000.0/24 = 41.66.

The above equation represents the number of 24us periods that add up
to 1ms i.e after 41.66 interrupts the error will be 1ms. Of course you
can’t get 41.66 interrupts so you have to wait for the following
interrupt to detect when the error is greater than 1000us. This will be
when 42 interrupts have occurred.

The clever part of the algorithm is that the error accumulator is
incremented by 24 every interrupt (the division is not performed — that
just lets you see the idea). When this variable is greater than 41.66*24
i.e 42*24  = 1008 then the error is corrected.

The next really, really, clever part of the algorithm is that the
error variable is not reset to zero — you just subtract the 1ms value
(since that was what was corrected) leaving the last value of the error
in the accumulator i.e. it will be 8 on this occasion. This error then
accumulates again and the millis() timer is again adjusted when the error is greater then 1ms.

From the analysis below the millis() timer will be
continuously corrected and is not in error by more than 2ms (See simulation and real output results below).

You can explore this further by looking at the code
that follows below. One thing to note is that the values are fitted into
bytes because they are all multiples of 8 (but this only works for 16MHz and 8MHz
clocks):

    1024.0 / 8 = 128.0 ;   1024 >> 3 is exactly 128  i.e. fits in a byte.

    1000.0 / 8 = 125.0 ;   1000 >> 3 is exactly 125  i.e. fits in a byte.

        24.0 / 8 =
3.0    ;       24
>> 3 is exactly 3      i.e. fits in a byte.

These numbers are used in the code below.

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

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

плата 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

How to make a simple scheduler using Arduino millis

The aim of this Arduino millis example is to make a simple scheduler
algorithm to start different actions at different times. This is only a simple
example and you can find multitasking schedulers that transfer operation to a
different task saving variables so that tasks can be interrupted stopped and
restarted. There will also be the concept of flags that allow communication
between tasks. This simple example is definitely not that type but it can be
useful nevertheless.

Scheduling initial times for offset start using Arduino millis

TIP: To avoid everything happening at the same time set
the initial conditions to be offset from each othe.

You can offset the start times of each timer so that they are not all a multiple of 1000, because if
they are then they will fire more or less at the same time and serial output
will be generated, and serial output takes a bit of time thus changing the
actual time that subsequent time matches happen.

For example you could write the following initialisation (using random
offsets):

This would mean that the starting times of each timed output are offset from
each other — only the start times — the subsequent repeat times would be at the
repeat time specified in the code — they would still be offset so they would
not happen at the exact same time.

So the processor would not have to do the
actions associated with each timeout at the same time. Therefore the code will
operate more smoothly and not have to do a big processing burp!

Show Index
×
                                                                                       

Исходный код программы

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

Arduino

#include<LiquidCrystal.h> //подключение библиотеки для работы с ЖК дисплеем
#define ledPin 7
LiquidCrystal lcd(8,9,10,11,12,13);
float value = 3035; //Preload timer value (3035 for 4 seconds)
void setup()
{
lcd.begin(16,2);
lcd.setCursor(0,0);
lcd.print(«ARDUINO TIMERS»);
delay(2000);
lcd.clear();

pinMode(ledPin, OUTPUT);
pinMode(2,INPUT);
pinMode(4,INPUT);

noInterrupts(); // отключаем все прерывания

TCCR1A = 0;
TCCR1B = 0;
TCNT1 = value; // preload timer
TCCR1B |= (1 << CS10)|(1 << CS12); // 1024 prescaler (коэффициент деления предделителя)
TIMSK1 |= (1 << TOIE1); // enable timer overflow interrupt ISR (разрешаем вызов процедуры обработки прерывания переполнения счетчика)
interrupts(); // разрешаем все прерывания
}
ISR(TIMER1_OVF_vect) // процедура обработки прерывания переполнения счетчика
{
TCNT1 = value; // preload timer
digitalWrite(ledPin, digitalRead(ledPin) ^ 1); //включаем и выключаем светодиод
}
void loop()
{
if(digitalRead(2) == HIGH)
{
value = value+10; //Incement preload value
}
if(digitalRead(4)== HIGH)
{
value = value-10; //Decrement preload value
}
lcd.setCursor(0,0);
lcd.print(value);
}

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

Сейчас рассмотрим, как сделать таймер на Ардуино своими руками с энкодером и 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.

Что лучше: millis() или delay()

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

Итак, как работает функция delay()? Она останавливает выполнение программы на заданное количество миллисекунд. Например, если нам нужно, чтобы спикер пропищал 1 секунду, мы напишем следующий код:

Или нам нужно опрашивать какой-либо датчик 1 раз в 5 секунд:

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

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

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

Итак, что же делать? И тут нам на помощь приходит замечательная функция millis().Из :

Перепишем код последнего примера на ее использование:

Итак, поясню, что же здесь происходит. В LOOP_MILLIS мы помещаем требуемое время задержки — 5000 миллисекунд.В начале функции loop() на строке 7 мы определяем статическую переменную lastLoop и инициализируем ее нулем

Обратите внимание, что значение 0 будет ей присвоено только при первом вызове функции loop() (советую ознакомиться со статьей про статические переменные и преимущества их использования).
Далее (строчка 9) создается уже обычная локальная переменная now, в которую помещается значение миллисекунд, прошедших с момента запуска скетча. Строчки 10-12 пока пропускаем

И на строке 14 видим условие, в теле которого мы вызывает действия, которые нужно повторять каждые 5 секунд, и перезаписываем переменную lastLoop текущим значением переменной now. Таким образом мы сохранили время последнего вызова нашей операции. И далее, она будет вызвана тогда, когда с момент последнего ее вызова прошло 5 секунд (что и означает условие на строчке 14).Теперь вернемся к строчкам 10-12. Вспомним, что в документации по функции millis() было написано, что примерно раз в 50 дней происходит переполнение и функция вновь будет возвращать значения начиная с 0. Поэтому необходимо проверить, что произошло переполнение (только при переполнении значение переменной lastLoop, которая содержит время последнего запуска, может быть больше, чем значение переменной now), и также обнуляем переменную lastLoop. Если этого не сделать, то условие на строке 14 просто перестанет выполняться, так как now всегда будете меньше, чем lastLoop.

← Выбираем лучшую среду разработки: Arduino IDE или PlatformIO

Что использовать: статические или глобальные переменные →

Моргание без команды Delay [1]

Иногда в процессе работы может потребоваться, чтобы два процесса проходили одновременно. К примеру, может понадобиться, чтобы светодиод моргал каждый раз, когда система будет считывать нажатие на кнопку. В этом случае функцию delay() использовать нельзя – руководствуясь ею, Arduino приостановит действие программы и потому просто «проморгает» факт нажатия на кнопку.
Скетч ниже демонстрирует, как заставить светодиод моргать, не используя при этом функцию delay(). Код заставляет светодиод включиться, а затем отмечает время. Затем, проходя через loop(), проверяет, не закончилось ли время, отведенное программой на режим «вкл». Если закончилось, он выключает светодиод и снова отмечает время. Потом ждет, когда закончится нужный интервал и снова включает светодиод. И так по кругу

То есть этот код заставляет светодиод непрерывно моргать.
В качестве аналогии можно привести такую ситуацию – допустим, вы разогреваете в микроволновке пиццу и в то же время ждете важного телефонного звонка. Вы кладете пиццу в микроволновку и включаете ее на 10 минут

То есть, если сравнить это с использованием функции delay(), то вы как бы сидите перед микроволновкой и ждете, когда таймер отсчитает эти 10 минут, но, услышав звонок, вдруг убегаете в другую комнату снимать трубку, тем самым «проморгав» момент икс – 10 минут превратятся в 11, 12, 13 и т.д., пока пицца не превратится в обуглившуюся лепешку.
Но это пример из выдуманной вселенной, где у микроволновки нет таймера. В нашей же вселенной он есть, благодаря чему во время подогрева пиццы вы можете и разговаривать по телефону, и читать «имейлы», и сидеть в соцсети (но не слишком долго – пицца остынет!), будучи уверенным, что по прошествии этих 10 минут микроволновка выключится и пицца будет в идеальной кондиции.
В данном примере мы как раз научимся делать подобный таймер.

Программирование Ардуино

Язык программирования устройств Ардуино основан на C/C++. Он прост в освоении, и на данный момент Arduino — это, пожалуй, самый удобный способ программирования устройств на микроконтроллерах.

Базовые и полезные знания, необходимые для успешного программирования под платформу Arduino:

Справочник языка Ардуино

Язык Arduino можно разделить на три раздела:

Библиотеки Arduino

Servo — библиотека управления сервоприводами.EEPROM — чтение и запись энергонезависимой памяти микроконтроллера.SPI — библиотека, реализующая передачу данных через интерфейс SPI.Stepper — библиотека управления шаговыми двигателями.

Example #2: Basic Delay with for() loops

For our 2nd example, we are only going to delay for 1ms, but do so inside of a for() loop.

void setup() {
   pinMode(13, OUTPUT);
}

void loop() {
   digitalWrite(13, HIGH);   // set the LED on
   for (int x=0; x < 1000; x++) {     // Wait for 1 second
      delay(1);
   }
   digitalWrite(13, LOW);   // set the LED on
   for (int x=0; x < 1000; x++) {     // Wait for 1 second
      delay(1);
   }
}

This new sketch will accomplish the same sequence as Example #1. The difference is that the Arduino is only “delayed” for one millisecond at a time. A clever trick would be to call other functions inside of that for() loop. However, your timing will be off because those instructions will add additional delay.

Способы управления через Blynk

На данный момент есть два варианта управлять пином:

С помощью вебхуков

• https://blynk-cloud.com/<ваш_токен>/update/V0?value=1 — для замыкания реле
• https://blynk-cloud.com/<ваш_токен>/update/V0?value=0 — для размыкания реле

С помощью мобильного приложения blynk

1. Вернёмся к созданному ранее проекту и добавим простую кнопку с помощью иконки «+» в верхнем правом углу приложения.
2. Выберем в открывшемся меню «Button» и разместим, где удобней.
3. Зададим виртуальный пин, управлять которым мы будем этой кнопкой. Для этого просто тапнем по созданной кнопке.
4. По желанию называем кнопки, задаём цвет и текст, для включенного и выключенного состояний.
5. Тип «Push<>Switch» (кнопка или переключатель). Push — нажали и отпустили, пин выключился. Switch — нажали и отпустили, пин запомнил состояние.

When it’s ok to use delay() and delayMicroseconds()

There are specific occasions when using in your code is still OK.

Here are 2 of those:

• You need to initialize a component during the setup of your program, and this component needs some time to get initialized – for example 1.5 seconds. In this case, using in your function is perfectly fine. Basically, any in the function of your Arduino program won’t be a problem.
• As explained in the part, you need to wait for a few microseconds (not milliseconds!) when communicating with an external component. If you find that using with a small number (for example 10) doesn’t disturb the rest of your program, you can still use it without having to worry too much. But consider it as an exception, not the common rule.

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

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