Descrizione

[vc_row][vc_column][vc_column_text]

⚙️ 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++;
}

[/vc_column_text][/vc_column][/vc_row]