C++ for Arduino
Complete Reference Guide

// 1. Preprocessor directives — processed before compilation
#include <Arduino.h>    // usually auto-included by IDE
#define LED_PIN  13       // compile-time constant (no memory used)
#define BAUD     9600

// 2. Global variables — live for the entire program lifetime
int counter = 0;

// 3. Function declarations (prototypes) — optional in .ino; required in .cpp
void blinkLED(int times);

// ──────────────────────────────────────────────
// setup() — runs ONCE when the board powers on
// ──────────────────────────────────────────────
void setup() {
  Serial.begin(BAUD);          // start serial monitor at 9600 baud
  pinMode(LED_PIN, OUTPUT);     // configure pin 13 as output
  Serial.println("Arduino ready!");
}

// ──────────────────────────────────────────────
// loop() — runs FOREVER after setup() completes
// ──────────────────────────────────────────────
void loop() {
  counter++;
  blinkLED(3);
  delay(1000);               // pause 1000 ms
}

// 4. User-defined function
void blinkLED(int times) {
  for (int i = 0; i < times; i++) {
    digitalWrite(LED_PIN, HIGH);
    delay(200);
    digitalWrite(LED_PIN, LOW);
    delay(200);
  }
}

// Declaration and initialization
int           count   = 0;
unsigned long t       = 0UL;      // UL suffix = unsigned long literal
float         voltage = 3.14f;    // f suffix = float literal
bool          isOn    = false;
char          letter  = 'A';      // single quotes for char
const int     PIN     = 7;        // const: value cannot change

// Storage class qualifiers
static int    runCount = 0;  // persists between function calls
volatile int  isr_flag = 0;  // used in interrupt service routines

// Type casting
int   raw = analogRead(A0);        // 0 – 1023
float v   = (float)raw * 5.0 / 1023.0; // C-style cast

// PROGMEM — store constant data in Flash instead of SRAM
#include <avr/pgmspace.h>
const char msg[] PROGMEM = "Hello from Flash!"; // saves precious SRAM

// Bitwise operations are critical in embedded programming
byte reg = 0b10110000;   // binary literal

reg |=  (1 << 2);  // SET bit 2   → 10110100
reg &= ~(1 << 7);  // CLEAR bit 7 → 00110100
reg ^=  (1 << 4);  // TOGGLE bit 4→ 00100100

bool bit4set = (reg >> 4) & 0x01; // READ bit 4

// ── IF / ELSE IF / ELSE ──────────────────────
int temp = 25;
if (temp < 0) {
  Serial.println("Freezing");
} else if (temp < 20) {
  Serial.println("Cold");
} else {
  Serial.println("Warm");
}

// ── SWITCH ───────────────────────────────────
byte mode = 2;
switch (mode) {
  case 1:  Serial.println("Mode: Blink");   break;
  case 2:  Serial.println("Mode: Fade");    break;
  case 3:  Serial.println("Mode: Pulse");   break;
  default: Serial.println("Mode: Off");
}

// ── FOR LOOP ─────────────────────────────────
for (int i = 0; i < 10; i++) {
  Serial.println(i);
}

// ── WHILE LOOP ───────────────────────────────
int count = 0;
while (count < 5) {
  count++;
}

// ── DO-WHILE — executes at least once ────────
do {
  Serial.println("Always runs once");
} while (false);

// ── BREAK & CONTINUE ─────────────────────────
for (int i = 0; i < 10; i++) {
  if (i == 5) break;     // exit loop
  if (i % 2 == 0) continue; // skip even numbers
  Serial.println(i);
}

// ── NON-BLOCKING TIMING (preferred over delay)
unsigned long previousMillis = 0;
const unsigned long INTERVAL = 1000;

void loop() {
  unsigned long now = millis();
  if (now - previousMillis >= INTERVAL) {
    previousMillis = now;
    // do periodic work here without blocking
  }
}

// ── Basic function ───────────────────────────
// return_type name(param_type param) { body }
int add(int a, int b) {
  return a + b;
}

// ── void function (no return value) ──────────
void printSeparator() {
  Serial.println("──────────────");
}

// ── Default parameters ────────────────────────
void blink(int pin, int ms = 500) {
  digitalWrite(pin, HIGH);
  delay(ms);
  digitalWrite(pin, LOW);
  delay(ms);
}
// Usage: blink(13);       — uses default 500ms
// Usage: blink(13, 100);  — uses 100ms

// ── Pass by value vs by reference ────────────
void byValue(int x) { x = 99; }        // original unchanged
void byRef  (int &x) { x = 99; }       // modifies original (& = reference)
void byPtr  (int *x) { *x = 99; }      // pointer dereference

// ── Overloaded functions (same name, diff params)
float mapVal(int   v, int   lo, int   hi) { return (float)v / (hi - lo); }
float mapVal(float v, float lo, float hi) { return (v - lo) / (hi - lo); }

// ── Recursion — use sparingly (limited stack!) 
long factorial(int n) {
  if (n <= 1) return 1;
  return n * factorial(n - 1);
}

// ── Interrupt Service Routine (ISR) ──────────
volatile bool buttonPressed = false;
void IRAM_ATTR onButtonPress() {   // runs on hardware interrupt
  buttonPressed = true;
}
// In setup(): attachInterrupt(digitalPinToInterrupt(2), onButtonPress, FALLING);

