Modulo motore con L9110 per Arduino e ESP

Il modulo in figura è un driver per motori DC basato sul chip L9110, progettato per il controllo di due motori in corrente continua o di un motore passo-passo bipolare.
Integra due ponti H indipendenti, ciascuno in grado di gestire direzione e velocità del motore tramite segnali digitali o PWM provenienti da un microcontrollore (come ESP32, Arduino, ecc.).
Il modulo dispone di morsetti a vite per il collegamento dei motori e di un connettore a pin per alimentazione e segnali di controllo, risultando compatto, semplice da usare e ideale per piccoli robot, veicoli RC e progetti didattici.

Indice

Descrizione del modulo motore L9110

Questo modulo utilizza 2 chip H-bridge tipo L9110 (oppure tipo HG7881) indipendenti ognuno dei quali può pilotare un motore con una corrente di esercizio fino 800mA, con una corrente massima di picco di 1.5-2A.
La scheda può essere pilotata con livelli logici TTL compresi tra 2,5 V e 12 V questo permette l’utilizzo con microcontrollori alimentati a 3.3V oppure 5V.

La velocità dei motori può venire controllata tramite PWM, mentre la direzione è data da un livello logico.
Questo modulo può anche essere utilizzato per pilotare un motore passo-passo a due fasi.
La scheda dispone di 6 pin maschio e 2 terminali doppi. I motori si collegano ai 2 terminali. I pin di alimentazione VCC e GND sono posti al centro del connettore.

Il modulo, a differenza degli H-bridge come la L293 e L298, non richiede una tensione separata per la parte logica e per l’alimentazione dei motori ma sarà sufficiente fornire uno tensione compresa tra i 2,5 e i 12V.

Caratteristiche

Alimentazione motore e modulo:	da 2.5V a 12V
Gestione motori:	2 Motori in CC oppure un singolo motore passo passo
Massimo assorbimento per canale:	800mA continui
Dimensioni:	31mm x 22mm x 12mm
Peso:	7 gr.

Schema elettrico del modulo motore L9110

Lo schema elettrico del modulo è molto semplice, il collegamento dell’integrato L9110 (datasheet) è quello tipico riportato nel datasheet.


Pin	Foto del chip

