> ARDUINO REFERENCE MANUAL

Arduino è una piattaforma open-source basata su microcontrollori AVR (principalmente ATmega328P per Arduino Uno). Lo sviluppo avviene tramite l'IDE Arduino, che fornisce un ambiente C/C++ semplificato con funzioni wrapper per I/O, comunicazioni e temporizzazione.

// Le variabili globali sono dichiarate qui
int led = 13;

void setup() {
  // Eseguita UNA SOLA volta all'avvio
  pinMode(led, OUTPUT);
  Serial.begin(9600);
}

void loop() {
  // Eseguita in loop continuo
  digitalWrite(led, HIGH);
  delay(1000);
  digitalWrite(led, LOW);
  delay(1000);
}

// PROGMEM: dati costanti in Flash
const char msg[] PROGMEM = "Hello from Flash";
char buf[20];
strcpy_P(buf, msg);  // Copia da Flash a SRAM

// F() macro: stringhe direttamente da Flash
Serial.println(F("Salva SRAM!"));

void setup() {
  pinMode(13, OUTPUT);       // LED builtin
  pinMode(2, INPUT_PULLUP);  // Pulsante con pull-up interno
}

void loop() {
  int stato = digitalRead(2);
  digitalWrite(13, !stato);   // INPUT_PULLUP: LOW = premuto
}

int sensorValue = analogRead(A0);           // 0-1023
float voltage = sensorValue * (5.0 / 1023.0); // Conversione in Volt

analogWrite(9, 128);  // PWM 50% duty cycle sul pin 9

// Pattern NON BLOCCANTE con millis()
unsigned long previousMillis = 0;
const long interval = 1000;

void loop() {
  unsigned long currentMillis = millis();
  if (currentMillis - previousMillis >= interval) {
    previousMillis = currentMillis;
    // azione periodica ogni 1 secondo
    digitalWrite(13, !digitalRead(13));
  }
  // altro codice eseguito senza blocco
}

void setup() {
  Serial.begin(9600);
  while (!Serial);  // Attendi connessione (solo Leonardo/Micro)
}

void loop() {
  if (Serial.available() > 0) {
    char c = Serial.read();
    Serial.print("Ricevuto: ");
    Serial.println(c);
  }
}

// map(): rimappare lettura ADC a range PWM
int sensor = analogRead(A0);                      // 0-1023
int pwmVal = map(sensor, 0, 1023, 0, 255);       // 0-255
int clamped = constrain(pwmVal, 10, 245);          // Limita range
analogWrite(9, clamped);

void setup() {
  randomSeed(analogRead(0));  // Seed da pin flottante (rumore)
}

void loop() {
  long r = random(1, 7);  // Simula dado: 1-6
}

volatile bool pressed = false;

void buttonISR() {
  pressed = true;  // ISR: breve e veloce!
}

void setup() {
  pinMode(2, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(2), buttonISR, FALLING);
  Serial.begin(9600);
}

void loop() {
  if (pressed) {
    pressed = false;
    Serial.println("Premuto!");
  }
}

#include <EEPROM.h>

// Salvare e leggere una struct
struct Config {
  int threshold;
  float calibration;
  byte mode;
};

Config cfg = {512, 1.05, 2};
EEPROM.put(0, cfg);        // Salva in EEPROM

Config loaded;
EEPROM.get(0, loaded);     // Rileggi da EEPROM

#include <Wire.h>

Bus I2C (TWI): SDA = pin A4, SCL = pin A5 su Arduino Uno. Velocità standard: 100 kHz.

// Master: scrive e legge da dispositivo I2C
Wire.begin();
Wire.beginTransmission(0x68);  // Indirizzo MPU-6050
Wire.write(0x3B);              // Registro ACCEL_XOUT_H
Wire.endTransmission(false);   // Repeated start
Wire.requestFrom(0x68, 6);     // Leggi 6 byte
while (Wire.available()) {
  byte b = Wire.read();
}

#include <SPI.h>

SPI su Uno: MOSI = pin 11, MISO = pin 12, SCK = pin 13, SS = pin 10.

SPI.begin();
pinMode(10, OUTPUT);  // Chip Select

SPI.beginTransaction(SPISettings(1000000, MSBFIRST, SPI_MODE0));
digitalWrite(10, LOW);         // Seleziona slave
byte result = SPI.transfer(0x42);
digitalWrite(10, HIGH);        // Deseleziona slave
SPI.endTransaction();