// ── Arrays ────────────────────────────────────
int  pins[4] = {9, 10, 11, 12};    // fixed size at compile time
int  len   = sizeof(pins) / sizeof(pins[0]); // = 4

for (int i = 0; i < len; i++) {
  pinMode(pins[i], OUTPUT);
}

// ── 2D Arrays ─────────────────────────────────
byte matrix[3][3] = {
  {1, 0, 1},
  {0, 1, 0},
  {1, 0, 1}
};

// ── C-style strings (char arrays) ─────────────
char greeting[] = "Hello";     // auto-sized: 6 bytes (incl. \0)
char buf[32];                  // buffer for building strings
sprintf(buf, "Temp: %d C", 25); // printf-style formatting
Serial.println(buf);

// String functions from <string.h>
int len2 = strlen(greeting);   // length without null
strcpy(buf, greeting);          // copy string
strcat(buf, " World");          // concatenate
int cmp = strcmp("abc", "abc"); // 0 if equal

// ── Arduino String object ─────────────────────
String s1 = "Sensor: ";
String s2 = s1 + String(42);    // "Sensor: 42" — heap allocation!
Serial.println(s2);
// ⚠ Avoid String in loops — causes heap fragmentation on R3

int  value = 42;
int *ptr   = &value;   // ptr holds the ADDRESS of value

Serial.println(*ptr);  // dereference: prints 42
*ptr = 100;            // modifies value through pointer
Serial.println(value); // prints 100

// ── Pointers and arrays ───────────────────────
int  arr[] = {10, 20, 30};
int *p = arr;           // array name IS a pointer to first element
Serial.println(*(p + 1)); // prints 20 (pointer arithmetic)

// ── Passing array to function ─────────────────
void printArray(int *data, int length) {
  for (int i = 0; i < length; i++) {
    Serial.println(data[i]);
  }
}

// ── References (C++ only, not in C) ──────────
void swap(int &a, int &b) {  // & makes it a reference param
  int tmp = a;
  a = b;
  b = tmp;
}
// swap(x, y); — no & needed at call site

// ── Function pointers — useful for callbacks ──
void doWork(void (*callback)()) {
  // ... do something ...
  callback();   // call whatever function was passed in
}
void myAction() { Serial.println("Action!"); }
// doWork(myAction);

// ── Class Definition (usually in a .h header file) ──
class LED {
  private:                     // accessible only inside the class
    int  _pin;
    bool _state;

  public:                      // accessible from anywhere
    // Constructor — called when object is created
    LED(int pin) : _pin(pin), _state(false) {
      pinMode(_pin, OUTPUT);
    }

    // Destructor — called when object goes out of scope
    ~LED() { digitalWrite(_pin, LOW); }

    void on()     { _state = true;  digitalWrite(_pin, HIGH); }
    void off()    { _state = false; digitalWrite(_pin, LOW); }
    void toggle() { _state ? off() : on(); }

    // Getter — const means it doesn't modify the object
    bool isOn() const { return _state; }

    void blink(int times, int ms = 200) {
      for (int i = 0; i < times; i++) {
        on(); delay(ms);
        off(); delay(ms);
      }
    }
};

// ── Inheritance ───────────────────────────────
class FadingLED : public LED {  // inherits everything from LED
  private:
    int _brightness;
  public:
    FadingLED(int pin) : LED(pin), _brightness(0) {}
    void fadeTo(int brightness) {
      _brightness = brightness;
      analogWrite(_pin, brightness);  // 0-255 PWM
    }
};

// ── Usage in sketch ───────────────────────────
LED statusLED(13);          // creates object, calls constructor
FadingLED rgbLED(9);

void setup() {
  statusLED.blink(3);       // object.method()
  rgbLED.fadeTo(128);
}

/*
 * Hello World — Arduino Uno
 * Blinks the built-in LED on pin 13
 * and prints a message to the Serial Monitor.
 *
 * Hardware: No extra components needed.
 * Open: Tools → Serial Monitor, set baud to 9600
 */

const int LED = 13;     // built-in LED on all Uno boards
int       blinkCount = 0;

void setup() {
  Serial.begin(9600);
  pinMode(LED, OUTPUT);
  Serial.println("Hello, Arduino World!");
}

void loop() {
  digitalWrite(LED, HIGH);   // LED on
  delay(500);
  digitalWrite(LED, LOW);    // LED off
  delay(500);

  blinkCount++;
  Serial.print("Blink #");
  Serial.println(blinkCount);
}

// ✅ Use F() macro to keep string literals in Flash
Serial.println(F("This string stays in Flash, not SRAM"));

// ✅ Non-blocking blink pattern
unsigned long prev = 0;
bool state = false;
void loop() {
  if (millis() - prev >= 500) {
    prev = millis();
    state = !state;
    digitalWrite(13, state);
  }
  // other code runs here — not blocked!
}

// ✅ Debounce button manually
bool readButton(int pin) {
  if (digitalRead(pin) == LOW) {
    delay(20);                     // short delay OK in debounce
    return digitalRead(pin) == LOW;
  }
  return false;
}

// ✅ Map analog reading to voltage
float toVolts(int raw) {
  return raw * (5.0f / 1023.0f);
}

// ✅ Constrain sensor readings before use
int raw = analogRead(A0);
int safe = constrain(raw, 0, 1023);
int mapped = map(safe, 0, 1023, 0, 255);