Differences

This shows you the differences between two versions of the page.

--- en:iot-open:introductiontoembeddedprogramming2:cppfundamentals:timing [2023/06/25 17:38] – created ktokarz
+++ en:iot-open:introductiontoembeddedprogramming2:cppfundamentals:timing [2024/05/27 10:51] (current) – ktokarz
@@ Line 1: / Line 1: @@
-==== Timing ====
+====== Timing ======
+{{:en:iot-open:czapka_b.png?50| General audience classification icon }}{{:en:iot-open:czapka_e.png?50| General audience classification icon }}\\
+Writing code that handles interrupts from internal peripherals, for example, timers, is possible but depends strongly on the hardware.
-Writing code that handles interrupts that come from internal peripherals, for example, timers, is possible, but depends strongly on the hardware. Because this chapter presents an introduction to programming, more advanced techniques can be found in other positions. Here some basic timing functions will be shown.
+==== Time-related functions ====
+Because this chapter presents just an introduction to programming, some essential timing functions will be shown.\\
-=== Delay ===
+** Delay **\\
-The simplest solution to make functions work for a certain time is to use the //delay()// ((https://www.arduino.cc/reference/en/language/functions/time/delay/)) function.
+The simplest solution to make functions work for a particular time is to use the ''delay()'' ((https://www.arduino.cc/reference/en/language/functions/time/delay/)) function.
-//delay()// function stops program execution for the time specified as the argument.
+The ''delay()'' function halts program execution for the time specified as the argument (in milliseconds).
-The previously shown blinking LED code is a simple demonstration of delay functionality:
+The blinking LED code is a simple demonstration of delay functionality:
 <code c>
   digitalWrite(LED_BUILTIN, HIGH);   //Turn the LED on
@@ Line 14: / Line 17: @@
   delay(1000);                       //Stop program for a second
 </code>
+Using ''delay()'' is convenient but has a severe drawback: the algorithm is halted, and only interrupts (or tasks in the background) are executed. The main algorithm is present in the figure {{ref>timers1}}. Some tasks, e.g. receiving serial transmissions, networking, and outputting set PWM values, continue to work as background tasks, using interrupts or task management (such as FreeRTOS).
+<figure timers1>
+{{ :en:iot-open:introductiontoembeddedprogramming2:cppfundamentals:timing-page-1.drawio.png?200 | Blocking call: use of the delay}}
+<caption>Blocking call: use of the delay()</caption>
+</figure>
-Limitations that come with using //delay()//: most tasks stop, and there can be no sensor reading, calculation, or pin manipulation. Some tasks continue to work, like receiving serial transmissions and outputting set PWM values. The alternative to using delay is to use //millis()//.
+The alternative to using delay is to switch to the non-blocking method, based on timing with the use of ''millis()'' as presented below.\\
-=== Millis ===
+** Millis **\\
-//millis()// (( https://www.arduino.cc/reference/en/language/functions/time/millis/)) returns the number in milliseconds since Arduino began running the current program. The number will reset after approximately 50 days. //millis()// can be used to replace //delay()//, but needs some additional coding.
+The ''millis()'' (( https://www.arduino.cc/reference/en/language/functions/time/millis/)) returns the number in milliseconds since MCU began running the current program. Note it has nothing to do with a real-time clock, as most microcontrollers and development boards do not have one. The readings are 32-bit and will roll over in approximately 49 days. ''millis()'' can be used to replace ''delay()'' but needs some additional coding. Instead of blocking the algorithm, one can check if the desired time has passed. Meanwhile, it is possible to handle other tasks instead of blocking execution, as presented in the algorithm in figure {{ref>timers2}}.
+<figure timers2>
+{{ :en:iot-open:introductiontoembeddedprogramming2:cppfundamentals:timing-page-2.drawio.png?350 | Non-blocking call: use of the millis}}
+<caption>Non-blocking call: use of the millis()</caption>
+</figure>
-Here is an example code of blinking LED using //millis()//. Millis is used as a timer. Every new cycle time is calculated since the last LED state change. If the time passed is equal to or greater than the threshold value the LED is switched:
+Here is an example code of blinking LED using ''millis()''. Millis is used as a timer. Every new cycle time is calculated since the last LED state change. If the time passed is equal to or greater than the threshold value, the LED is switched:
 <code c>
-//Unsigned long should be used to store time values as the millis() returns 32-bit unsigned number
+//Unsigned long should be used to store time values
+//as the millis() returns a 32-bit unsigned number
 //Store value of current millis reading
 unsigned long currentTime = 0;
 //Store value of time when last time the LED state was switched
 unsigned long previousTime = 0;
-bool ledState = LOW; //Variable for setting LED state
+bool ledState = LOW;              //Variable for setting LED state
 const int stateChangeTime = 1000; //Time at which switch LED states
 void setup() {
-  pinMode (LED_BUILTIN, OUTPUT); //LED setup
+  pinMode (LED_BUILTIN, OUTPUT);  //LED setup
 }
 void loop() {
-  currentTime = millis(); //Read and store current time
+  currentTime = millis();         //Read and store current time
   //Calculate passed time since the last state change
@@ Line 44: / Line 59: @@
   if (currentTime - previousTime >= stateChangeTime) {
-    previousTime = currentTime; //Store new LED state change time
+    previousTime = currentTime;   //Store new LED state change time
-    ledState = !ledState; //Change LED state to oposite
+    ledState = !ledState;         //Change LED state to oposite
     digitalWrite(LED_BUILTIN, ledState); //Write current state to LED
   }
@@ Line 51: / Line 66: @@
 </code>
-**Check Yourself**
+==== Sleep Modes ====
+Some IoT-dedicated microcontrollers have special features such as sleep modes that hold program execution for a predefined time or unless an external trigger occurs. This can be used for periodic, time-based activities. Its side effect is energy efficiency. The model of this behaviour and its features are very vendor-specific and vary much: e.g. Espressif MCUs have the only option to restart the code. At the same time, STM32 can hold execution and then continue. Because of the variety of models, modes and features, we do not present here any specific solution but rather a general idea.
-. What are the drawbacks of using //delay()//?
-  * Program execution stops.
-  * Can’t read sensors during //delay()//.
-  * Simple code.
-. What is the difference between //delay()// and //millis()//?
-. Explain why //millis()// timer value resets after about 50 days.

en/iot-open/introductiontoembeddedprogramming2/cppfundamentals/timing.1687714688.txt.gz · Last modified: 2023/06/25 14:38 (external edit)