Pin	Descrizione
B-IA	Motore B Input A (IA)
B-IB	Motore B Input B (IB)
GND	Negativo alimentazione
VCC	Positivo alimentazione 2.5-12V
A-IA	Motore A Input A (IA)
A-IB	Motore A Input B (I

Sugli ingressi di controllo sono presenti delle resistenze di pull-up R1, R2, R3, R4 da 10K per mantenere stabile il segnale di controllo. La tensione di alimentazione è filtrata dai due condensatori C1 10 μF e C2 1 μF. È inoltre presente il diodo led D1 con la sua resistenza di limitazione R5 da 1K la cui accensione segnala la presenza della tensione di alimentazione. Sulla morsettiera d’uscita verso i motori sono presenti due ulteriori condensatori di filtro C3 e C4 da 100 nF.

Lo schema sotto riportato è stato realizzato con il programma EasyEDA, per informazioni vedere l’articolo EasyEDA – Freeware per circuiti stampati

Montaggio del modulo

Il modulo arriverà in un blister antistatico. Per poterlo utilizzare, occorre saldare dei pinhead non presenti, in alternativa è possibile saldare direttamente i cavi sui pad.

Esempio di gestione di un solo motore

Vediamo un test del modulo. In questo caso comanderemo la rotazione di due piccoli moto riduttori.
Lo schema di collegamento è riportato nell’immagine sotto:

Sono stati utilizzati i seguenti componenti

Scheda Uno R3 o Scheda UNO R3 – ELEGOO

Modulo motore L9110

Motoriduttore

Cavetti colorati

Primo programma – senza uso PWM

Ecco un codice Arduino di test semplice per un solo driver L9110 collegato ad un motore DC.
Si dovrà verificarne direzione e “on/off” prima di usarlo in un progetto completo.
L’alimentazione dei motori può essere separata (consigliata) purché massa Arduino e massa motori siano collegate insieme.

Tabella della verità
Ingresso		Uscita		Descrizione
IA	IB	OA	OB	Descrizione
L	L	L	L	Off
H	L	H	L	Forward
L	H	L	H	Reverse
H	H	L	L	Off

// Test singolo motore con driver L9110
// Pin di controllo motore
const int PIN_INA = 9;  // controllo 1
const int PIN_INB = 10; // controllo 2

void setup() {
  // Imposta pin motore come uscite
  pinMode(PIN_INA, OUTPUT);
  pinMode(PIN_INB, OUTPUT);

  // Spegni motore all'avvio
  digitalWrite(PIN_INA, LOW);
  digitalWrite(PIN_INB, LOW);

  Serial.begin(9600);
  Serial.println("Test singolo motore L9110");
}

void loop() {
  Serial.println("Rotazione in avanti...");
  // Motore gira in un verso
  digitalWrite(PIN_INA, HIGH);  // livello alto
  digitalWrite(PIN_INB, LOW);   // opposto basso
  delay(2000);

  Serial.println("Stop...");
  // Ferma motore
  digitalWrite(PIN_INA, LOW);
  digitalWrite(PIN_INB, LOW);
  delay(1000);

  Serial.println("Rotazione indietro...");
  // Motore gira nell'altro verso
  digitalWrite(PIN_INA, LOW);
  digitalWrite(PIN_INB, HIGH);
  delay(2000);

  Serial.println("Stop...");
  digitalWrite(PIN_INA, LOW);
  digitalWrite(PIN_INB, LOW);
  delay(3000);
}

// Test singolo motore con driver L9110

// Pin di controllo motore

const int PIN_INA = 9; // controllo 1

const int PIN_INB = 10; // controllo 2

void setup() {

// Imposta pin motore come uscite

pinMode(PIN_INA, OUTPUT);

pinMode(PIN_INB, OUTPUT);

// Spegni motore all'avvio

digitalWrite(PIN_INA, LOW);

digitalWrite(PIN_INB, LOW);

Serial.begin(9600);

Serial.println("Test singolo motore L9110");

}

void loop() {

Serial.println("Rotazione in avanti...");

// Motore gira in un verso

digitalWrite(PIN_INA, HIGH); // livello alto

digitalWrite(PIN_INB, LOW); // opposto basso

delay(2000);

Serial.println("Stop...");

// Ferma motore

digitalWrite(PIN_INA, LOW);

digitalWrite(PIN_INB, LOW);

delay(1000);

Serial.println("Rotazione indietro...");

// Motore gira nell'altro verso

digitalWrite(PIN_INA, LOW);

digitalWrite(PIN_INB, HIGH);

delay(2000);

Serial.println("Stop...");

digitalWrite(PIN_INA, LOW);

digitalWrite(PIN_INB, LOW);

delay(3000);

}

Primo programma – utilizzo PWM

Ecco la versione per codice con controllo della velocità (PWM) per un solo driver L9110 e un motore DC, pensata per schede Arduino classiche (UNO, Nano, Mega).
Usiamo pin PWM (contrassegnati con ~ su Arduino UNO). Il PWM viene applicato a uno solo dei due pin, l’altro resta LOW.
Per regolare la velocità, occorre modificare il valore della variabile “spedMotor” , nell’esempio posto al valore di 180.

Valore	Effetto
0	motore fermo
80–120	velocità bassa
150–200	velocità media
255	massima velocità

// ================================
// Test L9110 con controllo velocità
// Arduino UNO / Nano / Mega
// ================================

// Pin di controllo
const int PIN_INA = 9;   // PWM
const int PIN_INB = 10;  // Direzione

// Velocità motore (0 - 255)
int speedMotor = 180;  // cambia questo valore per il test

void setup() {
  pinMode(PIN_INA, OUTPUT);
  pinMode(PIN_INB, OUTPUT);

  // Motore fermo all'avvio
  digitalWrite(PIN_INA, LOW);
  digitalWrite(PIN_INB, LOW);

  Serial.begin(9600);
  Serial.println("Test L9110 con controllo velocità");
}

void loop() {

  // ===== Rotazione avanti =====
  Serial.println("Avanti");
  digitalWrite(PIN_INB, LOW);        // direzione
  analogWrite(PIN_INA, speedMotor);  // PWM velocità
  delay(3000);

  // ===== Stop =====
  Serial.println("Stop");
  digitalWrite(PIN_INA, LOW);
  digitalWrite(PIN_INB, LOW);
  delay(1500);

  // ===== Rotazione indietro =====
  Serial.println("Indietro");
  digitalWrite(PIN_INA, LOW);        // direzione
  analogWrite(PIN_INB, speedMotor);  // PWM velocità
  delay(3000);

  // ===== Stop =====
  Serial.println("Stop");
  digitalWrite(PIN_INA, LOW);
  digitalWrite(PIN_INB, LOW);
  delay(3000);
}

// ================================

// Test L9110 con controllo velocità

// Arduino UNO / Nano / Mega

// ================================

// Pin di controllo

const int PIN_INA = 9; // PWM

const int PIN_INB = 10; // Direzione

// Velocità motore (0 - 255)

int speedMotor = 180; // cambia questo valore per il test

void setup() {

pinMode(PIN_INA, OUTPUT);

pinMode(PIN_INB, OUTPUT);

// Motore fermo all'avvio

digitalWrite(PIN_INA, LOW);

digitalWrite(PIN_INB, LOW);

Serial.begin(9600);

Serial.println("Test L9110 con controllo velocità");

}

void loop() {

// ===== Rotazione avanti =====

Serial.println("Avanti");

digitalWrite(PIN_INB, LOW); // direzione

analogWrite(PIN_INA, speedMotor); // PWM velocità

delay(3000);

// ===== Stop =====

Serial.println("Stop");

digitalWrite(PIN_INA, LOW);

digitalWrite(PIN_INB, LOW);

delay(1500);

// ===== Rotazione indietro =====

Serial.println("Indietro");

digitalWrite(PIN_INA, LOW); // direzione

analogWrite(PIN_INB, speedMotor); // PWM velocità

delay(3000);

// ===== Stop =====

Serial.println("Stop");

digitalWrite(PIN_INA, LOW);

digitalWrite(PIN_INB, LOW);

delay(3000);

}

Alcuni esempi di utilizzo

Altri moduli per controllo motori

Altri tipi di controllo motori possono essere trovati in questo post