Shield L293D – Collegamento Arduino e programma per variare la velocità di un motore DC 👨💻

Home > Arduino > Variazione velocità motore DC

Come variare la velocità di un motore DC con un Arduino e un L293D'un moteur à courant continu avec une Arduino et un L293D

Quando si vuole controllare un motore DC, a volte è necessario scegliere il senso di rotazione del motore ma anche cambiare la velocità di rotazione dell’albero del motore.
Per semplificare la variazione della velocità di un motore a corrente continua, sto usando un Arduino e una scheda L293D che mi permetterà di cambiare la velocità di rotazione del motore da un set point PWM.
Come faccio a collegare l’Arduino, il motore shield L293D e il motore DC? Quali programmi si usano per gestire la velocità del motore a corrente continua?
Scopri le risposte a queste domande leggendo questo articolo dedicato alla variazione di velocità.

Contenuti:

– Qual è l’hardware utilizzato in questo tutorial?
РQual ̬ il segnale PWM generato da Arduino?
– Come collegare l’arduino e lo scudo motore L293D?
– Programmazione di Arduino per la variazione di velocità
– Variazione di velocità nel video

Qual è l’hardware usato in questo tutorial?

Per eseguire i diversi esperimenti o per riprodurre le spiegazioni a casa, avrete bisogno delle seguenti attrezzature:
– Un Arduino e il suo cavo USB.
– Un modulo L293D (Mini 4-Channel Motor Drive Shield L293D).
– Piastre di prova o cavi di prototipazione (maschio/maschio, maschio/femmina, femmina/femmina).
– Un motore DC, personalmente l’ho preso da una vecchia stampante.
– Un alimentatore switching per alimentare il motore.
– Un potenziometro rotativo per variare la resistenza.
– Un joystick XY a doppio asse per variare la resistenza come il potenziometro.
– Una scheda per esperimenti o breadboard (opzionale).
Hardware utilizzato per variare la velocità di un motore DC'un moteur à courant continu
Se non conosci la L293D Shield per controllare un motore DC (inversione del senso di rotazione del motore, variazione di velocità) in modo sicuro con un arduino controlla questo tutorial Arduino.
Tutorial che utilizza la Shield L293D per controllare un motore DC

Alimentazione a commutazione (DC)

L’alimentazione a commutazione fornisce la tensione e la potenza necessarie per far funzionare il motore in modo ottimale. Il motore DC che ho smontato da una stampante HP supporta fino a 24V DC, ma riesce a funzionare a vuoto (senza carico), con una batteria da 9V.

Se il motore che stai usando supporta anche una tensione abbastanza bassa, puoi sperimentare i tuoi setup con una semplice alimentazione a batteria da 9V. Quando tutti i tuoi test sono completati, puoi finalizzare il tuo setup con un alimentatore switching che fornisce l’energia elettrica necessaria per il motore DC.

L’alimentatore DC qui sotto ha due terminali di alimentazione etichettati L e N per alimentare la scatola con una tensione di rete di 230V in corrente alternata (AC). Il segnale DC è sui terminali V+ e V-, il valore della tensione è regolabile su un range che dipende da ogni alimentatore switching.

Simbolo elettrico di un alimentatore a commutazione per fornire DC a un motore DC'une alimentation à découpage pour alimenter en courant continu un moteur à courant continu
La regolazione del valore della tensione DC in uscita si fa con la manopola ADJ sulla destra. Usando un voltmetro calibrato a VDC, mettendolo all’uscita dell’alimentazione DC V+ V- si potrà impostare la tensione desiderata.

Qual è il segnale PWM generato da Arduino?

Il segnale Logic o TOR

