Arduino C++

Arduino C++ Basics (PDF) ← Here’s an even simpler single page introduction for you to 🖨️ print

Programming - The basics

Comments

// This is a comment - it's ignored when the program runs

Basic Structure

// the setup function runs at the very start of the program
void setup() {
	// in here you can initialize all the things that need initializing
}

// the loop function runs again and again and again for as long as your program runs
void loop() {

}

🎓Lifecycle

These are the steps involved in creating and running a program:

1. We write are instructions for the Microcontroller to follow.
1. We do this using a programming language called C++
2. We use an Integraded Development Environment (IDE) - essentially a fancy text-editor with extra functionality to make coding easy.

2. Our 📄 source code is then ⚙️ compiled (translated) into 🤖 machine code (a low-level representation of instructions that the microcontroller can execute directly)

3. We ⬆️ upload the compiled program to the microcontroller’s flash memory

4. The microcontroller’s program counter points to the first instruction and starts executing the code sequentially. Variables and other data are allocated to RAM (Random Access Memory)

What we need to know to be able to program

These are the very basic things we have to understand to be able to program:

• 📜 Instructions = individual commands

• 🆎 Data Types = the types of data we can use

• 📦 Variables = containers that hold bits of information that we can change and work with

• 🔣 Operators = how to assign values to variables, etc.

• 🔂 Control structures = how to compare stuff and branch out

• ↗️ Functions = sections of code that can be called from elsewhere in the program

These things all play together, so it might be confusing at first when you learn about one while you don’t yet know about another. But bear with me, it will all make sense after an hour or two!

1. Instructions

• When programming, we’re writing lists of instructions for the computer to execute.

• Instructions can be function calls, variable asignments, control instructions, etc.

void setup() {
	int a = 0; // make a variable of type integer, call it "a" and assign 0 to it
	a = a + 5; // add 5 to a
	a = a - 2; // subtract 2 from a
}

Note how every instruction in C++ has to end with a semi-colon ;!

2. Data Types

String str = "Hello";
char* chArr = str.c_str();

3. Variables

int score = 100;
float num = 32.19076;
String name = "Bob";

4. Operators

• = (simple assignment). Example: score = 12;

• + (addition). Example: score = score + 2;
• += (addition assignment). Example: score += 2;
• ++ (increment by 1). Example: score++;

• - (subtraction). Example: score = score - 10;
• -= (subtraction assignment). Example: score -= 10;
• -- (decrement). Example: score--;

• * (multiplication). Example: score = score * 2;

• / (division). Example: score = score / 4;

• == (equal to). Example: if(name == "Bob") { Serial.println("Hello"); }

• != (not equal to). Example: if(name != "Bob") { Serial.println("Hi"); }

• < (less than). Example: if(health < 1) { Serial.println("Dead"); }

• > (greater than). Example: if(score > 50) { Serial.println("Yay"); }

• <= (less than or equal to). Example: if(health <= 0) { Serial.println("Dead"); }

• >= (greater than or equal to). Example: if(score >= 100) { Serial.println("You Win!"); }

5. Control Structures

Manage the flow of execution in your program!

If

if(a > b) {
	// if a > b do this
}

if(a > b) {
	// if a > b do this
} else {
	// otherwise do this
}

if(a > b) {
	// if a > b do this
} else if(a < b) {
	// otherwise, if a < b do this
} else {
	// in all other cases, do this
}

void loop() {
    char userChoice;
    Serial.begin(9600);
    Serial.println("Enter something:");
    while (!Serial.available()) {} // Wait for user input
    userChoice = Serial.read();

    switch (userChoice) {
        case '1':
            Serial.println("One");
            break;
        case '2':
            Serial.println("Two");
            break;
        case '3':
        case '4':
        case '5':
		        Serial.println("Yep.");
		        break;
        case 'blah':
            Serial.println("Blah indeed!");
            break;
        default:
            Serial.println("Whatever...");
    }
}

For

const int ledPin = 13;

void setup() {
    pinMode(ledPin, OUTPUT);
    
    for (int i = 0; i < 5; i++) {
        digitalWrite(ledPin, HIGH); // turn LED on
        delay(500);
        digitalWrite(ledPin, LOW); // turn LED off
        delay(500);
    }
}

void loop() {
    
}

While

const int buttonPin = 2;

void setup() {
    pinMode(buttonPin, INPUT_PULLUP);
    Serial.begin(9600);
}

void loop() {
    // Wait for button press
    while (digitalRead(buttonPin) == HIGH) {
        // Do nothing until the button is pressed
    }

    // Button pressed!
    Serial.println("Button pressed.");
    delay(1000); // Debounce
}

do {
    // Wait for button press
} while (digitalRead(buttonPin) == HIGH);

6. Functions / Methods

A function is a section of code that can be called from elsewhere in your code. Ideally your function has a descriptive name and does one specific thing.

Functions and Methods are the same thing. A Function that’s part of a Class or Object is called a Method

Calling functions

Making your own functions

int add(int a, int b) {
	return a + b;
}

