Controllore di velocità del motore PWM XY-1250 10-50A/60A 3000W utilizzando Arduino
In questo tutorial, ti mostreremo come prendere un comune controller di velocità per motori PWM XY-1250 (valutato per 10-50A/60A fino a 3000W) e modificarlo in modo da poter controllare la sua velocità con un Arduino invece del suo controllo manuale incorporato. Questa è una richiesta popolare da parte degli hobbisti che vogliono integrare un controller di motore ad alta potenza nei propri progetti, come costruire un longboard elettrico personalizzato, un controllo della velocità di un mandrino CNC, un sistema di trasporto robotico o un sistema di ventilazione automatizzato. Sostituendo il potenziometro manuale con un segnale digitale, ottieni un controllo preciso e programmabile sulla velocità del tuo motore, aprendo un mondo di possibilità per l'automazione e il funzionamento da remoto.
Ecco alcuni progetti pratici che puoi realizzare con questa configurazione:
- Costruire un longboard elettrico personalizzato o un go-kart con ramp-up di velocità programmabile.
- Creare un controller della velocità del mandrino di una macchina CNC che può essere regolato tramite G-code.
- Costruire una ventola automatizzata per serre che regola la velocità in base ai sensori di temperatura.
- Realizzare un robot radiocomandato con motori ad alta coppia.
- Sviluppare un sistema di nastro trasportatore intelligente per un laboratorio o una piccola fabbrica.
Componenti hardware
- Modulo di controllo della velocità del motore PWM XY-1250 (10-50A/60A, 3000W)
- Arduino Uno (o qualsiasi scheda compatibile)
- Motore DC (per test)
- Alimentatore DC (12V-36V raccomandato)
- Potenziometro (10kΩ) - per opzione di controllo manuale
- Fili di collegamento
- Saldatore e filo (per modificare il PCB)
Come funziona l'XY-1250
L'XY-1250 utilizza un modulo temporizzatore 555 (etichettato come "U3" sulla scheda) per generare un segnale PWM. Questo segnale controlla il gate di quattro MOSFET che attivano il circuito del motore ad alta potenza. Il ciclo di lavoro, che determina la velocità del motore, è normalmente impostato dal potenziometro integrato collegato al pin 3 del temporizzatore 555. Per controllare questo con un Arduino, dobbiamo disconnettere l'uscita del 555 dai gate dei MOSFET e immettere invece il nostro segnale PWM.
Questa modifica è necessaria perché l'Arduino non può pilotare direttamente le porte MOSFET ad alta corrente. Tagliando le tracce PCB tra il timer 555 e i MOSFET, possiamo iniettare in sicurezza il nostro segnale PWM a bassa tensione dall'Arduino, ottenendo il controllo digitale completo sulla velocità del motore. (nel video al 01:42)
Modifica la scheda XY-1250
Prima di poter collegare l'Arduino, dobbiamo effettuare due tagli sulla PCB per isolare l'uscita del timer 555 dai gate del MOSFET. Ecco come fare:
- Trova il chip timer 555 (U3) sulla scheda. Ha un piccolo punto o una linea che indica il pin 1.
- Identificare le tracce PCB provenienti dal pin 3 (l'uscita) che portano ai diodi collegati ai gate dei MOSFET.
- Utilizzando un coltello affilato o uno strumento rotativo con un disco da taglio, tagliare con cautela queste tracce in due punti, uno per ciascun percorso di uscita.
- Dopo aver tagliato, usa un tester di continuità per verificare che il taglio sia completo. Non dovresti sentire beep tra il pin 3 del 555 e l'area del gate del MOSFET.
Questa modifica è critica: impedisce al segnale del timer 555 di interferire con il segnale PWM del nostro Arduino. (nel video alle 07:02)
Guida al cablaggio
Il cablaggio per questo progetto prevede di collegare l'Arduino alla scheda XY-1250 modificata. Ecco il diagramma di collegamento:
- Potenza per Arduino:L'XY-1250 ha un regolatore di tensione che fornisce circa 8,5V. Collega questo output (il filo rosso tra i due condensatori) al pin VIN dell'Arduino. Questo alimenta l'Arduino direttamente dall'alimentazione del motore.Importante: non collegare questo al pin 5V, brucerà l'Arduino.
- Collegamento a terra:Collegare il filo di massa dal XY-1250 a un qualsiasi pin GND sull'Arduino.
- Segnali PWM:Collegare il pin 5 di Arduino al primo segno di taglio (dove si trovava l'uscita del 555) e il pin 6 di Arduino al secondo segno di taglio.
- Potenziometro (opzionale):Se desideri il controllo manuale, collega un potenziometro da 10kΩ al pin A0 dell'Arduino, con gli altri due pin a 5V e GND.
- Motore:Collega il tuo motore DC ai terminali di uscita del modulo XY-1250.
Una volta cablato, l'Arduino sarà alimentato dallo stesso alimentatore del motore e invierà segnali PWM sincronizzati a entrambi i circuiti del gate MOSFET.
Spiegazione del codice
Il codice Arduino è semplice e si concentra sulla generazione dei segnali PWM. Ecco le parti chiave configurabili dall'utente:
#define pwmPin1 5
#define pwmPin2 6
#define controlPin A0
pwmPin1epwmPin2sono i pin dell'Arduino che inviano il segnale PWM ai due circuiti di gate MOSFET. Questi sono definiti come i pin 5 e 6, che sono entrambi pin compatibili con PWM sull'Arduino Uno.controlPinè il pin analogico collegato al potenziometro (A0). Se non vuoi utilizzare un potenziometro, puoi ignorare questo.
Nellaloop()funzione, il codice legge il valore del potenziometro (0-1023), lo mappa a un valore PWM (0-255) e lo invia a entrambi i pin PWM. Ildelay(500)imposta la frequenza di aggiornamento a due volte al secondo - puoi ridurre questo adelay(100)per una risposta più fluida.
Il codice include anche una personalizzazionetoPWM()funzione che converte un valore percentuale (0-100) in un valore PWM (0-255). Questo è utile se si desidera impostare una velocità specifica senza un potenziometro. Ad esempio, chiamandotoPWM(50)restituirebbe 127, che rappresenta un ciclo di lavoro del 50%. Puoi utilizzare questa funzione nel tuo codice per impostare direttamente la velocità del motore.
Test e dimostrazione
Dopo aver caricato il codice e collegato tutto, puoi testare la configurazione. Se stai usando un potenziometro, ruotarlo regolerà gradualmente la velocità del motore dallo 0 al 100%. Il monitor seriale visualizzerà sia il valore analogico grezzo (0-1023) che il valore PWM mappato (0-255).
Se vuoi controllare la velocità in modo programmato, puoi sostituire la lettura del potenziometro con un valore fisso. Ad esempio, impostandoint pwm = toPWM(20);eseguirà il motore al 20% della velocità. Questo è perfetto per le applicazioni in cui si desidera che il motore funzioni a una velocità specifica senza regolazioni manuali. (nel video alle 16:42)
Dimostrazione del Progetto dal Vivo
Nel video, puoi vedere il controller XY-1250 modificato che aziona un piccolo motore DC. La dimostrazione mostra:
- Controllare la velocità del motore con un potenziometro collegato all'Arduino.
- Impostare il motore a una velocità fissa del 20% utilizzando il
toPWM()funzione. - Aumentare la velocità al 50% e poi all'80% per mostrare l'intera gamma di controllo.
Le letture dell'oscilloscopio confermano che entrambi i segnali PWM sono perfettamente sincronizzati, senza differenza di fase tra i due canali. Ciò garantisce che i MOSFET siano alimentati in modo uniforme, prevenendo usura diseguale o surriscaldamento. (nel video al 14:56)
Capitoli
- [00:00] Introduzione e panoramica del progetto
- [01:42] Come funziona il controller PWM XY-1250
- [04:28] Testare il segnale originale con un oscilloscopio
- [07:02] Tagliare le tracce del PCB per isolare il timer 555
- Collegare l'Arduino al modulo modificato
- [12:18] Spiegazione del codice Arduino
- Dimostrare il controllo del motore con un potenziometro
- Controllare la velocità programmaticamente con valori fissi
- [20:32] Riepilogo finale e osservazioni conclusive
Immagini
/*
* Modify XY-1250 12-50V 60A PWM to work with Arduino.
get this code and other resouces http://robojax.com/RTJ162
If you want to control it without a potentiometer, see http://robojax.com/RTJ162
*
* Written by Ahmad Shamshiri
* on Saturday, June 15, 2019 at 16:14
* in Ajax, Ontario, Canada
* www.robojax.com
* Watch the video instruction: https://youtu.be/k13iTmvPtUU
*/
#define pwmPin1 5
#define pwmPin2 6
#define controlPin A0
void setup() {
pinMode(pwmPin1,OUTPUT);
pinMode(pwmPin2,OUTPUT);
Serial.begin(9600);
}
void loop() {
int potValue = analogRead(controlPin);
Serial.print(potValue);
int pwm =map(potValue, 0,1023, 0, 255);
analogWrite(pwmPin1,pwm);
analogWrite(pwmPin2,pwm);
Serial.print(" ");
Serial.println(pwm);
delay(500);
}
/*
* @brief Converts a percentage value from 0 to 100% to 0-255.
* @param v An integer value representing a percentage from 0-100.
* @return A value from 0 to 255.
*/
int toPWM(int v){
return map(v, 0,100,0,255);
}/*
* file: PWM_for_XY1260_module_no_pot
* Modify XY-1250 12-50V 60A PWM to work with Arduino
* This code allows you to control the motor without a potentiometer. See video for demonstration.
* resources page for this project https://robojax.com/RTJ162
Watch the video instruction on youTube: https://youtu.be/ZLZr2AZgmPI
*
* How to use:
* To control speed at 100%
motorControl(100);
delay(3000);//keep it running for 3 seconds
* To control speed at 400%
motorControl(40);
delay(3000);//keep it running for 3 seconds
* To stop motor
motorControl(0); //set zero
delay(3000);//keep it running for 3 seconds
* Written by Ahmad Shamshiri
* on Saturday, January 30, 2021, at 12:49
* in Ajax, Ontario, Canada
* www.Robojax.com
* Watch the video instruction: https://youtu.be/ZLZr2AZgmPI
*/
#define pwmPin1 3
#define pwmPin2 6
bool defaultMotorON = false;// or set to "true" to make the motor start
unsigned int defaultSpeed= 20;//20% set it in % 0=stop, 100=full speed
int toPWM(int);//prototype
void setup() {
pinMode(pwmPin1,OUTPUT);
pinMode(pwmPin2,OUTPUT);
Serial.begin(9600);
Serial.print("Control XY-1260 without pot");
if(defaultMotorON){
analogWrite(pwmPin1,toPWM(defaultSpeed));
analogWrite(pwmPin2,toPWM(defaultSpeed));
}else{
analogWrite(pwmPin1,0);
analogWrite(pwmPin2,0);
}
}
void loop() {
motorControl(100);//set speed to 100%
delay(3000);//keep motor running at 100% for 3 seconds
motorControl(0);//stops motor
delay(4000);//keep motor stopped for 4 seconds
motorControl(45);//set speed to 45%
delay(3000);//keep motor running at 45% for 3 seconds
motorControl(0);//stops motor
delay(4000);//keep motor stopped for 4 seconds
//from 0 to 100% with 50 millisecond delay (increasing speed)
for(int i=0; i<100; i++)
{
motorControl(i);//set speed with value of i from 0 to 100
delay(50);//give motor 50 milliseconds before going to the next value
}//for loop end
motorControl(0);//stops motor
delay(4000);//keep motor stopped for 4 seconds
//from 100% to 10 with 50 millisecond delay (decreasing speed)
for(int i=100; i>0; i--)
{
motorControl(i);//set speed with value of i from 0 to 100
delay(50);//give motor 50 milliseconds before going to the next value
}//for loop end
motorControl(0);//stops motor
delay(4000);//keep motor stopped for 4 seconds
}//loop end
/*
* @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
*/
int toPWM(int v){
return map(v, 0,100,0,255);
}//
/*
* @brief controls the speed of motor with value from 0 to 100%
* @param speed is integer value representing % from 0-100
* @return none
* written January 30, 2021 by Ahmad Shamshiri
* www.robojax.com
*
*/
void motorControl(int speed)
{
int pwm= map(speed, 0,100,0,255);
analogWrite(pwmPin1,pwm);
analogWrite(pwmPin2,pwm);
}Cose di cui potresti avere bisogno
-
Amazon
-
Amazon60A 3000W PWM module on Amazonamzn.to
-
eBay
-
eBay60A 3000W PWM module on eBayebay.us
-
AliExpress60A 100A Motor Speed Controller on AliExpress-1s.click.aliexpress.com
-
AliExpress60A 100A Motor Speed Controller on AliExpress-2s.click.aliexpress.com
-
AliExpress60A 3000W PWM module on AliExpresss.click.aliexpress.com
-
Banggood60A 100A Motor Speed Controller on Banggoodbanggood.com
Risorse e riferimenti
-
EsternoDatasheet per NCE7190A MOSFET (8 pezzi) (PDF)datasheet.lcsc.com
-
Esterno
-
Esterno
File📁
Nessun file disponibile.