L’Arduino è in grado di emettere un segnale All or Nothing (TOR) o Logic, cioè o:
– Alto e in questo il segnale emesso vale 5V o 3,3V all’uscita del terminale.
– Basso e in questo il segnale emesso vale 0V all’uscita del terminale.
Il segnale Logic o All or Nothing può quindi assumere solo 2 valori possibili (Alto o Basso). Come uscita con questo segnale possiamo attivare l’uscita (HIGH) o disattivarla (LOW).
Questa è una logica binaria composta da due valori, corrisponde a un bit (2 valori = 21).
Segnale di uscita di Arduino On/Off (TOR)
Il segnale PWM è anche conosciuto come PWM o Pulse Width Modulation. Il PWM è usato negli inverter per le macchine asincrone per ottenere una variazione di velocità.

PWM di Arduino

Le informazioni PWM possono essere generate da alcune uscite di Arduino (vedere la tabella delle uscite PWM di Arduino).
Al contrario del segnale logico, il segnale PWM di Arduino è codificato su 8 bit, quindi offre 256 valori possibili 28=256 valori da 0 a 255.

PWM e il duty cycle

Per differenziare le 256 combinazioni, non giocheremo sui livelli di tensione (HIGH o LOW) ma sul ciclo di cambiamento dei valori HIGH e LOW.
Così, a seconda del tempo o l’informazione LOW è inviato e il tempo durante il quale HIGH è emixed durante lo stesso periodo, otterremo diverse combinazioni.
L’informazione trasportata dal segnale PWM è fatto su una frequenza di circa 500 HZ che è un periodo di 2 ms.
– Per capire, guardate le animazioni qui sotto che presentano diversi duty cycle o diversi valori di PWM e la conseguenza per un led collegato in uscita.
– Per un duty cycle del 100% il segnale è sempre attivo (HIGH), vale a dire che se colleghiamo un led su questa uscita, sarà sempre acceso. Il valore corrispondente è PWM = 255.
Segnale PWM pari a 255 emesso dalla scheda Arduino e che alimenta un LED, duty cycle 100%
– Per un duty cycle del 90% il segnale alterna BASSO per il 10% del tempo e ALTO per il restante 90% del tempo, se colleghiamo un LED su questa uscita, sarà acceso acceso per il 90% del tempo e spento per il 10% del tempo. Il valore corrispondente è PWM ≈ 230.
Segnale PWM pari a 230 emesso dalla scheda Arduino e che alimenta un LED, duty cycle del 90%
– Per il duty cycle del 90% il segnale alterna BASSO per il 10% del tempo e ALTO per il restante 90% del tempo, se colleghiamo un LED su questa uscita, sarà acceso per il 50% del tempo e spento per il 50% del tempo. Il valore corrispondente è PWM = 127.

Segnale PWM pari a 128 emesso dalla scheda Arduino e che alimenta un LED, duty cycle 50%
– Per un duty cycle del 10% il segnale alterna BASSO per il 90% del tempo e ALTO il restante 10% del tempo, se colleghiamo un LED su questa uscita, sarà acceso acceso per il 10% del tempo e spento per il 90% del tempo. Il valore corrispondente è PWM ≈ 25.
Segnale PWM pari a 25 immesso dalla scheda Arduino e che alimenta un LED, duty cycle 10%
– Per un duty cycle di 0% il segnale è sempre inattivo (LOW), se colleghiamo un LED a questa uscita sarà sempre spento. Il valore corrispondente è PWM = 0.
Segnale PWM uguale a 0 emesso dalla scheda Arduino e che alimenta un LED, duty cycle 0%
Se vi state ancora chiedendo a cosa serve il PWM, date un’occhiata all’articolo dedicato al segnale PWM e alla sua applicazione nei gruppi elettronici.

Come collegare l’arduino e lo Shield L293D?

Mappatura dei pin della schermatura L293D

Mappatura dei terminali di connessione della schermatura L293D:
– VIN GND Alimentazione logica del circuito L293D fino a 24V.
– VCC GND Alimentazione del motore DC da 3.5V a 24V.
Motore DC #1:
– A+ A- Alimentazione al motore DC #1.
– IN1 IN2 Controlla il senso di rotazione o la frenatura del motore #1.
Motore DC #2:
– B+ B- Alimentazione al motore DC #2.
– IN3 IN4 Controlla il senso di rotazione o la frenatura del motore #2.
Shield L293D schema elettrico del motore