// Define a function called "add" that takes two integer numbers as arguments
int add(int a, int b) {
	return a + b; // return the result of a + b
}

void setup() {
	int c = add(5, 8); // call the function and save the result in a new variable
	Serial.println(c); // output the result over Serial
	int d = add(12876, 3908234); // call the same function again with different arguments
	Serial.println(d);
}

int myFunction() {
    static int callCount = 0; // Static variable
    callCount++; // Increment on each call
    return callCount;
}

void setup() {
    Serial.begin(9600);
}

void loop() {
    int result = myFunction();
    Serial.print("Function called ");
    Serial.print(result);
    Serial.println(" times.");
    delay(1000);
}

Serial Output/Input

Serial Output

int count = 0;

void setup() {
	Serial.begin(9600); // start a serial connection at the given baud rate
}

void loop() {
	count++; // increment count
	Serial.println(count); // print a line to serial containing the current count 
	delay(1000); // pause for 1 second
}

Serial Input

const int ledPin = 13; // LED connected to digital pin 13

void setup() {
    pinMode(ledPin, OUTPUT);
    Serial.begin(9600);
}

void loop() {
    char userChoice;
    Serial.println("Enter '1' to turn on the LED, '0' to turn it off:");
    while (!Serial.available()) {} // Wait for user input to complete
    userChoice = Serial.read(); // Read the user input into a variable

    switch (userChoice) {
        case '1':
            digitalWrite(ledPin, HIGH);
            break;
        case '0':
            digitalWrite(ledPin, LOW);
            break;
        default:
            Serial.println("Invalid choice. Enter '1' or '0'.");
    }
}

Libraries

In the Arduino IDE there’s a special sidebar tab for libraries where you can find and install the ones you want to use.

For example: The Arduboy2 library is one that provides many things that help us make an Arduboy game.

Once a library is ⬇️ installed, we can include it in our program like this:

#include <Arduboy2.h>

Now our program can call all the things in the Arduboy2 library!

Note that many libraries come with examples! Check in the menu under File > Examples > [Name of the Library]

🎵 And that’s the basics!🎵

Working with Pins

pinMode(pin, mode);

• Parameters:
• pin: The Arduino pin number to set the mode of.
• mode: Can be one of the following:
• INPUT: Configures the pin as an input (read data from external devices).
• OUTPUT: Configures the pin as an output (control external devices).
• INPUT_PULLUP: Enables the internal pull-up resistor for the pin (useful for buttons and switches). ⚠️ Be aware however that turning on a pull-up will affect the values reported by analogRead().

pinMode(7, INPUT);
int buttonState = digitalRead(7); // Read input from digital pin 7 (1 = HIGH, 0 = LOW)

• For input (reading):
• HIGH (1): Indicates a voltage above a certain threshold (e.g., 2.5V).
• LOW (0): Indicates a voltage below the threshold.

pinMode(13, OUTPUT);
digitalWrite(13, HIGH); // Set pin 13 to HIGH

• For output (writing):
• HIGH (1): Represents a logic high voltage (usually 3.3V or 5V).
• LOW (0): Represents a logic low voltage (usually 0V or ground).

int sensorValue = analogRead(A0); 
// Read analog value from pin A0 (10-bit resolution = 0-1023)
// NOTE: On ESP32 it's 12-bit, so 0-4095

• Certain pins support hardware PWM (e.g., GPIOs 2, 4, 5, etc.).

• Use analogWrite(pin, value) to generate PWM signals (vary the intensity of an output).

pinMode(9, OUTPUT);
analogWrite(9, 128); // Generate PWM signal on digital pin 9 (50% duty cycle)

Object Oriented Programming

OOP is a way of writing code that organizes it around objects. Instead of writing one long script full of functions and logic we’re grouping data and functions together and create smaller, reusable parts.

Key Concepts / Building Blocks

#include <Arduino.h>

// Animal class definition
class Animal {
public:
    // Properties (attributes)
    String species;
    String name;

    // Constructor (initialize properties)
    Animal(const String& animalSpecies, const String& animalName) {
        species = animalSpecies;
        name = animalName;
    }

    // Method to introduce the animal
    void introduce() {
        Serial.print("Hi, I'm ");
        Serial.print(name);
        Serial.print(", the ");
        Serial.print(species);
        Serial.println("!");
    }
};

// Create animal objects
Animal bonko("Cat", "Bonko");
Animal sue("Giraffe", "Sue");

void setup() {
    Serial.begin(9600);
    delay(1000);

    // Call the introduce method on the animals
    bonko.introduce();
    sue.introduce();
}

void loop() {}

Classes

class MyClass {
  int x; // private by default
public:
  int y; // public
};

// Guy.h (Header File)
#include <Arduino.h>

class Guy {
    private:
        // Current Velocity
        float x;
        float y;
    public:
		    Guy(int16_t x, int16_t y);
        bool reset(int16_t x, int16_t y);
        void processInput(uint8_t up, uint8_t right, uint8_t down, uint8_t left, uint8_t a, uint8_t b);
};