#include <Servo.h>

Servo myservo;

void setup() {
  myservo.attach(9);
}

void loop() {
  for (int pos = 0; pos <= 180; pos++) {
    myservo.write(pos);
    delay(15);
  }
}

#include <Stepper.h>

Stepper myStepper(200, 8, 9, 10, 11);  // 200 step/giro, 4 pin

void setup() {
  myStepper.setSpeed(60);  // 60 RPM
}

void loop() {
  myStepper.step(200);     // 1 giro completo
  delay(500);
  myStepper.step(-200);   // 1 giro inverso
  delay(500);
}

#include <LiquidCrystal.h>

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

byte heart[8] = {
  0b00000, 0b01010, 0b11111, 0b11111,
  0b11111, 0b01110, 0b00100, 0b00000
};

void setup() {
  lcd.begin(16, 2);
  lcd.createChar(0, heart);
  lcd.print("Hello!");
  lcd.setCursor(0, 1);
  lcd.write((byte)0);  // Stampa cuore custom
}

#include <SD.h>
#include <SPI.h>

Usa SPI. CS tipicamente su pin 4 (Ethernet Shield) o pin 10.

File dataFile = SD.open("log.txt", FILE_WRITE);
if (dataFile) {
  dataFile.println("Temperatura: 23.5");
  dataFile.close();
}

#include <SoftwareSerial.h>

Emula una porta seriale su pin digitali qualsiasi. Utile per moduli GPS, Bluetooth, ecc.

SoftwareSerial bluetooth(2, 3);  // RX=2, TX=3

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

void loop() {
  if (bluetooth.available())
    Serial.write(bluetooth.read());
  if (Serial.available())
    bluetooth.write(Serial.read());
}

#include <Ethernet.h>
#include <SPI.h>

L'ATmega328P espone tutte le periferiche tramite registri I/O mappati in memoria (SFR — Special Function Registers). Manipolare direttamente i registri è più veloce e compatto rispetto alle funzioni Arduino, ma richiede conoscenza dell'hardware.

// Equivalenza: digitalWrite(13, HIGH)
PORTB |= (1 << PB5);   // Pin 13 = PB5, circa 2 cicli di clock

// Equivalenza: digitalWrite(13, LOW)
PORTB &= ~(1 << PB5);  // ~125ns vs ~6µs di digitalWrite()

// Equivalenza: digitalRead(2)
if (PIND & (1 << PD2)) { /* pin 2 HIGH */ }

Ogni porta (B, C, D) ha tre registri a 8 bit:

// Configura TUTTI i pin di PORTD come output
DDRD = 0xFF;         // 0b11111111

// Pin 13 (PB5) come output
DDRB |= (1 << DDB5);

// Pin 2 (PD2) come input con pull-up
DDRD &= ~(1 << DDD2);   // Input
PORTD |= (1 << PORTD2); // Pull-up attivo

// Leggere pin 2
if (PIND & (1 << PIND2)) { /* HIGH */ }

// Toggle veloce pin 13 (scrivendo 1 su PINx)
PINB = (1 << PINB5);  // Hardware toggle, 1 ciclo

// Scrivere un intero byte su PORTB (pin 8-13)
PORTB = 0b00101100;   // Pin 10,11,13 HIGH; altri LOW

L'ATmega328P ha 3 timer hardware:

// Timer1 CTC: interrupt ogni 1 secondo
// f = 16MHz / (prescaler * (1 + OCR1A))
// 1 Hz = 16000000 / (256 * (1 + 62499))
cli();                            // Disabilita interrupt
TCCR1A = 0;                      // Reset
TCCR1B = 0;
TCNT1  = 0;                      // Azzera contatore
OCR1A  = 62499;                   // Compare match value
TCCR1B |= (1 << WGM12);          // Modo CTC
TCCR1B |= (1 << CS12);           // Prescaler 256
TIMSK1 |= (1 << OCIE1A);         // Abilita Compare Match A
sei();                            // Riabilita interrupt

ISR(TIMER1_COMPA_vect) {
  // Eseguito ogni 1 secondo
  PINB = (1 << PB5);              // Toggle LED
}

