Motorino elettrico N20 con motoriduttore e Ingranaggi in Metallo con Mandrino in Plastica

Descrizione

---

1. Descrizione del modulo N20 con motoriduttore e mandrino

Caratteristiche principali

• Tipo di motore: Motore DC miniatura N20
• Tensione di funzionamento tipica: 3 V – 12 V DC (versione più comune: 6 V o 12 V)
• Corrente a vuoto: ~ 40–200 mA (dipende dal carico e dalla tensione)
• Corrente di stallo: ~ 1–1,5 A (attenzione a non superare il limite del driver)
• Velocità nominale: variabile in base al rapporto di riduzione (es. 100 rpm, 200 rpm, 600 rpm, ecc.)
• Coppia: elevata grazie al motoriduttore
• Motoriduttore: ingranaggi interni in metallo per maggiore resistenza
• Mandrino in plastica: montato sull’albero di uscita per collegare direttamente piccole punte, ruote, eliche o accessori
• Dimensioni tipiche del corpo motore: 12 × 10 × 15 mm (solo motore) + lunghezza riduttore

---

2. Come funziona

Il motore N20 è un motore DC a spazzole, quindi funziona semplicemente alimentandolo con corrente continua.
Il motoriduttore riduce la velocità e aumenta la coppia.
Il mandrino in plastica serve come supporto per fissare utensili o elementi rotanti.

Nota: essendo un motore DC, non può essere collegato direttamente ad Arduino, perché richiede più corrente di quella che i pin possono fornire. Serve un driver per motori o un ponte H (es. L298N, L293D, TB6612FNG o un MOSFET).

---

3. Collegamento con Arduino

Materiale necessario

• Arduino UNO/Nano/Leonardo
• Modulo driver motore (es. L298N o TB6612FNG)
• Alimentatore per motore (batteria LiPo 7,4 V, 6 × AA, o alimentatore 6–12 V)
• Cavi jumper
• Breadboard (opzionale)

Schema con TB6612FNG (consigliato)

Arduino           TB6612FNG           N20
--------------------------------------------
Pin 9  ---------- PWMA
Pin 8  ---------- AIN2
Pin 7  ---------- AIN1
5V     ---------- VCC
GND    ---------- GND
Motor A terminals -------------- Motore N20
VM     ---------- +6V / +12V da alimentatore esterno
GND    ---------- GND alimentatore esterno (comune con Arduino)

Il pin PWMA controlla la velocità (PWM), AIN1 e AIN2 controllano la direzione.

---

4. Esempio base di codice Arduino

// Controllo N20 con TB6612FNG
int PWMA = 9;   // PWM velocità
int AIN1 = 7;   // Direzione
int AIN2 = 8;   // Direzione

void setup() {
  pinMode(PWMA, OUTPUT);
  pinMode(AIN1, OUTPUT);
  pinMode(AIN2, OUTPUT);
}

void loop() {
  // Ruota in avanti a metà velocità
  digitalWrite(AIN1, HIGH);
  digitalWrite(AIN2, LOW);
  analogWrite(PWMA, 128); // 0-255

  delay(2000);

  // Stop
  analogWrite(PWMA, 0);
  delay(1000);

  // Ruota indietro a massima velocità
  digitalWrite(AIN1, LOW);
  digitalWrite(AIN2, HIGH);
  analogWrite(PWMA, 255);

  delay(2000);

  // Stop
  analogWrite(PWMA, 0);
  delay(2000);
}

---

5. Esempi di utilizzo pratico

• Robotica: ruote di piccoli robot, piattaforme mobili
• Meccanismi automatici: serrature elettriche, sistemi di apertura
• Mini trapani o avvitatori: grazie al mandrino, può tenere punte o accessori
• Progetti di modellismo: barche, macchine in scala, eliche
• Meccanismi scenografici: movimenti lenti e controllati

---

6. Consigli d’uso

• Non alimentare direttamente dal pin 5V di Arduino: rischi di bruciare la scheda
• Usa sempre un alimentatore separato per il motore
• Condividi il GND tra Arduino e il driver del motore
• Se usi un rapporto di riduzione molto alto (es. <100 rpm) avrai più coppia ma meno velocità
• Non bloccare l’albero durante il funzionamento: il motore può surriscaldarsi

---

Tutorial: Come usare Motorino N20

Il motorino N20 è ideale per progetti che richiedono movimento preciso e potente, come robot, carrelli mobili o giocattoli. Utile per maker principianti e intermedi.

Cosa serve

• Motorino N20
• Arduino o microcontrollore compatibile
• Alimentatore da 6V a 12V
• Inerzia minima (ad esempio un carrello leggero)

Passi

1. 1. Controlla che l’alimentazione sia compatibile (6V-12V). Verifica sul datasheet.
2. 2. Connetti l’alimentatore al motorino N20.
3. 3. Collega il motorino al pin di uscita di un Arduino (ad esempio, al pin 9).
4. 4. Carica il codice di esempio su Arduino (verifica sul datasheet).
5. 5. Controlla che il mandrino sia correttamente montato.
6. 6. Testa il moto avanti e indietro.
7. 7. Regola la velocità con il potenziometro (se presente).
8. 8. Monta il carrello o l’applicazione su cui vuoi utilizzare il motorino.

Codice di esempio

```
#include <AccelStepper.h>

const int stepPin = 9;
const int dirPin = 10;
AccelStepper stepper(AccelStepper::FULL_STEP, stepPin, dirPin);

void setup() {
  stepper.setSpeed(600);
  stepper.moveTo(5000);
}

void loop() {
  if (stepper.distanceToGo() == 0) {
    stepper.moveTo(-5000);
  }
  stepper.run();
}
```

Mini-progetto

Costruisci un carrello mobile che si muove avanti e indietro. Monta il motorino N20, collega l’Arduino e il microcontrollore, e controlla che il carrello si muova correttamente.

Errori comuni

• Collegare l’alimentazione errata (verifica sul datasheet).
• Omettere il collegamento del potenziometro (se presente).
• Montare il carrello troppo pesante.
• Dimenticare di caricare il codice su Arduino.

Accessori consigliati

• Inerzia minima (ad esempio un carrello leggero)
• Potenziometro (se necessario)
• Supporto per il motorino
• Cordoni di protezione

Domande frequenti

Come posso regolare la velocità?
Usa il potenziometro (se presente) o regola la velocità nel codice Arduino.

Il motorino funziona con batterie AA?
Verifica sul datasheet. Probabilmente richiede un alimentatore da 6V a 12V.

Quali microcontrollores sono compatibili?
Qualsiasi microcontrollore con pin di uscita compatibili.

Posso utilizzare questo motorino per progetti di stampa 3D?
Verifica sul datasheet. Il motorino N20 è progettato per movimenti lineari, non per stampa 3D.