Shield L293D PWM pins

Prima di tutto per capire come possiamo variare la velocità di un motore DC con Ardunino, daremo un’occhiata più da vicino alla L293D Shield e identificheremo i pin che ricevono le informazioni sulla velocità.
Sulla scheda L293D Shield, i terminali di ingresso marcati EN1 e EN2 permettono rispettivamente di ricevere le informazioni sulla velocità da Arduino. Questo segnale è in forma PWM e deve essere generato dalla scheda Arduino.
identificazione degli ingressi EN1 e EN2 per la variazione di velocità PWM e degli shunt da rimuovere per permettere la modifica della velocità

Jumper sui pin PWM

Su una L293D Shield originale sono presenti su EN1 e EN2 due jumper (Shunt o ponticelli) che permettono di cortocircuitare gli ingressi per disabilitare la variazione di velocità.
Arduino jumper, shunt jumper o ponticelli
Per abilitare la variazione di velocità sul motore #1, dobbiamo quindi rimuovere il jumper presente su EN1 e inviare un primo segnale PWM a EN1.
Rimuovere il ponticello EN1 dalla L293D Shield per abilitare la variazione di velocità del motore
Il pin EN1 sulla L293D è quello più vicino al marcatore EN1 (vedi foto sopra), il secondo è collegato direttamente al contatto Vcc.Quindi mettendo il ponticello su EN1 shuntiamo Vcc e EN1, la velocità massima viene inviata al motore, senza alcuna possibile variazione o regolazione della velocità del motore.
Per permettere la gestione della velocità sul motore #2, dobbiamo fare lo stesso e togliere lo shunt nero presente su EN2 e inviare un secondo segnale PWM su EN2.

Pin di Arduino per il segnale PWM

I segnali PWM dovranno essere generati da Arduino usando uno dei pin o terminali marcati PWM e assegnandogli la funzione Output.

Tipo o modello di Arduino Pin di PWM disponibili
Uno, Pro Mini, Nano 3, 5, 6, 9, 10 e 11
Leonardo 3, 5, 6, 9, 10, 11 e 13
Due da 2 a 13
Zero da 2 a 13
Mega da 2 a 13 e da 44 a 46td

PWM pin disponibili sull'arduino MEGA'arduino MEGA
Sto usando per questo tutorial un Arduino Mega, e assegnerò il pin #10 come emettitore del segnale PWM sulla L293D Shield.

Schema di cablaggio Arduino Shield L293D Motor

Per controllare un singolo motore in entrambi i sensi di rotazione e per variare la sua velocità è necessario seguire lo schema di cablaggio sottostante.
Schema di collegamento della Shield L293D con arduino e motore DC'arduino et le moteur à courant continu
Schema elettrico:
Per aiutarvi a collegare il vostro hardware (Alim-L293D-Arduino-motore), potete anche controllare lo schema elettrico qui sotto.

Schéma électrique Shield L293D au moteur et à l'ArduinoShield L293D schema di cablaggio al motore e Arduino

L’alimentatore switch-mode fornisce la tensione necessaria per il funzionamento ottimale del motore DC.
Per facilitare il collegamento delle vostre apparecchiature, rispettate un codice colore dei conduttori mettendo in rosso i potenziali positivi (+) e in nero le masse o potenziali negativi (-).

Collegamento del potenziometro

Per modificare manualmente la velocità del motore DC, uso un vecchio potenziometro lineare rotativo (120Ω nell’esempio), potete trovare in rete kit di potenziometri più pratici.
Utilizzare un potenziometro lineare rotativo per variare un valore analogico e per la variazione di velocità del motore'un potentiomètre linéaire rotatif pour faire varier une valeur analogique et pour la variation de vitesse du moteur
Il potenziometro ha 3 terminali, li collego ai pin GND, 5V e A0 di Arduino. Il potenziometro è solo una resistenza variabile con una manopola rotante. A seconda della posizione della manopola o del cursore, il valore ohmico del potenziometro cambia dal suo valore minimo al suo valore massimo. Per un potenziometro da 120Ω, la resistenza varia da 0Ω a 120Ω.
Schema di collegamento dell’insieme con il potenziometro:
collegare un potenziometro all'arduino per variare la velocità del motore CC'un potentiomètre sur l'arduino pour faire varier la vitesse du moteur à courant continu
Schema elettrico con il potenziometro:

Shield L293D schema di cablaggio al motore e Arduino con potenziometro'Arduino avec un potentiomètre

Tuning con joystick a doppio asse:
Per variare la velocità, è possibile utilizzare un controllo via joystick, una lettura analogica della posizione del joystick invierà il comando di velocità del motore (vedi programma associato).

Variazione della velocità del motore a corrente continua con arduino e doppio joystick.asse
Montaggio realizzato con alcuni elementi del progetto Super starter kit Uno R3 | Elegoo

Programmazione Arduino per variazione di velocità:

Al fine di scrivere per programmare Arduino, userò Arduino IDE, l’applicazione per scrivere e scaricare programmi nel vostro arduino o scheda compatibile.
Troverete una lista di programmi per fare la variazione di velocità ma secondo una logica diversa:
– Accelerazione e decelerazione automatica del motore.
– Variazione della velocità del motore da un potenziometro.
– Variare la velocità di un motore con due pulsanti uno per accelerare, l’altro per rallentare il motore.

Accelerazione e decelerazione automatica del motore

Con questo programma, il motore DC accelera e decelera automaticamente senza alcuna manipolazione esterna.

int Motor_sens1=4; // Pin 4 Arduino al pin A+ della L293D
int Motor_sens2=5; // Pin 5 Arduino al pin A- della L293D
int motor1_PWM = 10; // Pin 10 Arduino PWM a EN1 della L293D
int PWM=0; // PWM immagine variabile della velocità
void setup() {
Serial.begin(9600); // Aprire la porta seriale e impostare la velocità di comunicazione a 9600 bauds
pinMode(motor1_PWM, OUTPUT); // Pin 10 Arduino in uscita PWM
pinMode(Motor_sens1, OUTPUT); // Pin 4 Arduino in uscita digitale
pinMode(Motor_sens2, OUTPUT); // Pin 5 Arduino in uscita digitale
delay( 1000 ); // Aspetta 1 secondo prima di lanciare la funzione di accelerazione
Acceleration(); // Eseguire Accelerazione()
}
void loop() {
}
// Il tempo di accelerazione è impostato con il cambiamento di ritardo
void Accelerazione(){
for (PWM = 0; PWM // Loop per aumentare PWM da 0 a 255
delay( 10 ); // Attendere 10ms prima del prossimo incremento PWM
digitalWrite(Motor_sens1,HIGH); // Abilitare pin A+ di L293D
digitalWrite(Motor_sens2,LOW); // Disabilitare pin A- di L293
analogWrite(motor1_PWM,PWM); // Inviare segnale PWM a uscita analogica 10
Serial.print(“Valore PWM: “); // Visualizza sull’editor seriale il testo
Serial.println(PWM); // Visualizza sull’editor seriale il valore PWM
}
delay( 3000 ); // Aspetta 3 secondi
Decelerazione();
}
// Il tempo di decelerazione è impostato con il cambiamento di ritardo
void Deceleration(){
for (PWM = 255; PWM >= 0; –PWM){// Loop per dminute PWM da 255 a 0
delay( 10 ); // Attendere 10ms prima del prossimo decremento PWM
digitalWrite(Motor_sens1,HIGH); // Abilita L293D pin A+
digitalWrite(Motor_sens2,LOW); // Disabilita L293D pin A-
analogWrite(motor1_PWM,PWM); // Invia segnale PWM a uscita analogica 10
Serial.print(“Valore PWM: “); // Visualizza sull’editor seriale il testo
Serial.println(PWM); // Visualizza sull’editor seriale il valore PWM
}
// Arresto del motore
digitalWrite(Motor_sens1,LOW); // Disabilita il pin A+ della L293D
digitalWrite(Motor_sens2,LOW); // Disabilita il pin A- della L293D
delay( 3000); // Attendere 3 secondi
Accelerazione(); // Riprendiamo l’accelerazione del motore
}

