Centralina per Pedalata Assistita su kit E-bike con acceleratore

[MaxVe]

Sto in questo periodo elettrificando un risciò che uso al mare per gli spostamento casa-spiaggia.
Per poterlo utilizzare a norma avevo la necessità di modificare il funzionamento della centralina del kit che ho acquistato che prevedeva l'uso dell'acceleratore come mezzo di regolazione della potenza del motore.

Essendo invece obbligatorio l'avviamento solo con la rotazione dei pedali e non volendo manomettere la centralina in dotazione ho deciso di realizzare una piccola centralina con ESP32 che si interfaccia a quella del motore tramite la porta dell'acceleratore.

Tutte le centraline di questi kit economici per e-bike da quanto ho capito regolano la velocità del motore in base al voltaggio presente sul filo segnale dell'acceleratore che varia da 1V quando spento a 4V alla massima velocità.

Il progetto, che ho realizzato non fa altro che inviare alla porta della centralina un voltaggio da 1 a 4 V in base alla presenza di pedalata verificato tramite un sensore PAS.

Riassumo le caratteristiche del funzionamento:
- possibilità di impostare 4 velocità diverse
- azionamento solo se si pedala almeno ad una rotazione dei pedali ogni 6 secondi
- partenza con rotazione di almeno 1/4 di giro del pedale
- spegnimento del motore se si smette di pedalare per più di 0,5 secondi
- spegnimento del motore se si tira il freno.

Implementazioni in preparazione
- pulsante walk-assist
- aggiornamento software OTA
- possibilità di collegare a smartphone tramite AP dell'ESP per configurare i parametri di funzionamento.

al momento ho utilizzato per un po' il sistema al banco in attesa di montarlo sul mezzo e non ha dato problemi, confido di montarlo entro marzo e provarlo sul campo una volta ultimata la parte in lavorazione.

Alcuni consigli sui collegamenti:
i 2 pulsanti selettori vanno collegati al relativo pin e a GND
i 4 led che indicano la potenza impostata vanno collegati ai rispettivi pin con una resistenza da 220-270 ohm
il sensore PAS va collegato al pin di ingresso e al +3.3v e GND (attenzione a non collegarlo al +5V)
il sensore freno va collegato al relativo pin e a GND

l'alimentazione dell'ESP32 è fatta tramite uno step-down collegato alla porta di alimentazione della centralina che porta la tensione da 24V a 5V.

Se qualche appassionato ha osservazioni o consigli sono sempre molto ben accetti.

Vi allego il codice da caricare sull'EPS32 per chi vuole provarlo, ovviamente ognuno lo fa a suo rischio e pericolo.

--------------------------------------------

#include <Adafruit_MCP4725.h>
#include <Arduino.h>
#include <Wire.h>

Adafruit_MCP4725 dac;


// Pin sensor PAS
const byte pin_pas = 4;
// Pin freno.
const byte pin_freno = 17;
// Pin power up
const byte pin_up = 18;
// Pin power down
const byte pin_down = 19;

// led power set
const byte pin_led1 = 32;
const byte pin_led2 = 33;
const byte pin_led3 = 25;
const byte pin_led4 = 26;


const int valore_stop = 209;
const int valore_p0 = 235;
const int valore_p1 = 296;
const int valore_p2 = 357;
const int valore_p3 = 418;
const int valore_p4 = 479;
const int valore_p5 = 540;
const int valore_p6 = 601;
const int valore_p7 = 622;
const int valore_p8 = 723;
const int valore_p9 = 784;
const int valore_p10 = 842;

// valore potenza massima motore impostata
int valore_set;
// pedali in movimento
int pedala = 0;
// valore modalità potenza
int valore_power = 1;
// valore attuale motore
int valore_motore;
// valore precedente motore
int valore_motore_prec = 0;
// valore freno
int freno = LOW;
// valore crescita rampa motore
int tprogro = 200;
// timer
unsigned long tprev = 0;
unsigned long pasprev = 0;
unsigned long passec = 0;
// pulsante su mappa motore
int push_up_now = 1;
int push_up_before = 1;
// pulsante su mappa motore
int push_down_now = 1;
int push_down_before = 1;
// mappatura valore DAC
int valDac(int vl_acel) {
return map(vl_acel, 0, 1023, 0, 4095);
}


// verifica se sto pedalando almeno 1 impulso ogni 0,5 sec
void pedalata() {
unsigned long tnow1 = millis();
//Serial.print("Il Pedale Gira : ");
//Serial.println(pedala);
pasprev = tnow1;
if (tnow1 - pasprev > 250) {pedala = 0;}
else{
if (tnow1 - passec >= 1000 && pedala > 6){pedala = 10; passec = tnow1;}
pedala = pedala + 1;
}

}

