7

Hi I am using Arduino Nano to gamify my experience on Unity3D. I know that Update() in Unity3D runs every frame per second but I because I'm not an electronics guy I don't know how loop() function runs on Arduino.

Does it depends on number of CPU cycles(or micro processor chip in case of Arduino) or what? Please explain. I facing some lags in my game. I can fix them only if know how is loop() function running on Arduino

There ain't a lot of information about loop() in arduino documentation

3
  • 3
    "runs every frame per second" not sure you completely understand frames, or maybe just a typo. but in Unity3D each frame runs as fast as possible, they don't purposefully but a delay in the frame – MCMastery Aug 24 '17 at 18:19
  • put a delay in the frame (can't edit it? thought i could) – MCMastery Aug 24 '17 at 19:18
  • 1
    Looks like the short answer is "as fast as possible". – user253751 Aug 25 '17 at 1:56
10

Loop runs as long as loop needs to run.

Instructions in a CPU run sequentially. The more instructions there are the longer it takes to run.

The more code you put in loop the longer loop will run.

There are two ways to know how long each iteration of loop will take:

  1. Profiling: Actively time each iteration of loop, though be warned, the act of timing will affect the amount of time taken.
  2. Cycle counting. Compile the source into assembly and total up the number of clock cycles needed for all the instructions (including calls to functions). Arduous for small loops, a gargantuan task for anything else.

Also note that many external factors can affect how long loop() takes to run - such as serial communication speed, etc.

2
  • Don't forget interruptions for example updating the millis value every 16000 clock cycles (for 16Mhz oscilator). They stop execution of program in regular intervals and prevent the arduino from being a good PWM source. (yes you can turn them off) – Filip Franik Aug 24 '17 at 15:14
  • 5
    @FilipFranik: 1. The interrupt that updates the millis() value runs every 1024 µs, or 16384 CPU cycles at 16 MHz. 2. Interrupts affect the quality of software PWM output (e.g., the Servo library). They have no effect on hardware-generated PWM (e.g., with analogWrite()). – Edgar Bonet Aug 24 '17 at 15:24
3

the instructions between the end of loop() and the next run of it are a ret, jmp and a call.

You can consider the main function to be effectively:

void main(){

    init();
    while(1) loop();

}

Though in reality there is some setup done before init() to make millis() and such work.

6
  • 2
    Also you have serial event code after loop. – Majenko Aug 24 '17 at 11:19
  • @Majenko isn't that done with interrupts? – ratchet freak Aug 24 '17 at 11:20
  • 1
    No, it's not. It's just called at the end of loop. It's very crude and many people don't understand just how pointless it really is. – Majenko Aug 24 '17 at 11:21
  • I think the loop() is optimized by the compiler, so no actual jmp or ret occur. The code translates to: while (1) yourLoopCode; without function call. But I saw horrible dumb things with GCC... – next-hack Aug 24 '17 at 11:22
  • 2
    The more I look at the standard runtime of an arduino the more I am dissapointed... – ratchet freak Aug 24 '17 at 11:38
2

It depends on what's in the loop. From a few clock cycles to infinite hang.

2

A look at main.cpp (for avr code in my installation) in file:

C:\Program Files (x86)\Arduino\hardware\arduino\avr\cores\arduino\main.cpp

shows that the Arduino runs loop() alternately with serialEventRun() in an infinite loop:

int main(void)
{
    init();
    initVariant();
 #if defined(USBCON)
    USBDevice.attach();
#endif

    setup();

    for (;;) {
        loop();
        if (serialEventRun) serialEventRun();
    }

    return 0;
}

Inspection of HardwareSerial.cpp shows that serialEventRun() simply calls serialEvent(), if you have defined it in your sketch.

This means that you can write your own infinite loop within loop() perfectly safely, unless you have written serialEvent() code and are expecting it to run regularly.

This begs the question: if serialEvent() is called sequentially with loop(), will serialEvent() be called if loop() never returns? In other words, is serialEvent() interrupt-driven as well as being called when loop() returns? A quick test -see below- shows that it is not interrupt-driven, so the previous paragraph is true.

/*
  Serial Event Checker

  A sketch to see if serialEvent() is interrupt-driven.
  Will serialEvent() be called if loop() never returns?

  This code is based on Tom Igoe's SerialEvent example.

  On (at least) Arduino Uno we find that serialEvent() simply runs
  sequentially with loop().  When loop() never returns serialEvent()
  is never called.

  NOTE: The serialEvent() feature is not available on the Leonardo, Micro, or
  other ATmega32U4 based boards.

  R Symonds-Tayler 2018-02-01

  This example code is in the public domain.

*/

String inputString = "";         // a String to hold incoming data

void setup() {
  // initialize serial:
  Serial.begin(115200);
  // reserve 200 bytes for the inputString:
  inputString.reserve(200);
}

// comment out this definition to allow loop() to return
#define INFINITE_LOOP

void loop() { 
#ifdef INFINITE_LOOP
    while(1);
#endif

}

/*
  SerialEvent occurs whenever a new data comes in the hardware serial RX. This
  routine is run between each time loop() runs, so using delay inside loop can
  delay response. Multiple bytes of data may be available.
*/
void serialEvent() {
  while (Serial.available()) {
    // get the new byte:
    char inChar = (char)Serial.read();
    // add it to the inputString:
    inputString += inChar;
    // if the incoming character is a newline, set a flag so the main loop can
    // do something about it:
    if (inChar == '\n') {
      Serial.print("Got: '");
      Serial.print(inputString);
      Serial.println("'");
      // clear the string:
      inputString = "";
    }
  }
}

This means that serialEvent() code might just as well go into your main loop() within a:

if(serial.available()){
   // your code here...
}

block.

1

try looking up arduino functions micros() and delayMicroseconds() If you might need your loop to wait longer than 16000 microseconds then also look up the other delay() function which does milliseconds.

By the way, the internal clock is very slightly off and varies with room temperature, so don't rely on it staying synchronised to your other device without a handshake.

1
  • 1
    micros() and delayMicroseconds() use 32-bit integers (unsigned long) and can manage durations up to 2³² µs, or about 1.19 hours. – Edgar Bonet Aug 24 '17 at 16:47
0

In this article bri_huang made a nice experiment using an oscilloscope and simple write functions.

He calculated the speed of the loop to be 117 kHz even though the microcontroller has a 16 MHz clock.

https://learn.sparkfun.com/blog/1687

3
  • 3
    That link does not really say a lot about how “fast” loop() is (which I.M.O. Is meaningless), but only how fast the Arduino implementation of digitalWrite() is (which is not exactly the fastest way to toggle a pin on the Arduino). – StarCat May 10 at 13:34
  • So no satisfactory answer yet? Or can we assume it runs at the speed of the crystal oscillator? – Alejandro Camus May 11 at 12:51
  • @Alejandro Camus It has a billion factors all the way from temperature of your room to how much load is the microprocessor is handling, we cannot even say that it runs at the speed of the oscillator as commands take time to do – Coder9390 May 12 at 14:23

Not the answer you're looking for? Browse other questions tagged or ask your own question.