Il programma precedente genererà la variazione della velocità del motore DC secondo la logica presentata nel seguente grafico:
Variazione grafica della velocità del motore rispetto al tempo
Per cambiare la rampa di accelerazione o di decelerazione, dobbiamo cambiare i tempi di ritardo (10 ms) inseriti nei cicli for. Aumentando il valore di questo tempo, il motore DC partirà più dolcemente e raggiungerà la sua velocità massima meno rapidamente.
Per visualizzare il monitor seriale sul software Arduino IDE, è necessario cliccare sul menu Strumenti e poi su Serial Monitor oppure premendo la combinazione di tasti Ctrl + Shift + M.

Programma di velocità del motore DC variabile sotto Arduino IDE
Arduino IDE
Visione del monitor seriale di Arduino IDE per la variazione di velocità di un motore DC'un moteur DC
Monitoraggio seriale con software Arduino IDE

Variare la velocità di un motore con un potenziometro

Info: Per far funzionare questo programma, è necessario fare riferimento allo schema di cablaggio di Arduino con potenziometro.

int Motor_sens1=4; // Pin 4 Arduino al pin A+ della L293D
int Motor_sens2=5; // Pin 5 Arduino al pin A- della L293D
int Potentiometer = A0; // Pin A0 Arduino al pin variabile del potenziometro
int PotValue=0; // Potenziometro variabile
int PWM; // Immagine velocità variabile PWM
int Motor1_PWM = 10; // Pin 10 Arduino PWM a EN1 di L293D
// Codice di setup eseguito una volta
void setup() {
Serial.begin(9600); // Aprire la porta seriale e impostare la velocità di comunicazione a 9600 bauds
pinMode(motor1_PWM, OUTPUT); // Pin 10 Arduino in uscita PWM
pinMode(Motor_sens1, OUTPUT); // Pin 4 Arduino in uscita digitale
pinMode(Motor_sens2, OUTPUT); // Pin 5 Arduino all’uscita digitale
}
// Programma loop
void loop() {
PotValue=analogRead(Potentiometer); // Leggi il valore analogico all’uscita del potenziometro
PWM=map(PotValue,0,1020,0,255); // Associa il valore del potenziometro al segnale PWM
analogWrite(motor1_PWM,PWM); // Invio del segnale PWM all’uscita analogica 10
// Condizione Se la velocità è maggiore di zero allora il motore è ruotato
if(PWM>0){
digitalWrite(Motor_sens1,HIGH); // Abilita il pin A+ della L293D
digitalWrite(Motor_sens2,LOW); // Disabilita il pin A- della L293D
}
else{// Altrimenti fermiamo il motore
digitalWrite(Motor_sens1,LOW); // Disabilita il pin A+ della L293D
digitalWrite(Motor_sens2,LOW); // Disabilita il pin A- della L293D
}
Serial.print(“Valore PWM: “); // Visualizza sull’editor seriale il testo
Serial.println(PWM); // Visualizza sull’editor seriale il valore PWM
}

La linea PWM=map(PotValue,0,1020,0,255); utilizza la funzione map per convertire, secondo un prodotto incrociato, i valori analogici del potenziometro in un segnale PWM che va da 0 a 255.
Per informazione, il valore 1020 è specifico del mio potenziometro.
Per conoscere il valore massimo del vostro potenziometro da annotare nel vostro programma, è necessario leggere l’ingresso analogico A0 del potenziometro quando questo è regolato con la resistenza massima:

void setup() {
Serial.begin(9600); // Apertura della porta seriale per utilizzare il monitor seriale
}
void loop() {
Serial.print(“valore del potenziometro = “); // Visualizza il testo nel monitor seriale
Serial.println(analogRead(A0)); // Valore letto dal potenziometro
}

Utilizzando il monitor seriale, dovrai solo leggere il valore analogico visualizzato.

Programma Arduino per eseguire la lettura di un ingresso analogico A0 e visualizzare sul monitor seriale'une entrée analogique A0 et l'affichage sur le moniteur série
Programma Arduino IDE per lettura analogica su ingresso A0

Visualizzazione sul monitor seriale del valore analogico A0 del potenziometro
Visualizzazione del monitor seriale su Arduino IDE

Accelerazione e decelerazione con un joystick

Usando un Dual-asse XY, è possibile controllare la velocità di funzionamento del motore in entrambe le direzioni.

Utilizzare un joystick arduino per controllare la velocità di un motore DC'un joystick arduino pour commander la vitesse de rotation d'un moteur à courant continu
Joystick per controllare la velocità operativa del motore DC

Per fare questo, Uso solo un asse del joystick, per esempio l’asse orizzontale (asse X), quando il joystick è verso destra, il motore girerà nella direzione normale e la velocità dipenderà dall’inclinazione del joystick. er fermare il motore, rilasciate il joystick ed esso ritornerà alla sua posizione iniziale. Infine, per invertire il senso di rotazione del motore, punto il joystick a sinistra e la sua inclinazione varierà la velocità del motore DC.