// Fast PWM su pin 6 (OC0A) con frequenza custom
// f_PWM = f_clk / (prescaler * 256)
// Con prescaler 64: 16MHz / (64 * 256) = 976.5 Hz (default Arduino)
DDRD |= (1 << DDD6);             // Pin 6 output
TCCR0A = (1<<COM0A1) | (1<<WGM01) | (1<<WGM00);  // Fast PWM, non-inv
TCCR0B = (1<<CS01) | (1<<CS00);  // Prescaler 64
OCR0A  = 128;                    // Duty cycle 50%  (128/256)

// Phase Correct PWM su pin 9 (OC1A) — Timer1 16-bit
// f = f_clk / (2 * prescaler * TOP)
DDRB |= (1 << DDB1);             // Pin 9 output
TCCR1A = (1<<COM1A1) | (1<<WGM11);
TCCR1B = (1<<WGM13) | (1<<CS11); // Phase Correct, prescaler 8, TOP=ICR1
ICR1   = 20000;                  // TOP: 50 Hz (per servo: 20ms periodo)
OCR1A  = 1500;                   // Pulse 1.5ms (servo centro)

// Lettura ADC manuale (equivale a analogRead(0))
ADMUX  = (1<<REFS0);                 // AVCC come riferimento
ADMUX  = (ADMUX & 0xF0) | (0 & 0x0F); // Canale ADC0
ADCSRA = (1<<ADEN) | (1<<ADPS2) | (1<<ADPS1) | (1<<ADPS0); // Enable, prescaler 128

ADCSRA |= (1<<ADSC);                 // Avvia conversione
while (ADCSRA & (1<<ADSC));           // Attendi completamento
uint16_t result = ADC;                // Leggi risultato (ADCL + ADCH)

// Free Running Mode: conversioni continue
ADCSRA |= (1<<ADATE);                // Auto trigger
ADCSRB = 0;                           // Free running (ADTS = 000)
ADCSRA |= (1<<ADSC);                 // Prima conversione
// Da ora ADC converte continuamente, leggibile da ADC

// Lettura rapida a 8 bit
ADMUX |= (1<<ADLAR);                 // Left adjust
// ... avvia conversione ...
uint8_t fast = ADCH;                  // Solo 8 bit alti

// Inizializzazione USART a 9600 baud
#define BAUD 9600
#define UBRR_VAL ((F_CPU / 16 / BAUD) - 1)  // = 103 a 16MHz

void uart_init() {
  UBRR0H = (UBRR_VAL >> 8);
  UBRR0L = UBRR_VAL;
  UCSR0B = (1<<RXEN0) | (1<<TXEN0);       // Abilita TX e RX
  UCSR0C = (1<<UCSZ01) | (1<<UCSZ00);    // 8 bit, 1 stop, no parity
}

void uart_tx(uint8_t data) {
  while (!(UCSR0A & (1<<UDRE0)));        // Attendi buffer vuoto
  UDR0 = data;
}

uint8_t uart_rx() {
  while (!(UCSR0A & (1<<RXC0)));         // Attendi dato
  return UDR0;
}

void uart_print(const char *s) {
  while (*s) uart_tx(*s++);
}

// INT0 (pin 2) su fronte di discesa
EICRA |= (1<<ISC01);                // ISC01=1, ISC00=0 = FALLING
EIMSK |= (1<<INT0);                 // Abilita INT0
sei();

ISR(INT0_vect) {
  // Handler interrupt esterno 0
}

// Pin Change Interrupt su pin 8 (PCINT0)
PCICR  |= (1<<PCIE0);               // Abilita PCINT per PORTB
PCMSK0 |= (1<<PCINT0);              // Abilita PCINT0 (pin 8)
sei();

ISR(PCINT0_vect) {
  // Scatta per QUALSIASI pin abilitato in PCMSK0
  // Determinare quale pin è cambiato confrontando con stato precedente
  static uint8_t lastB = 0;
  uint8_t changed = PINB ^ lastB;
  lastB = PINB;
  if (changed & (1<<PB0)) { /* pin 8 cambiato */ }
}

// SPI Master, modo 0, clock = F_CPU/16
DDRB |= (1<<DDB3) | (1<<DDB5) | (1<<DDB2); // MOSI, SCK, SS output
SPCR  = (1<<SPE) | (1<<MSTR) | (1<<SPR0);    // Enable, Master, /16

uint8_t spi_transfer(uint8_t data) {
  SPDR = data;
  while (!(SPSR & (1<<SPIF)));
  return SPDR;
}

