Modifica un controller di velocità per motori PWM DC da 20A con un Arduino.
In questo tutorial, impareremo come modificare un controllore di velocità per motori PWM DC da 20A per funzionare senza problemi con un Arduino. Questa modifica consente un controllo di velocità preciso di un motore utilizzando sia un potenziometro che comandi diretti dall'Arduino. Il risultato è un sistema di controllo del motore più versatile che può essere integrato in vari progetti.
Per questo progetto, collegheremo il controller PWM all'Arduino e utilizzeremo il codice per gestire la velocità del motore in base all'input dell'utente. Questa configurazione può essere vantaggiosa in applicazioni che richiedono il controllo della velocità variabile, come la robotica o i sistemi automatizzati. Per ulteriore chiarezza, puoi fare riferimento al video che accompagna questo tutorial (nel video a 00:00).
Hardware Spiegato
I componenti principali di questo progetto includono la scheda Arduino, il controller di velocità del motore PWM DC da 20A e un potenziometro. L'Arduino funge da cervello del sistema, inviando segnali PWM al controller del motore per regolare la velocità del motore. Il controller di velocità del motore utilizza a sua volta un IC timer 555 per generare segnali PWM, che controllano il gate di un MOSFET che regola l'alimentazione del motore.
Il potenziometro funge da dispositivo di input, consentendo agli utenti di impostare manualmente la velocità desiderata. Ruotando il potenziometro, la resistenza cambia, inviando una tensione corrispondente all'Arduino. L'Arduino legge questa tensione e regola di conseguenza il segnale PWM inviato al controllore del motore.
Dettagli della scheda tecnica
| Produttore | Sconosciuto |
|---|---|
| Numero di parte | Controllore di velocità per motori a corrente continua PWM da 20A |
| Tensione logica/IO | 5 V |
| Tensione di alimentazione | 10-60 V |
| Corrente di uscita (per canale) | 20 A |
| Corrente di picco (per canale) | 40 A |
| Indicazioni sulla frequenza PWM | Tipicamente 1 kHz |
| Soglie logiche di input | 0,2 V (basso), 2,0 V (alto) |
| Caduta di tensione / RDS(on)/ saturazione | 0,1 V |
| Limiti termici | Fino a 85°C |
| Pacchetto | PCB standard |
| Note / varianti | Variati modelli disponibili |
- Assicurati di avere un adeguato dissipatore di calore per applicazioni ad alta corrente.
- Controlla il cablaggio per la corretta polarità prima di alimentare il sistema.
- Utilizzare condensatori di disaccoppiamento tra i terminali di alimentazione.
- Mantenere la frequenza PWM intorno a 1 kHz per prestazioni ottimali.
- Fai attenzione ai limiti di tensione di ingresso (10-60 V).
Istruzioni di cablaggio
Per collegare il controller di velocità del motore PWM DC da 20A all'Arduino, inizia collegando l'alimentazione. Il terminale positivo dell'alimentazione deve essere collegato all'ingresso V+ del controller del motore, mentre il terminale negativo si collega a terra (GND) del controller. Successivamente, collega il motore ai terminali di uscita del controller, assicurandoti di avere la polarità corretta per la rotazione desiderata.
Per il segnale PWM, identifica il pin di uscita PWM sul controller, che collegheremo al pin PWM designato sull'Arduino (in questo caso, il pin5). Inoltre, collega la massa dell'Arduino alla massa del controllore del motore per garantire un riferimento comune. Infine, se si utilizza un potenziometro, collega un'estremità al pin da 5V dell'Arduino e il pin centrale a un pin analogico (comeA0), e l'ultimo pin a terra.
Esempi di codice e guida passo passo
Il codice inizia definendo il pin di uscita PWM e il pin di controllo per il potenziometro.setup()la funzione inizializza il pin PWM come uscita e avvia la comunicazione seriale per il debug.
#define pwmPin 5
#define controlPin A0
void setup() {
pinMode(pwmPin, OUTPUT);
Serial.begin(9600);
}
Nellaloop()Funzione, leggiamo il valore dal potenziometro e lo mappiamo a un intervallo PWM adatto per il controller del motore. Questo valore viene poi scritto sul pin PWM, che controlla la velocità del motore.
void loop() {
int potValue = analogRead(controlPin);
int pwm = map(potValue, 0, 1023, 0, 255);
analogWrite(pwmPin, pwm);
Serial.print("PWM:");
Serial.println(pwm);
delay(500);
}
Infine, sono definite funzioni per convertire il valore PWM in percentuale, consentendo una comprensione più semplice della velocità del motore in base all'immissione dell'utente. Il codice completo è caricato sotto l'articolo (nel video a 00:00).
Dimostrazione / Cosa Aspettarsi
Una volta che tutto è collegato e il codice è caricato, puoi aspettarti che il motore risponda alla posizione del potenziometro. Ruotare il potenziometro aumenterà o diminuirà la velocità del motore in base al segnale PWM inviato dall'Arduino. Assicurati che l'alimentazione sia all'interno dell'intervallo di tensione richiesto e che il motore sia in grado di gestire la tensione applicata.
Le trappole comuni includono il cablaggio errato, che potrebbe portare a una rotazione del motore invertita o al mancato avvio. Controlla sempre due volte le connessioni e assicurati che i punti di massa dell'Arduino e del controller del motore siano collegati insieme (nel video a :30).
Timestamp video
- 00:00 Inizio
- 00:40 Introduzione
- 04:07 Preparazione per il cablaggio (modificandolo)
- 06:55 Spiegazione del cablaggio
- 08:40 Codice spiegato
- 13:15 Dimostrazione
Immagini
/*
* Modify 80NF70 PWM 20A Module to control with Arduino
* Modify the "DC 10-60V 20A Motor Speed Control Regulator PWM Motor Speed Controller Switch"
*
*
* Written by Ahmad Shamshiri
* on Saturday, July 27, 2019 at 18:23
* in Ajax, Ontario, Canada
* www.Robojax.com
* Watch the video instruction: https://youtu.be/ipFxYQkB5uw
* See the module on eBay. Get this module from eBay:
https://www.ebay.com/sch/i.html?&_nkw=20A+DC10-60V+PWM&_sacat=0
* or search for "DC 10-60V 20A Motor Speed Control Regulator PWM Motor Speed Controller"
* Watch full review of this module: https://youtu.be/kgs_FILyppk
*/
#define pwmPin 5
#define controlPin A0
void setup() {
pinMode(pwmPin,OUTPUT);
Serial.begin(9600);
}
void loop() {
int potValue = analogRead(controlPin);
int pwm =map(potValue, 0,1023, 0, 255);
//pwm = toPWM(0);
analogWrite(pwmPin,pwm);
Serial.print("PWM:");
Serial.print(pwm);
Serial.print(" it is:");
Serial.print(pwmToPercent(pwm));
Serial.println("%");
delay(500);
}
/*
* @brief converts % value from 0 to 100% to 0-255
* @param v is integer value representing % from 0-100
* @return will return value from 0 to 255
* Written by Ahmad Shamshiri for robojax.com
* on July 30, 2019 in Ajax, Ontario, Canada
*/
int toPWM(int v){
return map(v, 0,100,0,255);
}//
/*
* @brief converts Arduino PWM value which is 0 to 255 to 0-100%
* @param p is integer value representing from 0-255
* @return will return value from 0 to 255
* Written by Ahmad Shamshiri for robojax.com
* on July 30, 2019 in Ajax, Ontario, Canada
*/
int pwmToPercent(int p)
{
return map(p, 0,255,0,100);
}Cose di cui potresti avere bisogno
-
AliExpressAcquista il Controller di Velocità del Motore PWM DC 10-60V 20A da AliExpresss.click.aliexpress.com
-
Banggood
Risorse e riferimenti
-
Interno
File📁
Nessun file disponibile.