lettura analogica diarduino sul joystick a due assi
Precisioni sulla lettura analogica del joystick
int Motor_sens1=4; // Pin 4 Arduino al pin A+ della L293D
int Motor_sens2=5; // Pin 5 Arduino al pin A- della L293D
int Potenziometro = A0; // Pin A0 Arduino al pin X del Joystick
int PotValue=0; // Valore del Joystick
int PWM; // Immagine PWM a velocità variabile
int motor1_PWM = 10; // Pin 10 Arduino PWM a EN1 di L293D
// Codice di setup eseguito una volta
void setup() {
Serial.begin(9600); // Aprire la porta seriale e impostare la velocità di comunicazione a 9600 bauds
pinMode(motor1_PWM, OUTPUT); // Pin 10 Arduino in uscita PWM
pinMode(Motor_sens1, OUTPUT); // Pin 4 Arduino in uscita digitale
pinMode(Motor_sens2, OUTPUT); // Pin 5 Arduino in uscita digitale
}
// Programma loop
void loop() {
PotValue=analogRead(Potentiometer); // Leggere il valore analogico dall’uscita del Joystick
if(PotValue>498) // Joystick a destra (direzione normale)
{
PWM=map(PotValue,498,1023,0,255); // Associare il valore x+ del Joystick al segnale PWM
digitalWrite(Motor_sens1,HIGH); // Abilita il pin A+ della L293D
digitalWrite(Motor_sens2,LOW); // Disabilita il pin A- della L293D
analogWrite(motor1_PWM,PWM); // Invia il segnale PWM all’uscita analogica 10
Serial.println(“Direzione normale del motore”); // Visualizza sul monitor seriale il testo
Serial.println(“Valore PWM: “); // Visualizza sul monitor seriale il testo
Serial.println(PWM); // Visualizza sul moninatore seriale il valore PWM
}
else if(PotValue// Joystick a sinistra (direzione inversa)
{
PWM=map(PotValue,494,0,0,255); //Associa il valore x del Joystick al segnale PWM
digitalWrite(Motor_sens1,LOW); // Disabilita il pin A+ della L293D
digitalWrite(Motor_sens2,HIGH); // Abilita il pin A- della L293D
analogWrite(motor1_PWM,PWM); // Invia il segnale PWM all’uscita analogica 10
Serial.println(“Motor reverse direction”); // Visualizza sull’editor seriale il testo
Serial.println(“Valore PWM: “); // Visualizza sull’editor seriale il testo
Serial.println(PWM); // Visualizza sull’editor seriale il valore PWM
}
else // Joystick nel centro fermare il motore
{
digitalWrite(Motor_sens1,LOW); // Disabilita il pin A+ della L293D
digitalWrite(Motor_sens2,LOW); // Disabilita il pin A- della L293D
analogWrite(motor1_PWM,0); // Invia il segnale PWM all’uscita analogica 10
Serial.println(“Motor stopped”); // Visualizza sul moninatore seriale il testo
}
}

Accelerazione e decelerazione con due pulsanti

Questo scenario utilizza due pulsanti collegati agli ingressi digitali 11 e 12.
– Appena si preme il primo pulsante la velocità PWM viene aumentata di 5.uando si preme il secondo pulsante, la velocità PWM viene diminuita di 5.
Programma corrispondente:

int command_plus=11; // Pulsante più
int command_minus=12; // Pulsante destro
int Motor_sens1 = 4; // Pin 4 Arduino al pin A+ della L293D
int Motor_sens2 = 5; // Pin 5 Arduino al pin A- della L293D
int motor1_PWM = 10; // Pin 10 Arduino PWM a EN1 della L293D
int speed_PWM=0; // PWM è assegnato 0
boolean etat_bp_plus,etat_bp_minus; // Dichiarazione delle variabili logiche meno e più
boolean mem_g,mem_d; // Dichiarazione delle memorie più e meno
void setup()
{
pinMode(command_plus, INPUT_PULLUP); // Impostiamo il pin 11 come ingresso digitale
pinMode(command_minus, INPUT_PULLUP); // Pin 12 è impostato come ingresso digitale
pinMode(Motor_sens1, OUTPUT); // Pin 4 Arduino come uscita digitale
pinMode(Motor_sens2, OUTPUT); // Pin 5 Arduino come uscita digitale
Serial.begin(9600); //inizializzare il collegamento seriale a 9600 bauds
}
void loop()
{
etat_bp_plus=!digitalRead(command_plus); // Invertire la lettura sull’ingresso BP plus
etat_bp_minus=!digitalRead(command_minus); // Invertire la lettura sull’ingresso BP minus
if(etat_bp_plus!=mem_plus) // Cambia lo stato del pulsante plus (fronte di salita o di discesa)
{
if(etat_bp_plus && !etat_minus) // Premi BP più ma non meno
{
Accelerate(); // Esegui la funzione di accelerazione
}
}
mem_plus=etat_bp_plus; // Salva il nuovo stato del pulsante più
if(etat_bp_minus!=mem_minus) // Cambia lo stato del pulsante destro (fronte di salita o discesa)
{
if(etat_bp_minus && !etat_bp_plus) // Premi BP Minus ma non plus
{
Decelerate(); // Esegui la funzione di decelerazione
}
}
mem_moins=etat_bp_minus; // Memorizza il nuovo stato del pulsante destro
delay(100); // Aspetta 100ms
};
void Accelerer() {
if(speed_PWMspeed_PWM=speed_PWM+5;
}
analogWrite(motor1_PWM,speed_PWM); //Invia il segnale PWM all’uscita analogica 10
digitalWrite(Motor_sens1, HIGH); // Abilita il pin A+ della L293D
digitalWrite(Motor_sens2, LOW); // Disabilita il pin A- della L293D
Serial.print(“Stiamo accelerando il motore | PWM = “);
Serial.println(speed_PWM);
}
void Decelerer()
{
if(speed_PWM>=5)
{
speed_PWM=speed_PWM-5;
}
analogWrite(motor1_PWM,speed_PWM); // Invia il segnale PWM all’uscita analogica 10
digitalWrite(Motor_sens1, HIGH); // Abilita L293D pin A+
digitalWrite(Motor_sens2, LOW); // Disabilita L293D pin A-
Serial.print(“Rallentiamo il motore | PWM = “);
Serial.println(speed_PWM);
}

azionamento in video:

Trova il principio dell’azionamento del motore DC in video:

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *