Ардуино delay или millis

Arduino

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

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

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

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

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

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

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

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

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

Функция возвращает количество миллисекунд, прошедших с момента запуска текущей программы. Это число будет переполнено (обнулится) примерно через 50 дней.

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

Итак, поясню, что же здесь происходит. В 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 .

Источник

Millis() или delay() : что лучше и правильнее использовать?

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

Функция delay() останавливает выполнение программы на заданное временное значение перед следующим действием или циклом. Прописывается она в отдельное в строке и содержит внутри себя значение в миллисекундах (на заметку: 1000 мс, миллисекунд = 1 секунда)

Пример задержки в 5 секунд будет выглядеть так:

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

Рассмотрим это на следующем примере:

Попробуем включать светодиоды путем нажатия на кнопку/кнопки

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

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

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

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

Отличия от предыдущего скетча в том, что появляются новые переменные и строчки в коде. led1OnTime и led2OnTime сохраняют значения времени для работы каждого из светодиодов, а led1On и led2On отслеживают значение на выходе светодиода – горит он или не горит (true/false)

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

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

Таким образом, мы выяснили, что для циклов, содержащих в себе несколько переменных и несколько условий, желательно использовать millis()

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

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

Источник

Ардуино задержка: delay и millis без delay

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

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

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

  • Arduino Uno / Arduino Nano / Arduino Mega.

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

Ардуино delayMicroseconds()

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

Ардуино delay()

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

Ардуино millis()

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

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

Используем в Ардуино millis вместо delay

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

Заключение. Команда millis Arduino не останавливает выполнения программы, а начинает отсчет времени с начала запуска счетчика в миллисекундах. В отличии от этого, delay и delayMicroseconds останавливают выполнение программы на заданное количество миллисекунд или микросекунд соответственно. Применение определенной задержки в скетче Ардуино микроконтроллеров зависит от поставленной задачи.

Источник

Функции времени

