Modulo Sensore di Velocità Infrarossi Encoder Digitale

🔍 Descrizione del Modulo Sensore di Velocità Infrarossi Encoder Digitale

✅ Caratteristiche principali

Il Modulo Sensore di Velocità a Infrarossi (IR) con Encoder Digitale è un dispositivo comunemente utilizzato per il rilevamento della velocità di rotazione o del conteggio delle rotazioni di oggetti in movimento, come motori o ruote.

• Tipo di sensore: Ottico a infrarossi
• Uscita: Digitale (0 o 1 logico)
• Principio di funzionamento: Interruzione di un fascio IR da parte di un disco codificato (encoder disk)
• Tensione operativa: 3.3V – 5V
• Tipo di uscita: Segnale digitale (HIGH/LOW)
• Pin: VCC, GND, OUT
• Frequenza supportata: Fino a ~1000 RPM (dipende dal disco encoder)

🧰 Applicazioni tipiche

• Misurazione della velocità angolare di motori
• Conta impulsi (tachimetri)
• Robotica e automazione
• Encoder ottici per ruote robotiche

⚙️ Componenti necessari per il progetto con Arduino

• 1x Arduino UNO (o compatibile)
• 1x Modulo Sensore di Velocità IR
• 1x Disco Encoder (ruota codificata, forata)
• Cavi Dupont
• Motore DC (facoltativo)
• Breadboard (opzionale)

🔌 Collegamenti elettrici

🖥️ Codice di esempio per Arduino

1. Lettura degli impulsi

volatile int conta_impulsi = 0;

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

void loop() {
  Serial.print("Impulsi contati: ");
  Serial.println(conta_impulsi);
  delay(1000);
}

void contaImpulso() {
  conta_impulsi++;
}

✅ Questo sketch usa l’interrupt su pin 2 (solo i pin 2 e 3 supportano interrupt su Arduino UNO) per contare le interruzioni generate dal disco encoder.

2. Calcolo della velocità angolare (RPM)

Supponiamo che il disco abbia 20 fori (20 impulsi per giro completo):

volatile int impulsi = 0;
unsigned long tempo_precedente = 0;

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

void loop() {
  unsigned long tempo_attuale = millis();
  
  if (tempo_attuale - tempo_precedente >= 1000) {
    noInterrupts(); // disabilita gli interrupt per lettura sicura
    int rpm = (impulsi * 60) / 20; // 20 fori -> 20 impulsi per rotazione
    impulsi = 0;
    interrupts(); // riattiva gli interrupt

    Serial.print("RPM: ");
    Serial.println(rpm);
    tempo_precedente = tempo_attuale;
  }
}

void contaImpulso() {
  impulsi++;
}

📏 Guida alla taratura e test

1. Installazione fisica: Monta il sensore vicino al disco forato sul motore. Assicurati che il raggio infrarosso attraversi i fori del disco encoder.
2. Allineamento: Il fascio IR deve colpire esattamente l’intervallo tra i fori. Una cattiva allineazione riduce l’affidabilità della lettura.
3. Verifica funzionamento: Utilizza il primo sketch per assicurarti che gli impulsi vengano letti correttamente.
4. Misura RPM: Usa il secondo sketch per stimare la velocità di rotazione del disco.

💡 Suggerimenti pratici

• Usa dischi encoder stampabili in 3D o acquistabili, con un numero noto di fori.
• Per migliorare la stabilità, filtra elettricamente l’alimentazione del modulo (es. con un condensatore da 100nF tra VCC e GND).
• Il modulo può essere utilizzato anche per rilevare oggetti che passano in una linea di produzione (conta pezzi).

📚 Risorse aggiuntive

• Encoder Wheel Generator (PDF) – crea dischi encoder stampabili
• Arduino attachInterrupt() reference

Perfetto! Estendiamo ora la guida per includere:

1. ✅ Controllo di un motore DC con encoder IR
2. ✅ Implementazione di un controllo PID della velocità
3. ✅ Codice completo e spiegazione
4. ✅ Schema funzionale del sistema

🔁 Obiettivo del progetto

Realizzare un controllo di velocità a circuito chiuso per un motore DC, usando:

