Descrizione

⚙️ Modulo Sensore di Velocità con Encoder Digitale – Descrizione Completa

✅ Cos’è?

Il Modulo Sensore di Velocità con encoder digitale è un dispositivo progettato per misurare la velocità angolare o la rotazione di un asse (ad esempio ruote motrici) utilizzando un sistema ottico a infrarossi. È comunemente impiegato nei robot mobili, nei sistemi di conteggio rotazioni e nei progetti che richiedono la misura di velocità o distanza percorsa.

🔧 Come funziona

Il modulo sfrutta:

• Un emettitore IR (LED infrarosso)
• Un ricevitore IR (fototransistor)
• Un disco forato o a strisce alternate (encoder ottico)

Quando il disco ruota, i fori o le strisce interrompono il fascio IR, generando impulsi digitali che Arduino può contare per determinare la velocità o la distanza.

🧩 Componenti principali del modulo

• Emettitore + ricevitore IR
• Comparatori per pulire il segnale
• Uscita digitale a onda quadra (HIGH/LOW)
• Interfaccia con 3 o 4 pin (VCC, GND, OUT, a volte anche A0)
• Supporto meccanico per asse/disco

📦 Caratteristiche tecniche

🔌 Collegamento con Arduino

🧰 Materiali

• Arduino Uno/Nano/Mega
• Modulo encoder IR
• Disco forato o ruota con strisce nere/bianche
• Cavi jumper

🖇️ Schema di collegamento

⚠️ Importante: collega OUT a un pin con interrupt hardware (D2 o D3 su Arduino Uno) per conteggio preciso.

👨‍💻 Codice di esempio base: conteggio impulsi

volatile int impulsi = 0;

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

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

void contaImpulso() {
  impulsi++;
}

Ogni impulso corrisponde a un’interruzione del raggio IR, quindi a una “finestra” del disco.

📐 Calcolo velocità e distanza

🧮 Formula (esempio base):

velocita = (impulsi / numero_fessure) * (2 * PI * raggio) / tempo;

Dove:

• numero_fessure = quanti fori/strisce ci sono nel disco
• raggio = raggio ruota in metri
• tempo = tempo tra due letture (in secondi)

🧪 Esempio: velocità lineare

#define FESSURE 20
#define RAGGIO_CM 3.0

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

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

void loop() {
  delay(1000); // campionamento ogni 1 sec

  noInterrupts();
  int conteggio = impulsi;
  impulsi = 0;
  interrupts();

  float giroRuota = 2 * PI * RAGGIO_CM / 100.0;
  float giri = (float)conteggio / FESSURE;
  float distanza = giri * giroRuota;
  float velocita = distanza / 1.0; // m/s, perché il tempo è 1 sec

  Serial.print("Velocità (m/s): ");
  Serial.println(velocita);
}
void contaImpulso() {
  impulsi++;
}

🔬 Test e calibrazione

• Usa un disco con numero noto di fessure
• Misura il diametro effettivo della ruota
• Verifica la precisione su rotazioni note (es. 1 giro completo = 20 impulsi)
• Se il segnale è instabile, aggiungi un condensatore di decoupling o un filtro software

🧠 Applicazioni pratiche

• 🚗 Robot mobili: calcolo distanza percorsa
• 📦 Nastri trasportatori: conta oggetti o lunghezza
• 🏎️ Auto RC / veicoli autonomi: controllo velocità
• ⚙️ Macchine CNC: encoder per asse di movimento
• ⏱️ Cronometraggio: misure di velocità in fisica sperimentale

📝 Conclusione

✅ Il sensore di velocità con encoder è uno strumento versatile e semplice da usare
✅ Fornisce dati precisi su rotazioni, velocità e distanza
✅ Essenziale nei progetti di robotica, automazione e ingegneria meccanica

// -------------------------------
// Modulo Encoder Velocità IR
// -------------------------------

#define ENCODER_PIN 2              // Collegato all'uscita digitale del modulo IR
#define NUM_FESSURE 20             // Numero di fessure/strisce sul disco
#define RAGGIO_RUOTA_CM 3.0        // Raggio della ruota in cm

volatile unsigned int impulsi = 0;
unsigned long tempoPrecedente = 0;
const unsigned long intervallo = 1000; // Tempo tra letture (ms)

void setup() {
  pinMode(ENCODER_PIN, INPUT);
  attachInterrupt(digitalPinToInterrupt(ENCODER_PIN), contaImpulsi, RISING);
  Serial.begin(9600);
  Serial.println("Sensore Encoder IR Avviato");
}

void loop() {
  unsigned long tempoAttuale = millis();

  if (tempoAttuale - tempoPrecedente >= intervallo) {
    noInterrupts();               // Disattiva gli interrupt per leggere in modo sicuro
    unsigned int conteggio = impulsi;
    impulsi = 0;
    interrupts();                 // Riattiva gli interrupt

    // Calcolo della distanza e velocità
    float giri = (float)conteggio / NUM_FESSURE;
    float circonferenza = 2 * PI * RAGGIO_RUOTA_CM / 100.0; // in metri
    float distanza = giri * circonferenza;                  // in metri
    float velocita = distanza / (intervallo / 1000.0);      // m/s

    Serial.print("Impulsi: ");
    Serial.print(conteggio);
    Serial.print(" | Distanza: ");
    Serial.print(distanza, 3);
    Serial.print(" m | Velocità: ");
    Serial.print(velocita, 3);
    Serial.println(" m/s");

    tempoPrecedente = tempoAttuale;
  }
}

void contaImpulsi() {
  impulsi++;
}

Tutorial: Come usare il Modulo Sensore di Velocità

Il Modulo Sensore di Velocità con encoder digitale è ideale per misurare la velocità di rotazione di un motore o di un dispositivo rotante. Utile per progetti di robotica e automazione.

Cosa serve

• Arduino UNO o compatibile
• Filtri elettrici (R/C)
• Cavo di alimentazione 5V
• Cavo di dati (per i pin di I/O)

Passi

1. 1. Collega il modulo al Arduino tramite i pin GND, 5V, D2 e D3.
2. 2. Monta un filtro elettrico tra 5V e GND per proteggere il modulo.
3. 3. Collega il cavo di alimentazione 5V al modulo.
4. 4. Collega il cavo di dati al pin D2 e D3.
5. 5. Carica l’Arduino IDE.
6. 6. Inserisci il codice di esempio fornito.
7. 7. Carica il codice su Arduino.
8. 8. Controlla la velocità di rotazione visualizzata sulla console seriale.

Codice di esempio

```cpp
#include <Encoder.h>

Encoder myEncoder(D2, D3);

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

void loop() {
  Serial.println(myEncoder.read());
}
```

Mini-progetto

Crea un dispositivo di controllo di velocità per un motore DC utilizzando il modulo e l’Arduino.

Errori comuni

• Omettere di collegare il filtro elettrico.
• Collegare i pin sbagliati.
• Dimenticare di caricare il codice.
• Non verificare la connettività dei pin prima di caricare il codice.

Accessori consigliati

• Motore DC
• Arduino UNO
• Filtro elettrico (R/C)
• Cavo di alimentazione 5V

Domande frequenti

Il modulo funziona con un’alimentazione diversa da 5V?
Verifica sul datasheet. Altre alimentazioni potrebbero richiedere un convertitore.

Quali pin dell’Arduino devo utilizzare?
Utilizza i pin D2 e D3 per connettere il modulo.

Il modulo funziona con Arduino compatibili?
Sì, ma assicurati che l’alimentazione sia compatibile con 5V.

Come posso verificare la connessione?
Controlla la console seriale dopo aver caricato il codice.