Задержки

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

  • delay(time)
    • Задержка на указанное количество миллисекунд (мс). 1 секунда = 1’000 мс.
    • time принимает тип данных unsigned long и может приостановить выполнение на срок от 1 до 4 294 967 295 мс (

    50 суток) с разрешением 1 мс.

  • Работает на системном таймере, поэтому не работает внутри прерывания и при отключенных прерываниях.
  • delayMicroseconds(time)
    • Задержка на указанное количество микросекунд (мкс). 1 секунда = 1’000’000 мкс.
    • time принимает тип данных unsigned int и может приостановить выполнение на срок от 4 до 16383 мкс (да, меньше чем максимум для этого типа данных) с разрешением 4 мкс.
    • Работает не на таймере, а на пропуске тактов процессора, поэтому может работать в прерывании и при отключенных прерываниях.
    • Иногда не совсем корректно работает с переменными, поэтому нужно стараться использовать константы ( const или просто число).
    • Часто используется в библиотеках для эмуляции цифровых интерфейсов связи.
  • Задержки использовать очень просто:

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

    Функция yield()

    Разработчики Arduino позаботились о том, чтобы функция delay() не просто блокировала выполнение кода, но и позволяла выполнять другой код во время этой задержки. Данный “костыль” получил название yield() и работает следующим образом: если объявить функцию

    то расположенный внутри неё код будет выполняться во время работы любой задержки delay() в программе! Это решение хоть и кажется нелепым, но в то же время позволяет быстро и без написания лишних костылей и таймеров реализовать пару параллельно выполняющихся задач. Это вполне соответствует идеологии Arduino – максимально простая и быстрая разработка прототипа. Рассмотрим простой пример: стандартный мигающий светодиод, но с опросом кнопки:

    Функции счёта времени

    Данные функции возвращают время, прошедшее с момента запуска программы, так называемый аптайм (англ. uptime). Таких функций у нас две:

      millis() – миллисекунды, тип unsigned long , от 1 до 4 294 967 295 мс (

    50 суток), разрешение 1 мс. После “переполнения” отсчёт начинается с нуля.
    micros() – микросекунды, тип unsigned long , от 4 до 4 294 967 295 мкс (

    70 минут), разрешение 4 мкс. После “переполнения” отсчёт начинается с нуля.

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

    millis() в часы и секунды

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

    Видео

    Источник

    Arduino Tutorial: Using millis() Instead of delay()

    A well known Arduino function is delay() which pauses the program for an amount of milliseconds specified as parameter.

    millis() , on the other hand, is a function that returns the amount of milliseconds that have passed since program start.

    At first glance you may doubt the usefulness of this function. The fact is that it’s extremely useful in many scenarios, often “replacing” delay() completely. Let’s first look at how we can use millis() almost exactly like delay() .

    Timing issues are often present in programming.

    Using millis() like delay()

    If you want your code to just pause for 1000 ms at the end of each loop iteration, the code above is a bit silly. You can just use delay(1000) instead. The only difference between the code above and a code with delay(1000) at the end is that the loop in the above code will run quite accurately once each second. The loop in a code with delay(1000) will run a bit less frequent since it also takes some time to execute Serial.println(«Hello») .

    Why Use millis() Instead of delay()?

    We will now look at two advantages with millis() compared to delay() .

    Accurate Timing

    The first advantage we’ll discuss is accurate timing. Code-wise, we covered this in the last chapter. With millis() we can ensure that the loop runs as often as we want, regardless of the execution time (obviously as long as the execution time is less time the desired period). With delay() this is not possible since we do not know how long the loop execution time is.

    Accurate timing like this is very useful when sampling at a certain frequency or running filters, among other things.

    Non-blocking

    The other advantage with millis() is that it won’t prevent us from running code while “waiting”.

    Let’s say we want to print “Hello” over serial once each second while doing other stuff in the meantime. This is not possible with delay() since it pauses the entire code. Here’s one way we can do this:

    This chunk of code is pretty similar to the first chunk, except that it doesn’t block the rest of the program when not printing over serial.

    Example: a Simple Scheduler

    Let’s write a simple example where we create a scheduler that prints certain bits of text at different intervals.

    Here’s what the first 60 seconds in the serial monitor looks like:

    This is a nice and easy way to synchronize executions in your code. You are able to run other code simultaneously as well.

    micros() and Overflowing

    Just like delay() has a microsecond-version called delayMicroseconds() , millis() has micros() . If you need better resolution, micros() may be the way to go.

    However, be aware that micros() will overflow after approximately 70 minutes, compared to millis() ‘s 50 days. This means that the functions’ return values will start all over from zero.

    More importantly: to learn how you can avoid the overflow issue alltogether, read this blog post.

    Summary

    millis() and micros() are really handy functions to use when dealing with timing tasks. If you’re not aware of these, you might end up using delay() instead, which won’t always work that well (if at all).

    For more Arduino tips & tricks, check out our Arduino Tutorials blog category. Stay tuned for more Arduino-related content in the future as well!

    October 15th 2018 – Updated with link to blog post about avoiding the potential overflow issue.

    January 9th 2020 – Edited the code with some inputs from Dimitris (from CityLab)

    Источник

    Arduino delay или millis

    Millis() или delay() : что лучше и правильнее использовать?

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

    Функция delay() останавливает выполнение программы на заданное временное значение перед следующим действием или циклом. Прописывается она в отдельное в строке и содержит внутри себя значение в миллисекундах (на заметку: 1000 мс, миллисекунд = 1 секунда)

    Пример задержки в 5 секунд будет выглядеть так:

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

    Рассмотрим это на следующем примере:

    Попробуем включать светодиоды путем нажатия на кнопку/кнопки

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

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

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

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

    Отличия от предыдущего скетча в том, что появляются новые переменные и строчки в коде. led1OnTime и led2OnTime сохраняют значения времени для работы каждого из светодиодов, а led1On и led2On отслеживают значение на выходе светодиода – горит он или не горит (true/false)

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

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

    Таким образом, мы выяснили, что для циклов, содержащих в себе несколько переменных и несколько условий, желательно использовать millis()

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

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

    Источник

    Функции времени

    Задержки

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

    • delay(time)
      • Задержка на указанное количество миллисекунд (мс). 1 секунда = 1’000 мс.
      • time принимает тип данных unsigned long и может приостановить выполнение на срок от 1 до 4 294 967 295 мс (

      50 суток) с разрешением 1 мс.

    • Работает на системном таймере, поэтому не работает внутри прерывания и при отключенных прерываниях.
  • delayMicroseconds(time)
    • Задержка на указанное количество микросекунд (мкс). 1 секунда = 1’000’000 мкс.
    • time принимает тип данных unsigned int и может приостановить выполнение на срок от 4 до 16383 мкс (да, меньше чем максимум для этого типа данных) с разрешением 4 мкс.
    • Работает не на таймере, а на пропуске тактов процессора, поэтому может работать в прерывании и при отключенных прерываниях.
    • Иногда не совсем корректно работает с переменными, поэтому нужно стараться использовать константы ( const или просто число).
    • Часто используется в библиотеках для эмуляции цифровых интерфейсов связи.
  • Задержки использовать очень просто:

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

    Функция yield()

    Разработчики Arduino позаботились о том, чтобы функция delay() не просто блокировала выполнение кода, но и позволяла выполнять другой код во время этой задержки. Данный “костыль” получил название yield() и работает следующим образом: если объявить функцию

    то расположенный внутри неё код будет выполняться во время работы любой задержки delay() в программе! Это решение хоть и кажется нелепым, но в то же время позволяет быстро и без написания лишних костылей и таймеров реализовать пару параллельно выполняющихся задач. Это вполне соответствует идеологии Arduino – максимально простая и быстрая разработка прототипа. Рассмотрим простой пример: стандартный мигающий светодиод, но с опросом кнопки:

    Функции счёта времени

    Данные функции возвращают время, прошедшее с момента запуска программы, так называемый аптайм (англ. uptime). Таких функций у нас две:

      millis() – миллисекунды, тип unsigned long , от 1 до 4 294 967 295 мс (

    50 суток), разрешение 1 мс. После “переполнения” отсчёт начинается с нуля.
    micros() – микросекунды, тип unsigned long , от 4 до 4 294 967 295 мкс (

    70 минут), разрешение 4 мкс. После “переполнения” отсчёт начинается с нуля.

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

    millis() в часы и секунды

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

    Видео

    Источник

    delay() Arduino Function: Tight Loops and Blocking Code

    Have you ever been making an Arudino project and you want something to occur at a timed interval? Maybe every 3 seconds you want a servo to move, or maybe every 1 minute you want to send a status update to a web server.

    How do you do that? Is there a function that is simple and straightforward that helps us with this? Yes there is! We will discuss the delay function, as well as the millis() function, in the video below:

    This is part 2 of our millis() function mini-series. Part 1 helps us understand what the millis() function does, part 2 discusses tight loops and blocking code, and part 3 discusses when the millis() function outshines the delay() function.

    Topics in this lesson

    • Tight loops
    • Blocking code
    • Ancient recipe for inspiring music

    Millis() versus Delay()

    So you want something to occur at a set interval and you’re looking for a solution. If your answer is using the delay function, well, you’re kind of right. But there is another way.

    The cooler, snazzier option is the Arduino millis() function. And the more familiar you are with using the millis function, to help you time events in your Arduino code, the easier it will be to incorporate other parts into your program later on.

    Once you start using the millis() function, you’ll be happier, more cheerful, and gosh darn it, people will like you.

    Tight Loops

    First let’s discuss the concept of a tight loop. And when we say a tight loop, what does that mean?

    Let’s take a look at an Arduino sketch for a demonstration of a tight loop. Starting with the most basic sketch, we’ve only got two functions: void setup, and void loop. And as you may know, void setup only runs once, and then it hands the show over to void loop.

    Void loop then goes through every line of code that might be inside the loop (inside these curly brackets).

    It executes the first line, then it executes the second, and then the third, and so on and so forth, until it gets to the bottom. And then it goes back to the top.

    How fast does it execute the loop? It depends on which Arduino board you’re using, but an Arduino Uno has a clock speed of 16 megahertz. So that means that 16 million instructions are happening every second on the Arduino!

    Each line of code isn’t necessarily one instruction. In fact, it’s most likely that it’s multiple instructions. But still, that’s relatively fast (your computer processor is likely running at Gigahertz speeds… that’s billions).

    So would you consider that empty sketch a tight loop? Definitely, that’s as fast and as tight as you can make a loop. Since there’s nothing inside of the loop to execute, the time it takes to go thru the sketch is practically zilch. Said another way, the interval from the start of the loop to the finish is short (therefore it is fast, or “tight”).

    Let’s add some lines of code. We will start serial communication, and then print something to the serial monitor window.

    Is this a tight loop? That is, from the start of the loop to the end of the loop, does that take a lot of time? It takes very little time, so that’s a fast, tight loop.

    It’s worth noting, however, that this loop is not as tight as the previous example. In the previous example, we had no code. So it was just racing through the loop. Now that we have a function here, serial print, it will take (a tiny) bit of time to print “Ice Ice Baby” to serial monitor.

    But this is still a pretty quick loop. So let’s add a little bit more code. We’ll have the program check to see if a button is pressed, and if it is, we’ll have something new sent to the serial monitor

    So we have declared a button and used an if statement to check and see if the button has been pressed. Is the voltage at pin five high? If so, then we print something else to the serial monitor window.

    Is this a tight loop? So, from the start of the loop, to the end of the loop, is that pretty quick?

    Yes, it’s still quite quick. This is a pretty tight loop. We’ve got four lines of code. We’re printing to the serial monitor, and then we’re doing a quick check to see if a button is being pressed. And if it is, we print something out. Still tight, still fast.

    Next let’s add a delay to this program using the Arduino delay() function. You can see below we’ve added a thousand millisecond (1 second) delay to the loop.

    Is this still a tight loop? Is the time, from the start of the loop to the end of the loop, a lot of time? No, this is definitely not a tight loop. The code starts fast, we do the serial print, but then we get halted right there at the delay function.

    The whole program comes to a standstill while we wait for this delay code to finish.

    When the Arduino gets to this line of code, it’s kind of like going to the grocery store. You get into the 12 items or less line, but then the guy in front of you pulls out his checkbook, and starts writing a check. You know you’re gonna be there for a minute. It’s the same deal here.

    So this is not a tight loop. The time from the start of the loop to the end of the loop is pretty significant. Especially compared to the last couple programs. The order of magnitude of time is huge.

    Now what we’ve tried to demonstrate here is that this whole idea about tight loops is relative. It all depends on your application. If you need to check the status of a sensor every 10 millionth of a second, then a program that has three lines of code may not be tight enough, it just depends.

    Another point to make is that not all lines of code take the same amount of time to execute. If you’re calling a function that does a bunch of stuff, like serial print for example, then that one line of code may take a whole lot longer than 10 other lines of code.

    So the tightness of a loop is a relative idea.

    Blocking Code

    When a program stops at some point, and takes some time to execute some code, that code can be called blocking code. This is a general term.

    In our program we’ve got the delay function acting as blocking code. None of the code after delay can run until the delay is over, so it’s getting blocked.

    Blocking code is not, however, just when we use the delay() function.

    Let’s take our program and get rid of delay, but we’ll add a for loop. Our for loop will print out numbers and text to the serial port.

    So how long does this loop run for? It’s going to run for a while because it has to go through 100 iterations before it stops.

    And what about the code after this for loop? Is it able to run? No, it has to wait because it’s being blocked by the for loop.

    This for loop is nested inside the main loop. Is the for loop a “tight” loop? Before you answer, let’s re-emphasize how you should think about it: does it take a lot of time to go through this for loop, from the top to the bottom?

    Well, not really. It’s only got two lines of code. So this is a pretty tight loop.

    But it’s a tight loop that has to go through a lot of iterations before the program can get to the code below it. So, even a tight loop, if forced to run through several iterations, can block our code.

    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.So we shouldn’t necessarily ostracize the delay() function from our programming toolbox. We should just recognize that it’s a simple programming function that can work in a lot of instances.

    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.

    Review

    First, we talked about the tightness of a loop. We said that the tightness of a loop is relative. It depends on what your application is.

    Second, we talked about blocking code, or code that blocks. Essentially, it’s a generic term we can give to code that’s going to take some time to execute, and it’s going to stop other parts of our program from running while it executes.

    We hope enjoyed this lesson! In the next part of this series, we’re going to continue our journey learning how to use the millis function to create timed, repetitive events in our Arduino code. We’ll see you next time!

    Источник

    Adblock
    detector