// TWI Master init: 100 kHz con F_CPU=16MHz
// TWBR = ((F_CPU / f_SCL) - 16) / 2 = (160-16)/2 = 72
TWSR = 0;                           // Prescaler = 1
TWBR = 72;                          // 100 kHz

// Invia START
TWCR = (1<<TWINT) | (1<<TWSTA) | (1<<TWEN);
while (!(TWCR & (1<<TWINT)));       // Attendi completamento

// Invia SLA+W (indirizzo + write)
TWDR = (0x68 << 1) | 0;            // Indirizzo 0x68, bit W=0
TWCR = (1<<TWINT) | (1<<TWEN);
while (!(TWCR & (1<<TWINT)));

// Invia dato
TWDR = 0x42;
TWCR = (1<<TWINT) | (1<<TWEN);
while (!(TWCR & (1<<TWINT)));

// STOP
TWCR = (1<<TWINT) | (1<<TWSTO) | (1<<TWEN);

uint8_t eeprom_read(uint16_t addr) {
  while (EECR & (1<<EEPE));          // Attendi scrittura precedente
  EEAR = addr;
  EECR |= (1<<EERE);                // Avvia lettura
  return EEDR;
}

void eeprom_write(uint16_t addr, uint8_t data) {
  while (EECR & (1<<EEPE));          // Attendi scrittura precedente
  EEAR = addr;
  EEDR = data;
  cli();                            // Sezione critica
  EECR |= (1<<EEMPE);               // Master enable
  EECR |= (1<<EEPE);                // Avvia scrittura (entro 4 cicli)
  sei();
}

Il Watchdog Timer (WDT) resetta il microcontrollore se non viene "alimentato" periodicamente. Utile per recupero da blocchi software.

#include <avr/wdt.h>

// Abilita WDT con timeout 2 secondi
wdt_enable(WDTO_2S);

// Nel loop: resetta il timer prima del timeout
void loop() {
  wdt_reset();          // "Alimenta" il watchdog
  // ... codice ...
}

// Disabilita WDT
wdt_disable();

// WDT come interrupt (senza reset)
cli();
WDTCSR |= (1<<WDCE) | (1<<WDE);      // Sblocca modifica
WDTCSR  = (1<<WDIE) | (1<<WDP2) | (1<<WDP1); // Interrupt mode, 1s
sei();

ISR(WDT_vect) {
  // Eseguito ogni ~1s (wake da sleep o task periodico)
}

#include <avr/sleep.h>
#include <avr/power.h>

// Power-down con wake da INT0
void enterSleep() {
  set_sleep_mode(SLEEP_MODE_PWR_DOWN);
  sleep_enable();

  // Configura INT0 per wake
  EICRA |= (1<<ISC01);              // FALLING edge
  EIMSK |= (1<<INT0);

  sei();
  sleep_cpu();                      // ZZZ... (si ferma qui)
  sleep_disable();                  // Riprende dopo wake
}

ISR(INT0_vect) {
  // Wake-up handler (può essere vuoto)
}

// Disabilitare periferiche non usate per risparmiare energia
power_adc_disable();
power_spi_disable();
power_twi_disable();
power_timer1_disable();
power_timer2_disable();

GCC per AVR permette di inserire istruzioni assembly inline con asm volatile("..."). volatile impedisce al compilatore di ottimizzare/rimuovere il blocco. Utile per operazioni a bassissimo livello non esprimibili in C.

// Ritardo esatto di N cicli (N × 62.5 ns a 16 MHz)
#define NOP asm volatile ("nop")

// ~250 ns di pausa (4 cicli)
NOP; NOP; NOP; NOP;

// Utile per rispettare timing stretti di protocolli (es. WS2812B / DHT)

// Set bit — pin HIGH (1 ciclo, molto più veloce di digitalWrite)
asm volatile ("sbi %0, %1" :: "I" (_SFR_IO_ADDR(PORTB)), "I" (5));  // PB5 = pin 13 HIGH

// Clear bit — pin LOW
asm volatile ("cbi %0, %1" :: "I" (_SFR_IO_ADDR(PORTB)), "I" (5));  // PB5 = pin 13 LOW

// Equivalente C (più leggibile, stessa velocità con ottimizzazione -Os):
PORTB |=  (1 << PB5);  // HIGH
PORTB &= ~(1 << PB5);  // LOW

// Salva SREG, disabilita interrupt, esegue, ripristina
uint8_t oldSREG;
asm volatile ("in %0, __SREG__" : "=r" (oldSREG));  // salva stato
asm volatile ("cli");                                 // disabilita interrupt