// pulsante aumento mappa potenza
void pushup() {
push_up_now = digitalRead(pin_up);
//Serial.print("Bottone Up: ");
//Serial.println(push_up_now);
if (push_up_now != push_up_before){
push_up_before = push_up_now;
if ( push_up_now == 0){
if (valore_power == 3) {valore_power = 4; valore_set = valore_p9; digitalWrite (pin_led1, LOW); digitalWrite (pin_led2, LOW); digitalWrite (pin_led3, LOW); digitalWrite (pin_led4, HIGH);}
if (valore_power == 2) {valore_power = 3; valore_set = valore_p6; digitalWrite (pin_led1, LOW); digitalWrite (pin_led2, LOW); digitalWrite (pin_led3, HIGH); digitalWrite (pin_led4, LOW);}
if (valore_power == 1) {valore_power = 2; valore_set = valore_p3; digitalWrite (pin_led1, LOW); digitalWrite (pin_led2, HIGH); digitalWrite (pin_led3, LOW); digitalWrite (pin_led4, LOW);}
//Serial.print("Set Potenza: ");
//Serial.println(valore_power);
}
}
}

// pulsante diminuzione mappa potenza
void pushdown() {
push_down_now = digitalRead(pin_down);
if (push_down_now != push_down_before){
push_down_before = push_down_now;
if (push_down_now == 0) {
if (valore_power == 2) {valore_power = 1; valore_set = valore_p1; digitalWrite (pin_led1, HIGH); digitalWrite (pin_led2, LOW); digitalWrite (pin_led3, LOW); digitalWrite (pin_led4, LOW); }
if (valore_power == 3) {valore_power = 2; valore_set = valore_p3; digitalWrite (pin_led1, LOW); digitalWrite (pin_led2, HIGH); digitalWrite (pin_led3, LOW); digitalWrite (pin_led4, LOW); }
if (valore_power == 4) {valore_power = 3; valore_set = valore_p6; digitalWrite (pin_led1, LOW); digitalWrite (pin_led2, LOW); digitalWrite (pin_led3, HIGH); digitalWrite (pin_led4, LOW); }
Serial.print("Set Potenza: ");
Serial.println(valore_power);
}
}
}

void setup() {
Serial.begin(9600);
dac.begin(0x60);
dac.setVoltage(valDac(valore_stop), false);
valore_set = valore_p1;

pinMode(pin_pas, INPUT);
pinMode(pin_freno, INPUT_PULLUP);
pinMode(pin_up, INPUT_PULLUP);
pinMode(pin_down, INPUT_PULLUP);
pinMode(pin_led1, OUTPUT);
pinMode(pin_led2, OUTPUT);
pinMode(pin_led3, OUTPUT);
pinMode(pin_led4, OUTPUT);

digitalWrite (pin_led1, HIGH);
digitalWrite (pin_led2, LOW);
digitalWrite (pin_led3, LOW);
digitalWrite (pin_led4, LOW);

// Interrupt.
attachInterrupt(digitalPinToInterrupt(pin_pas), pedalata, CHANGE);
attachInterrupt(digitalPinToInterrupt(pin_up), pushup, CHANGE);
attachInterrupt(digitalPinToInterrupt(pin_down), pushdown, CHANGE);

valore_motore_prec;
valore_motore = valore_stop;
freno = digitalRead(pin_freno);
//Serial.print("Freno: ");
//Serial.println(freno);
//Serial.print("Velocità motore: ");
//Serial.println(valore_motore);

}

void loop() {
unsigned long tnow = millis();
// leggo stato freno
freno = digitalRead(pin_freno);
// se non pedalo per 0,5 sec spengo il motore
if (tnow - pasprev > 500) {pedala = 0;}
// se non è tirato il freno verifico se accendere il motore richiesto 1/4 di giro di pedali per partire (6 inpulsi su 24)
if (freno == 1){
if (pedala > 6) {
if (tnow - tprev > tprogro){
if (valore_motore < valore_set) {valore_motore = valore_motore + 12;}
if (valore_motore > valore_set) {valore_motore = valore_set;}
dac.setVoltage(valDac(valore_motore), false);
tprev = millis();
}
}
else {valore_motore = valore_stop;
dac.setVoltage(valDac(valore_stop), false);
}
}
// se il freno è tirato fermo subito il motore
else {
valore_motore = valore_stop;
dac.setVoltage(valDac(valore_stop), false);

}
// per debug
// if (valore_motore != valore_motore_prec){
// Serial.print("Velocità motore: ");
// Serial.println(valore_motore);
// valore_motore_prec = valore_motore;
// }
}

------------------------------------------------------------------

[Murales]

Bel progetto, grazie per la condivisione!

[MaxVe]

Grazie Murales.

Dimenticavo per inviare il segnale 1-4V serve un DAC modello MCP4725 che va collegato tramite i pins SDA e SCL all' ESP32.

Il costo totale del progetto è di circa 15 euro acquistando i componenti su AliExpress.