Arduino Programming Fundamentals

Functions

In computer science, a subroutine or subprogram (also called procedure, method, function, or routine) is a portion of code within a larger program, which performs a specific task and is relatively independent of the remaining code.
A function is a way for programmers to reuse code without having to rewrite it, this is time saving, and often makes code more readable.
what we need to have a function:
1) each function must have a unique name
2) the function name is followed by parentheses()
3) functions have a return type, e.g. void
4) the body of a function is enclosed in opening and closing braces {}

Lets do a very simple example to see how it works

void setup() {
  Serial.begin(9600);
  
  DashedLine(); //here we are calling the function
  Serial.println("| BONJOUR |");
  DashedLine(); //here we call it again
}

void loop() {
}

void DashedLine() //here is where we create the function
{
  Serial.println("----------------");
}

Passing a value to a function

and a bit of for loop

void setup() {

  Serial.begin(9600);
  
  // draw the menu box
  DashedLine(24);
  Serial.println("| Program Options Menu |");
  DashedLine(24);
}

void loop() {
}
//a function needs to be able to accept an integer value that is passed to it, 
//the variable type and the name of the variable 
//are inserted between the opening an closing parentheses after the function name

void DashedLine(int len) 
{
  int i;
  
  // draw the line
  //The body of the sketch uses the len variable in a for loop 
  //to print out the correct number of dashes that make up the dashed line of the menu box
  for (i = 0; i < len; i++) {
    Serial.print("-");
  }
  // move the cursor to the next line
  Serial.println("");
}

let's try it with our usual Hello World blink

  pinMode(13, OUTPUT);
}
 
// the loop function runs over and over again forever
void loop() {
  blinkLed();
}
 
void blinkLed() {
  digitalWrite(13, HIGH);   // turn the LED on (HIGH is the voltage level)
  delay(1000);              // wait for a second
  digitalWrite(13, LOW);    // turn the LED off by making the voltage LOW
  delay(1000);              // wait for a second
}

now we can reuse the function multiple times

In this example, we’ll add a parameter to the function to allow the function to vary the speed of the blink

void setup() {
  // initialize digital pin 13 as an output.
  pinMode(13, OUTPUT);
}
 
// the loop function runs over and over again forever
void loop() {
  blinkLed(200);
}
 
void blinkLed(int delayTime) {
  digitalWrite(13, HIGH);   // turn the LED on (HIGH is the voltage level)
  delay(delayTime);              // wait for a second
  digitalWrite(13, LOW);    // turn the LED off by making the voltage LOW
  delay(delayTime);              // wait for a second
}

Arrays and the for loop

int timer = 100;           // The higher the number, the slower the timing.
int ledPins[] = { 2, 3, 4, 5, 6, 7 };       // an array of pin numbers to which LEDs are attached
int pinCount = 6;           // the number of pins (i.e. the length of the array)
 
void setup() {
  // the array elements are numbered from 0 to (pinCount - 1).
  // use a for loop to initialize each pin as an output:
  //We can see that thisPin is initialized at 0 and pinCount is equal to 6 
  //pinCount is one of the variables declared at the top 
  //Every time through the for loop, thisPin is incremented by adding 1
  for (int thisPin = 0; thisPin < pinCount; thisPin++) {
    pinMode(ledPins[thisPin], OUTPUT);
  }
}
 
void loop() {
  // loop from the lowest pin to the highest:

  for (int thisPin = 0; thisPin < pinCount; thisPin++) {
    // turn the pin on:
    digitalWrite(ledPins[thisPin], HIGH);
    delay(timer);
    // turn the pin off:
    digitalWrite(ledPins[thisPin], LOW);
 
  }
 
  // loop from the highest pin to the lowest:
  for (int thisPin = pinCount - 1; thisPin >= 0; thisPin--) {
    // turn the pin on:
    digitalWrite(ledPins[thisPin], HIGH);
    delay(timer);
    // turn the pin off:
    digitalWrite(ledPins[thisPin], LOW);
  }
}

Beyond the delay()

Blink without delay

const int ledPin =  13;      // the number of the LED pin
 
// Variables will change:
int ledState = LOW;             // ledState used to set the LED
long previousMillis = 0;        // will store last time LED was updated
 
// the follow variables is a long because the time, measured in miliseconds,
// will quickly become a bigger number than can be stored in an int.
long interval = 1000;           // interval at which to blink (milliseconds)
 
void setup() {
  // set the digital pin as output:
  pinMode(ledPin, OUTPUT);      
}
 
void loop()
{
  // here is where you'd put code that needs to be running all the time.
 
  // check to see if it's time to blink the LED; that is, if the 
  // difference between the current time and last time you blinked 
  // the LED is bigger than the interval at which you want to 
  // blink the LED.
  unsigned long currentMillis = millis();
 
  if(currentMillis - previousMillis > interval) {
    // save the last time you blinked the LED 
    previousMillis = currentMillis;   
 
    // if the LED is off turn it on and vice-versa:
    if (ledState == LOW)
      ledState = HIGH;
    else
      ledState = LOW;
 
    // set the LED with the ledState of the variable:
    digitalWrite(ledPin, ledState);
  }
}

As overly complicate as it seems, Blink without delay illustrates a very important concept known as a State Machine

A State Machine

A ‘state’ is the condition of a thing at a specific time. Something that can accomplish tasks and that utilizes states at its core is a state machine. They are also known as Finite State Machines (FSM), meaning that we know all possible states of the thing. The key to the state machine is the concept of time and history. The state of the machine is evaluated periodically. Each time it is evaluated, a new state is chosen (which could be the same state again), and the output is presented.

int ledPin =  13;      // the number of the LED pin
int ledState = LOW;             // ledState used to set the LED
unsigned long previousMillis = 0;        // will store last time LED was updated
long OnTime = 500;           // milliseconds of on-time
long OffTime = 500;          // milliseconds of off-time

void setup() 
{
  // set the digital pin as output:
  pinMode(ledPin, OUTPUT);      
}

void loop()
{
  // check to see if it's time to change the state of the LED
  unsigned long currentMillis = millis();
  unsigned long elapsed = currentMillis - previousMillis;  // elapsed is the time since the end of the last cycle

  if((ledState == HIGH) && (elapsed >= OnTime))
  {
    ledState = LOW;  // Turn it off
    previousMillis = currentMillis;  // Remember the time
    digitalWrite(ledPin, ledState);  // Update the actual LED
  }
  else if ((ledState == LOW) && (elapsed >= OffTime))
  {
    ledState = HIGH;  // turn it on
    previousMillis = currentMillis;   // Remember the time
    digitalWrite(ledPin, ledState);    // Update the actual LED
  }
}