// Guy.cpp (Implementation)
#include "Guy.h" // !include the header file!
#include <Arduino.h>

Guy::Guy(int16_t xPos, int16_t yPos) {
    x = xPos;
    y = yPos;
}

bool Guy::reset(int16_t xPos, int16_t yPos) {
    x = xPos;
    y = yPos;
    return true;
}

void Guy::processInput(uint8_t up, uint8_t right, uint8_t down, uint8_t left, uint8_t a, uint8_t b) {
	// ...
}

// INCLUDE/HEADER GUARD - to prevent redefinition of the same reusable class!
#ifndef PLATFORM_H // if it's not yet defined...
#define PLATFORM_H // ...define it and continue

struct Platform {
	int_fast16_t x;
	int_fast16_t y;
	int_fast16_t w;
	int_fast16_t h;
};

#endif // PLATFORM_H

There’s different ways to access stuff inside a class.

Structs

struct MyStruct {
  int x; // public by default
private:
  int y; // private
};

// Define a new struct
// If you want to ever use this as an argument in a function, then it has to be defined
// BEFORE the FIRST function in the file, or there will be an error (Arduino bug)
struct Platform {
    uint_fast8_t x;
    uint_fast8_t y;
    uint_fast8_t w;
    uint_fast8_t h;
};

// Now I make an array with this struct
Platform platforms[8];
// C++ is not good at resizing arrays, so I just make an array and keep track of its size myself
uint_fast8_t platformLength = 0;

// A function to add to the array
void addPlatform(uint_fast8_t px, uint_fast8_t py, uint_fast8_t pw, uint_fast8_t ph) {
  platforms[platformLength] = {px, py, pw, ph};
  platformLength++;
}

// And a function that uses the array
void drawPlatform(const Platform& platform) {
  tft.fillRect(platform.x, platform.y, platform.w, platform.h, ST77XX_WHITE);
}

void setup() {
	addPlatform(20, 20, 100, 20);
	drawPlatform(platforms[0]);
}

Queues and Stacks

Queues and Stacks are lists that differ in the way you can add and retrieve elements. Queues are First-In-First-Out (FIFO), so the first item you add will be the first item you can remove. (Add 1, 2, 3, retrieve 1, 2, 3) Stacks are First-In-Last-Out (FILO), so the first item you add will be the last item you can remove. (Add 1, 2, 3, retrieve 3, 2, 1)

#include <ArduinoQueue.h>

ArduinoQueue<int> myQueue(20); // create a queue of int, capable of holding 20 items

void setup() {
	Serial.begin(115200);

  delay(2000);

  // Add a few numbers to myQueue
  myQueue.enqueue(12);
  myQueue.enqueue(18);
  myQueue.enqueue(22);

  int num = myQueue.dequeue(); // will return the number 12 and remove it from the queue
  Serial.println(num);

  myQueue.enqueue(47); // add another number to myQueue

  num = myQueue.dequeue(); // will return the number 18 and remove it from the queue
  Serial.println(num);

  num = myQueue.getHead(); // will return the number 22, BUT leave it in the queue (in other places this is often called "peek")

  bool isEmpty = myQueue.isEmpty();    // Returns true if the queue is empty, false otherwise
  bool isFull = myQueue.isFull();    // Returns true if the queue is full, false otherwise
  unsigned int itemCount = myQueue.itemCount();    // Returns the number of items currently on the queue
  unsigned int itemSize = myQueue.itemSize();    // Returns the size of the item being stored (bytes)
  unsigned int maxQueueSize = myQueue.maxQueueSize();    // Returns the maximum possible size of the queue (items)*
  unsigned int maxMemorySize = myQueue.maxMemorySize();    // Returns the maximum possible size of the queue (bytes)*
}

void loop() {}

struct car {
    char brand[10];
    char model[10];
    int nr_doors;
};
ArduinoQueue<car> myCarsQueue(50);

#include <Stack.h>

Stack<char> myStack; // create a stack of char

void setup() {
  Serial.begin(115200);

  delay(2000); // wait 2 sec

  myStack.push('a'); // add 'a' to the stack
  myStack.push('b'); // add 'b' to the stack
  myStack.push('c'); // add 'c' to the stack
  while (myStack.length()) {
    Serial.print(myStack.pop()); // prints: cba (last in, first out!)
  }
  Serial.println();

}

void loop() {}

Types of Memory

💽 EEPROM

An EEPROM write takes 🕐 3.3 ms to complete. The EEPROM memory has a specified life of 💀 100,000 write/erase cycles, so you may need to be careful about how often you write to it.

#include <EEPROM.h>

int address = 0; // the current address in the EEPROM (i.e. which byte we're going to write to next)

void setup() {}

void loop() {
  
  int val = analogRead(0) / 4; // read input, divide by 4 so result fits into 1 byte
  if(EEPROM.read(address) != val) EEPROM.write(address, val); //save val to current eeprom address 

  // advance to the next address
  address = address + 1;
  if (address == EEPROM.length()) { 
    address = 0;
  }

  delay(100);
}