• Un modulo encoder IR digitale per misurare la velocità
• Un algoritmo PID per mantenere costante la velocità desiderata
• Un motore DC pilotato da un modulo driver (es. L298N, L9110, L293D)

🔩 Componenti aggiuntivi necessari

• 1x Motore DC
• 1x Disco Encoder con fori
• 1x Driver motore (es. L298N o L9110S)
• 1x Alimentatore esterno (motore)
• 1x Potenziometro (facoltativo, per impostare la velocità)
• Arduino UNO o compatibile

🔌 Schema elettrico (con L298N)

🧠 Struttura del codice: PID + Encoder + PWM

Il PID regola il segnale PWM per mantenere costante la velocità misurata dal sensore encoder.

⚙️ 1. Dichiarazioni e libreria PID

Installa la libreria PID_v1 da Arduino IDE (via Library Manager).

#include <PID_v1.h>

// PID Variables
double setpointRPM = 100;     // Valore desiderato (impostabile)
double inputRPM = 0;          // Valore letto dal sensore
double outputPWM = 0;         // Output PID -> PWM

// PID tunings: Kp, Ki, Kd
PID myPID(&inputRPM, &outputPWM, &setpointRPM, 2.0, 5.0, 1.0, DIRECT);

📏 2. Impulsi dal sensore

volatile int impulsi = 0;

void contaImpulso() {
  impulsi++;
}

🔁 3. Setup

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

  // Encoder
  pinMode(2, INPUT);
  attachInterrupt(digitalPinToInterrupt(2), contaImpulso, RISING);

  // Motore
  pinMode(8, OUTPUT);
  pinMode(9, OUTPUT);
  pinMode(10, OUTPUT);

  // Direzione motore fissa
  digitalWrite(8, HIGH);
  digitalWrite(9, LOW);

  // PID
  myPID.SetMode(AUTOMATIC);
  myPID.SetOutputLimits(0, 255); // PWM range
}

🔄 4. Loop: calcolo RPM e controllo PID

unsigned long tPrecedente = 0;
int foriDisco = 20;

void loop() {
  unsigned long tempo = millis();
  
  // Calcola RPM ogni 100 ms
  if (tempo - tPrecedente >= 100) {
    noInterrupts();
    int lettura = impulsi;
    impulsi = 0;
    interrupts();

    inputRPM = (lettura * 600.0) / foriDisco; // 600 = 60 sec/min * 100ms
    myPID.Compute(); // Calcola outputPWM

    analogWrite(10, (int)outputPWM); // Controlla motore

    // Debug seriale
    Serial.print("Setpoint: "); Serial.print(setpointRPM);
    Serial.print(" RPM -> Misurato: "); Serial.print(inputRPM);
    Serial.print(" PWM: "); Serial.println(outputPWM);

    tPrecedente = tempo;
  }
}

🎛️ (Facoltativo) Controllo della velocità via potenziometro

setpointRPM = map(analogRead(A0), 0, 1023, 0, 300);

Collega un potenziometro tra 5V – A0 – GND per regolare dinamicamente la velocità desiderata.

🧪 Taratura del PID

I valori iniziali di Kp, Ki, Kd devono essere adattati al tuo motore e carico:

PID myPID(&inputRPM, &outputPWM, &setpointRPM, 2.0, 5.0, 1.0, DIRECT);

• Kp (Proporzionale): aumenta per risposta più veloce
• Ki (Integrativo): corregge l’errore a lungo termine
• Kd (Derivativo): attenua oscillazioni

Inizia con solo Kp, poi aggiungi Ki, infine Kd.

✅ Risultato atteso

• Il motore mantiene una velocità costante anche se la tensione cambia o il carico varia
• Puoi impostare la velocità desiderata modificando setpointRPM
• Il sistema si autoregola con l’algoritmo PID

🧩 Estensioni possibili

• 📈 Log dati su SD card o monitor seriale
• 🧭 Controllo PID su 2 motori per robot differenziale
• 🕹️ Controllo remoto della velocità via Bluetooth o Wi-Fi
• 📊 Interfaccia grafica su Processing o Python