// — operazioni atomiche qui —
uint16_t val = volatileCounter;  // lettura 16-bit sicura

asm volatile ("out __SREG__, %0" :: "r" (oldSREG));  // ripristina stato

// Alternativa più idiomatica con avr-libc:
#include <util/atomic.h>
ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
  val = volatileCounter;
}

Un servomotore standard richiede un impulso PWM ogni 20 ms (50 Hz). Larghezza impulso: ~544 µs = 0°, ~1500 µs = 90°, ~2400 µs = 180°. La libreria Servo.h (built-in) gestisce tutto via Timer1.

#include <Servo.h>

Servo myServo;

int currentAngle = 90;
int targetAngle  = 90;
unsigned long lastMove = 0;
const int STEP_DELAY = 15;  // ms tra ogni grado (velocità)

void setup() {
  myServo.attach(9, 544, 2400);  // Pin, min µs, max µs
  myServo.write(currentAngle);
  Serial.begin(9600);
}

void smoothMove() {
  if (currentAngle == targetAngle) return;
  if (millis() - lastMove < STEP_DELAY) return;
  lastMove = millis();
  currentAngle += (targetAngle > currentAngle) ? 1 : -1;
  myServo.write(currentAngle);
}

void loop() {
  smoothMove();
  // Il resto del codice gira senza bloccarsi

  // Esempio: comando da seriale
  if (Serial.available()) {
    int angle = Serial.parseInt();
    targetAngle = constrain(angle, 0, 180);
  }
}

// writeMicroseconds() è più preciso di write()
// write(90) internamente chiama writeMicroseconds(1472)
// ma la conversione gradi → µs può perdere risoluzione

// Servo continuo: usare writeMicroseconds per velocità
myServo.writeMicroseconds(1500);  // Fermo
myServo.writeMicroseconds(1300);  // Rotazione lenta oraria
myServo.writeMicroseconds(1000);  // Rotazione veloce oraria
myServo.writeMicroseconds(1700);  // Rotazione lenta antioraria
myServo.writeMicroseconds(2000);  // Rotazione veloce antioraria

#include <Servo.h>

struct ServoCtrl {
  Servo servo;
  int pos, target, step;
  unsigned long lastUpdate, interval;
};

ServoCtrl servos[3];

void setup() {
  servos[0].servo.attach(9);  servos[0].interval = 15;
  servos[1].servo.attach(10); servos[1].interval = 25;
  servos[2].servo.attach(11); servos[2].interval = 10;
  for (int i = 0; i < 3; i++) {
    servos[i].pos = 90; servos[i].target = 90;
    servos[i].servo.write(90);
  }
}

void updateServos() {
  unsigned long now = millis();
  for (int i = 0; i < 3; i++) {
    if (servos[i].pos == servos[i].target) continue;
    if (now - servos[i].lastUpdate < servos[i].interval) continue;
    servos[i].lastUpdate = now;
    servos[i].pos += (servos[i].target > servos[i].pos) ? 1 : -1;
    servos[i].servo.write(servos[i].pos);
  }
}

void loop() {
  updateServos();
  // Imposta target: servos[0].target = 45; ecc.
}

Sensore di distanza a ultrasuoni. Emette un impulso a 40 kHz e misura il tempo di ritorno dell'eco. Range: 2–400 cm. Non richiede librerie.

const byte TRIG = 9;
const byte ECHO = 10;

void setup() {
  pinMode(TRIG, OUTPUT);
  pinMode(ECHO, INPUT);
  Serial.begin(9600);
}

float readDistanceCm() {
  // Invia impulso trigger di 10µs
  digitalWrite(TRIG, LOW);
  delayMicroseconds(2);
  digitalWrite(TRIG, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIG, LOW);

  // Misura durata echo in µs
  unsigned long duration = pulseIn(ECHO, HIGH, 30000);
  // timeout 30ms ≈ ~510 cm max

  if (duration == 0) return -1;  // Nessun eco (fuori range)

  // Distanza = (tempo * velocità suono) / 2
  // v_suono ≈ 343 m/s = 0.0343 cm/µs
  return duration * 0.0343 / 2.0;
}

void loop() {
  float dist = readDistanceCm();
  if (dist > 0) {
    Serial.print("Distanza: ");
    Serial.print(dist, 1);
    Serial.println(" cm");
  } else {
    Serial.println("Fuori range");
  }
  delay(100);  // Min 60ms tra misure consecutive
}

