Buongiorno chatgpt mi aiuti a realizzare uno scketch utilizzando una scheda ESP32 Heltec V2, un driver Cytron MDDS10 ed un potenziometro per controllare un motore a CC .
Di seguito ti propongo un esempio di sketch Arduino che, utilizzando una ESP32 Heltec V2, legge un potenziometro e controlla un motore CC tramite il driver (Cytron MDDS10).
In questo esempio il valore letto dal potenziometro determina sia la velocità che la direzione del motore: valori centrali (attorno a metà scala) corrispondono a “stop”, valori superiori attivano la marcia in avanti e valori inferiori la retromarcia.
Nota: assicurati di verificare i collegamenti hardware e di adattare le assegnazioni dei pin (ad es. potPin, motorPwmPin, motorDirPin) alla tua configurazione reale. Sul ESP32 è consigliato utilizzare i canali LEDC per il PWM, poiché la funzione analogWrite() non è supportata nativamente.
#include <Arduino.h>
// --- Definizione dei pin ---
// Pin analogico per il potenziometro (ad esempio, GPIO34, input-only)
const int potPin = 34;
// Pin per il segnale PWM verso il driver del motore (ad es. GPIO14)
const int motorPwmPin = 14;
// Pin per controllare la direzione del motore (ad es. GPIO27)
const int motorDirPin = 27;
// --- Configurazione LEDC per il PWM su ESP32 ---
const int pwmChannel = 0; // Canale PWM LEDC
const int pwmFreq = 5000; // Frequenza PWM in Hz
const int pwmResolution = 8; // Risoluzione in bit (0-255)
void setup() {
Serial.begin(115200);
// Configura il pin del potenziometro come ingresso
pinMode(potPin, INPUT);
// Configura i pin del motore come uscite
pinMode(motorPwmPin, OUTPUT);
pinMode(motorDirPin, OUTPUT);
// Inizializza il canale LEDC per il PWM
ledcSetup(pwmChannel, pwmFreq, pwmResolution);
ledcAttachPin(motorPwmPin, pwmChannel);
}
void loop() {
// Legge il valore analogico del potenziometro (range ~0-4095 per ESP32)
int potValue = analogRead(potPin);
Serial.print("Valore potenziometro: ");
Serial.println(potValue);
// Definizione del punto centrale e della zona morta
const int center = 2048; // Valore centrale (metà scala)
const int deadZone = 100; // Zona morta per evitare fluttuazioni
// Se il valore è vicino al centro, ferma il motore
if (abs(potValue - center) < deadZone) {
ledcWrite(pwmChannel, 0);
} else {
if (potValue > center) {
// Marcia in avanti: settiamo la direzione HIGH
digitalWrite(motorDirPin, HIGH);
// Mappa il valore del potenziometro per ottenere la velocità (0-255)
int speed = map(potValue, center + deadZone, 4095, 0, 255);
speed = constrain(speed, 0, 255);
ledcWrite(pwmChannel, speed);
} else {
// Marcia indietro: settiamo la direzione LOW
digitalWrite(motorDirPin, LOW);
int speed = map(potValue, 0, center - deadZone, 255, 0);
speed = constrain(speed, 0, 255);
ledcWrite(pwmChannel, speed);
}
}
delay(50); // Piccola pausa per stabilità
}
· Setup hardware e PWM:
Vengono configurati i pin per il potenziometro, l’uscita PWM e la direzione. Il PWM viene gestito tramite il canale LEDC dell’ESP32, impostato a 5000 Hz con risoluzione 8 bit (valori da 0 a 255).
· Lettura e mappatura del potenziometro:
Il valore letto dal potenziometro (0-4095) viene confrontato con un valore centrale (2048). Se il valore è entro una “deadZone” di ±100, il motore viene fermato. Altrimenti, se il valore è superiore al centro, il motore gira in avanti; se inferiore, gira indietro. La funzione map() viene usata per tradurre il range del potenziometro in un range di velocità PWM (0-255).
· Controllo del motore:
La direzione viene settata tramite il pin motorDirPin e la velocità tramite il PWM sul canale LEDC.
Questo sketch è un punto di partenza che potrai personalizzare ulteriormente in base alle specifiche del tuo progetto (ad esempio, eventuali modalità di frenata, regolazioni della zona morta, o integrazioni con display se vuoi sfruttare la funzionalità della Heltec ESP32 V2).
Spero che questo esempio ti sia utile per sviluppare il tuo progetto!
Mi aiuti a realizzare uno sketch per due motori CC utilizzando gli stessi componenti.
Di seguito trovi un esempio di sketch per controllare due motori CC (gestiti tramite due driver MDDS10, o due canali dello stesso driver se previsto) utilizzando la stessa ESP32 Heltec V2 e un unico potenziometro. In questo esempio il valore letto dal potenziometro determina, per entrambi i motori, la velocità e la direzione: valori centrali (attorno a 2048) fermeranno i motori, valori superiori faranno ruotare i motori in avanti e valori inferiori in retromarcia.
Nota:
Assicurati che i collegamenti hardware (pin per PWM e direzione) siano conformi al tuo schema. Nell’esempio vengono usati due canali PWM (LEDC) del chip ESP32, rispettivamente sul canale 0 e 1. Se i tuoi driver MDDS10 o il sistema di controllo richiedono altre configurazioni, adatta di conseguenza il codice.
#include <Arduino.h>
// --- Definizione dei pin ---
// Potenziometro: pin analogico (GPIO34, pin di input-only su ESP32)
const int potPin = 34;
// Motor 1: definizione dei pin per PWM e direzione
const int motor1PwmPin = 14; // PWM per motore 1
const int motor1DirPin = 27; // Direzione per motore 1
// Motor 2: definizione dei pin per PWM e direzione
const int motor2PwmPin = 26; // PWM per motore 2
const int motor2DirPin = 25; // Direzione per motore 2
// --- Configurazione LEDC per il PWM (ESP32) ---
const int pwmFreq = 5000; // Frequenza PWM in Hz
const int pwmResolution = 8; // Risoluzione a 8 bit (0-255)
// Canali LEDC
const int pwmChannel1 = 0;
const int pwmChannel2 = 1;
void setup() {
Serial.begin(115200);
// Configura il pin del potenziometro come ingresso
pinMode(potPin, INPUT);
// Configura i pin direzionali dei motori come uscite
pinMode(motor1DirPin, OUTPUT);
pinMode(motor2DirPin, OUTPUT);
// Inizializza il canale LEDC per il PWM del motore 1
ledcSetup(pwmChannel1, pwmFreq, pwmResolution);
ledcAttachPin(motor1PwmPin, pwmChannel1);
// Inizializza il canale LEDC per il PWM del motore 2
ledcSetup(pwmChannel2, pwmFreq, pwmResolution);
ledcAttachPin(motor2PwmPin, pwmChannel2);
}
void loop() {
// Legge il valore analogico dal potenziometro (range tipico 0-4095)
int potValue = analogRead(potPin);
Serial.print("Valore potenziometro: ");
Serial.println(potValue);
// Imposta il valore centrale e una zona morta per evitare fluttuazioni indesiderate
const int center = 2048;
const int deadZone = 100;
// Se il valore è vicino al centro, ferma entrambi i motori
if (abs(potValue - center) < deadZone) {
ledcWrite(pwmChannel1, 0);
ledcWrite(pwmChannel2, 0);
}
// Se il valore è superiore al centro, i motori girano in avanti
else if (potValue > center) {
// Imposta la direzione in avanti per entrambi i motori
digitalWrite(motor1DirPin, HIGH);
digitalWrite(motor2DirPin, HIGH);
// Mappa il valore del potenziometro da [center+deadZone, 4095] a [0, 255]
int speed = map(potValue, center + deadZone, 4095, 0, 255);
speed = constrain(speed, 0, 255);
ledcWrite(pwmChannel1, speed);
ledcWrite(pwmChannel2, speed);
}
// Se il valore è inferiore al centro, i motori girano in retromarcia
else {
// Imposta la direzione inversa per entrambi i motori
digitalWrite(motor1DirPin, LOW);
digitalWrite(motor2DirPin, LOW);
// Mappa il valore del potenziometro da [0, center-deadZone] a [255, 0]
int speed = map(potValue, 0, center - deadZone, 255, 0);
speed = constrain(speed, 0, 255);
ledcWrite(pwmChannel1, speed);
ledcWrite(pwmChannel2, speed);
}
delay(50); // Breve pausa per stabilizzare la lettura
}
· Impostazioni iniziali:
Vengono definiti i pin per il potenziometro e per i due motori (ognuno con un pin PWM e uno per la direzione). Il potenziometro, collegato a un ingresso analogico (GPIO34), fornisce il valore che determina la velocità e la direzione.
· Configurazione PWM:
Per ogni motore viene configurato un canale PWM separato tramite la funzione ledcSetup(). Il canale 0 viene usato per il motore 1 e il canale 1 per il motore 2.
· Controllo della velocità e direzione:
Nel loop, il valore del potenziometro viene letto. Se il valore è vicino al centro (entro una zona morta), i motori vengono fermati. Se il valore supera il centro, si imposta la direzione in avanti (HIGH) e si mappa il valore analogico a un range di velocità da 0 a 255 per il PWM. Se il valore è inferiore al centro, la direzione viene impostata in retromarcia (LOW) e la velocità è mappata in modo inverso.
Questo sketch fornisce una base di partenza per controllare due motori in parallelo. Se hai necessità di controllare i due motori in modo indipendente (ad esempio, con ingressi separati per la velocità o direzione), sarà necessario implementare ulteriori logiche e utilizzare altri ingressi analogici o digitali.
Spero che questo esempio ti sia utile per il tuo progetto!