Due tipi di buzzer: attivo (suona con solo 5V, no frequenza) e passivo (richiede onda quadra, pilotabile con tone()). tone() usa Timer2, quindi disabilita PWM su pin 3 e 11.

const byte BUZZER = 8;

// Definizione note
#define NOTE_C4  262
#define NOTE_D4  294
#define NOTE_E4  330
#define NOTE_F4  349
#define NOTE_G4  392
#define NOTE_A4  440
#define NOTE_B4  494
#define NOTE_C5  523
#define PAUSE    0

// Melodia: array di coppie {nota, durata_ms}
int melody[] = {
  NOTE_C4, 400, NOTE_D4, 400, NOTE_E4, 400, NOTE_F4, 400,
  NOTE_G4, 400, NOTE_A4, 400, NOTE_B4, 400, NOTE_C5, 800
};
int melodyLen = sizeof(melody) / sizeof(melody[0]) / 2;

void setup() {
  for (int i = 0; i < melodyLen; i++) {
    int nota = melody[i * 2];
    int dur  = melody[i * 2 + 1];
    if (nota != PAUSE)
      tone(BUZZER, nota, dur);
    delay(dur * 1.3);          // Pausa tra note (30%)
    noTone(BUZZER);
  }
}

// Beep di allarme senza tone() (bit-banging)
void beepManual(int freqHz, int durationMs) {
  long period = 1000000L / freqHz;
  long cycles  = (long)freqHz * durationMs / 1000;
  for (long i = 0; i < cycles; i++) {
    digitalWrite(BUZZER, HIGH);
    delayMicroseconds(period / 2);
    digitalWrite(BUZZER, LOW);
    delayMicroseconds(period / 2);
  }
}

Il sensore PIR (HC-SR501) rileva movimento tramite radiazione infrarossa. Output digitale: HIGH quando rileva movimento. Ha due trimmer: sensibilità e tempo di ritardo (2s–300s). Richiede ~60s di warm-up all'accensione.

const byte PIR_PIN = 2;
const byte LED_PIN = 13;

void setup() {
  pinMode(PIR_PIN, INPUT);
  pinMode(LED_PIN, OUTPUT);
  Serial.begin(9600);
  Serial.println(F("Calibrazione PIR... attendere 60s"));
  delay(60000);                    // Warm-up sensore
  Serial.println(F("Pronto."));
}

void loop() {
  if (digitalRead(PIR_PIN) == HIGH) {
    digitalWrite(LED_PIN, HIGH);
    Serial.println(F("Movimento rilevato!"));
  } else {
    digitalWrite(LED_PIN, LOW);
  }
  delay(200);
}

// Versione con interrupt (non-bloccante)
volatile bool motionDetected = false;

void motionISR() { motionDetected = true; }

void setup() {
  pinMode(PIR_PIN, INPUT);
  attachInterrupt(digitalPinToInterrupt(PIR_PIN), motionISR, RISING);
  Serial.begin(9600);
}

void loop() {
  if (motionDetected) {
    motionDetected = false;
    Serial.println(F("Movimento!"));
    // azione: accendi luce, allarme, ecc.
  }
}

Il fotoresistore (LDR) varia la sua resistenza con la luce: alta R al buio (~1 MΩ), bassa R in piena luce (~1 kΩ). Si legge con un partitore di tensione collegato a un pin analogico.

Circuito: 5V → LDR → nodo(A0) → R (10 kΩ) → GND. Più luce = più tensione su A0 (valore analogico alto).

const byte LDR_PIN = A0;
const byte LED_PIN = 9;  // Pin PWM

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

void loop() {
  int lux = analogRead(LDR_PIN);           // 0-1023

  // Accendi LED proporzionalmente al buio
  int brightness = map(lux, 0, 1023, 255, 0);
  analogWrite(LED_PIN, brightness);

  // Calcolo tensione e resistenza LDR
  float voltage = lux * 5.0 / 1023.0;
  float rLdr = 10000.0 * voltage / (5.0 - voltage);  // R partitore = 10k

  Serial.print("ADC: "); Serial.print(lux);
  Serial.print("  R_LDR: "); Serial.print(rLdr, 0);
  Serial.println(" ohm");
  delay(200);
}

Un termistor NTC (Negative Temperature Coefficient) diminuisce la resistenza con l'aumento della temperatura. Tipico: 10 kΩ a 25°C, B=3950. Si legge con partitore di tensione + equazione di Steinhart-Hart semplificata.

Circuito: 5V → R (10 kΩ) → nodo(A0) → NTC → GND.

const byte  NTC_PIN   = A0;
const float R_SERIES  = 10000.0;  // Resistenza partitore
const float R_NTC_25  = 10000.0;  // R del NTC a 25°C
const float BETA      = 3950.0;   // Coefficiente B (datasheet)
const float T_REF     = 298.15;   // 25°C in Kelvin

float readTemperature() {
  int adc = analogRead(NTC_PIN);
  float rNtc = R_SERIES * (1023.0 / adc - 1.0);

  // Equazione B-parameter (Steinhart-Hart semplificata)
  // 1/T = 1/T0 + (1/B) * ln(R/R0)
  float tKelvin = 1.0 / (1.0/T_REF + (1.0/BETA) * log(rNtc/R_NTC_25));
  return tKelvin - 273.15;  // Converti in °C
}

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

void loop() {
  float temp = readTemperature();
  Serial.print("Temperatura: ");
  Serial.print(temp, 1);
  Serial.println(" C");
  delay(500);
}

Per comandare carichi ad alta potenza (motori, lampade, elettrovalvole) servono relè o MOSFET come switch. Il pin Arduino fornisce solo il segnale di controllo.

const byte RELAY_PIN = 7;

void setup() {
  pinMode(RELAY_PIN, OUTPUT);
  digitalWrite(RELAY_PIN, HIGH);  // Molti moduli sono ACTIVE LOW
}

void loop() {
  digitalWrite(RELAY_PIN, LOW);   // Accendi (ACTIVE LOW)
  delay(5000);
  digitalWrite(RELAY_PIN, HIGH);  // Spegni
  delay(5000);
}

// Circuito: Drain → carico → V+
//           Source → GND
//           Gate → pin Arduino (R 100Ω serie, R 10k pulldown)
const byte MOSFET_PIN = 9;  // Pin PWM per controllo velocità

void setup() { pinMode(MOSFET_PIN, OUTPUT); }

void loop() {
  // Controllo velocità motore DC con PWM
  analogWrite(MOSFET_PIN, 64);   // 25%
  delay(2000);
  analogWrite(MOSFET_PIN, 128);  // 50%
  delay(2000);
  analogWrite(MOSFET_PIN, 255);  // 100%
  delay(2000);
  analogWrite(MOSFET_PIN, 0);    // OFF
  delay(2000);
}

LED RGB: tre LED (Rosso, Verde, Blu) in un unico package. Due tipi: anodo comune (pin lungo = 5V) e catodo comune (pin lungo = GND). Si controllano con PWM per miscelare colori.

// LED RGB Catodo Comune
// Pin lungo → GND; R/G/B → resistori 220Ω → pin PWM
const byte R_PIN = 9, G_PIN = 10, B_PIN = 11;

void setColor(byte r, byte g, byte b) {
  analogWrite(R_PIN, r);
  analogWrite(G_PIN, g);
  analogWrite(B_PIN, b);
}

// Per ANODO COMUNE: invertire i valori
// analogWrite(R_PIN, 255 - r); ecc.

void setup() {
  pinMode(R_PIN, OUTPUT);
  pinMode(G_PIN, OUTPUT);
  pinMode(B_PIN, OUTPUT);
}

void loop() {
  setColor(255, 0,   0);    delay(1000);  // Rosso
  setColor(0,   255, 0);    delay(1000);  // Verde
  setColor(0,   0,   255);  delay(1000);  // Blu
  setColor(255, 255, 0);    delay(1000);  // Giallo
  setColor(0,   255, 255);  delay(1000);  // Ciano
  setColor(255, 0,   255);  delay(1000);  // Magenta
  setColor(255, 255, 255);  delay(1000);  // Bianco

  // Dissolvenza arcobaleno
  for (int i = 0; i < 256; i++) {
    setColor(i, 255 - i, 0);
    delay(10);
  }
}

Lo shift register 74HC595 espande le uscite: con 3 pin Arduino si controllano 8 output digitali. Più 595 si possono collegare in cascata (daisy-chain) per 16, 24, ... uscite.

const byte DATA_PIN  = 11;  // DS
const byte CLOCK_PIN = 12;  // SHCP
const byte LATCH_PIN = 8;   // STCP

void updateShiftRegister(byte data) {
  digitalWrite(LATCH_PIN, LOW);
  shiftOut(DATA_PIN, CLOCK_PIN, MSBFIRST, data);
  digitalWrite(LATCH_PIN, HIGH);
}

void setup() {
  pinMode(DATA_PIN, OUTPUT);
  pinMode(CLOCK_PIN, OUTPUT);
  pinMode(LATCH_PIN, OUTPUT);
}

void loop() {
  // Knight Rider: LED che scorre avanti e indietro
  for (int i = 0; i < 8; i++) {
    updateShiftRegister(1 << i);
    delay(100);
  }
  for (int i = 6; i > 0; i--) {
    updateShiftRegister(1 << i);
    delay(100);
  }
}

// Due 595 in cascata (16 uscite)
void update16bit(uint16_t data) {
  digitalWrite(LATCH_PIN, LOW);
  shiftOut(DATA_PIN, CLOCK_PIN, MSBFIRST, data >> 8);   // Byte alto (2° chip)
  shiftOut(DATA_PIN, CLOCK_PIN, MSBFIRST, data & 0xFF); // Byte basso (1° chip)
  digitalWrite(LATCH_PIN, HIGH);
}

// Pattern macchina a stati
enum State { IDLE, HEATING, COOLING, ERROR };
State currentState = IDLE;

void loop() {
  switch (currentState) {
    case IDLE:
      if (temp < target) currentState = HEATING;
      break;
    case HEATING:
      activateHeater();
      if (temp >= target) currentState = COOLING;
      if (temp > MAX_SAFE) currentState = ERROR;
      break;
    // ...
  }
}

// Debounce con millis()
unsigned long lastDebounce = 0;
const unsigned long debounceDelay = 50;
int lastState = HIGH, stableState = HIGH;

void loop() {
  int reading = digitalRead(2);
  if (reading != lastState) lastDebounce = millis();
  if (millis() - lastDebounce > debounceDelay) {
    if (reading != stableState) {
      stableState = reading;
      if (stableState == LOW) { /* pulsante premuto */ }
    }
  }
  lastState = reading;
}

// Calcolo memoria libera
int freeMemory() {
  extern int __heap_start, *__brkval;
  int v;
  return (int)&v - (__brkval == 0
    ? (int)&__heap_start : (int)__brkval);
}

// Lookup table in PROGMEM
const uint8_t sineTable[] PROGMEM = {
  128, 131, 134, 137, /* ... 256 valori */
};
uint8_t val = pgm_read_byte(&sineTable[i]);

// Aritmetica a punto fisso (8.8 fixed point)
int16_t temp_fixed = 2350;       // 23.50°C * 100
int16_t result = temp_fixed * 9 / 5 + 3200;  // Fahrenheit * 100

// Scheduler cooperativo multi-task
struct Task {
  unsigned long interval;
  unsigned long lastRun;
  void (*callback)();
};

void readSensors() { /* ogni 100ms */ }
void updateDisplay() { /* ogni 500ms */ }
void logData() { /* ogni 5000ms */ }

Task tasks[] = {
  {100,  0, readSensors},
  {500,  0, updateDisplay},
  {5000, 0, logData}
};
const int NUM_TASKS = sizeof(tasks) / sizeof(tasks[0]);

void loop() {
  unsigned long now = millis();
  for (int i = 0; i < NUM_TASKS; i++) {
    if (now - tasks[i].lastRun >= tasks[i].interval) {
      tasks[i].lastRun = now;
      tasks[i].callback();
    }
  }
}

// Compilazione condizionale per debug
#define DEBUG  // Commentare per produzione

#ifdef DEBUG
  #define DBG(x)   Serial.print(F(x))
  #define DBGLN(x) Serial.println(F(x))
  #define DBGV(x)  Serial.println(x)
#else
  #define DBG(x)
  #define DBGLN(x)
  #define DBGV(x)
#endif

void setup() {
  #ifdef DEBUG
    Serial.begin(115200);
    DBGLN("Sistema avviato");
  #endif
}

void loop() {
  int val = analogRead(A0);
  DBG("Sensore: ");
  DBGV(val);       // In produzione: zero overhead
}

// Output per Serial Plotter (valori separati da tab)
Serial.print(temp);
Serial.print("\t");
Serial.print(humidity);
Serial.print("\t");
Serial.println(pressure);