Emuland ESP ha un solo analogico, A0

capi32 lo hai visto il progetto di Righetz

Emuland,
Non avevo capito ESP.
Ho cercato questo modulo e infatti il modulo esp32 potrebbe essere una buona soluzione. ma siccome l'hardware è già ordinato, il primo prototipo sarà su Arduino. Tengo le informazioni da parte per il futuro..

Claudio,
Ho appena letto il codice e non gestisce l'intensità o il risultato delle capacità (Ah).
aziona solo i relè per le modalità di carica e scarica a seconda della tensione e del tempo.
tutte le altre regolazioni e misure devono essere fatte manualmente e richiedono un sacco di lavoro quotidiano. Non voglio fare di nuovo questo lavoro ansioso.

Ho bisogno di arduino per sputare fuori le curve direttamente su di me, al fine di analizzarle facilmente.
siamo nel 2019 e non nel 1910, lasciate che le macchine funzionino per noi.

stasera ho lavorato un po' sul codice.
Normalmente ho creato tutte le costanti e le variabili che mi saranno utili nel codice.
c'è solo la funzione di ricarica

il passo successivo sarà aggiunto:
la funzione di scarico
la funzione ciclo
la funzione di conteggio dei cicli
ecc.......

CITAZIONE (Claudio, 20/09/2019 18:03:03 )

dopo alcune settimane di test e modifiche, finalmente ho una prima versione funzionale. la parte dei cicli di carica e scarica funziona ma l'alimentazione non è ancora gestita dal codice.

Non mi aspettavo che l'alimentazione tra la resistenza di potenza (r2) dovesse essere variabile e superiore alla tensione di carica della batteria per soddisfare il setpoint della corrente di carica.

Per testare il funzionamento, utilizzo batterie CR-2 Li-ion 3V 800Mah e INR18650-13Q 1300mAh agli ioni di litio . Ho aggiunto un ponte divisore di tensione (R9 R10 R11 R12) per poter gestire tensioni di carica superiori a 5v.

per i curiosi, fornisco il codice che utilizzo per il 18650 con un alimentatore esterno (ms-305d).

-TOP CODE-
//Arduino_Planté_cell_cycle_tester_24.ino #include <Wire.h> #include <LiquidCrystal_I2C.h> LiquidCrystal_I2C lcd(0x27,16,2); // Definir les variables système double cellVolts; double cellVolts2; int chargeCurrent; int numberCycles; int currentState; int delayTimer; int stateTimer; unsigned long sampleDelay; unsigned long cycleTime; // Definir le materiels #define DISCHARGE 8 // Relais de decharge #define RECHARGE 7 // Relais de recharge #define VOLTS A1 // Tension de cellule #define CURRENT A2 // CHARGE courant (pas de decharge ...jeca ) int gatePinC = 10; // jeca - Câble de signal de sortie (pour le Mosfet) connecte à la Pin numerique 9 int gatePinD = 9; // jeca - Câble de signal de sortie (pour le Mosfet) connecte à la Pin numerique 9 float resistance = 6.0; //resistance mesuree de la resistance R2 de puissance (+0.5pour le mosfet) #define EXTERNDIV_NUM 2 // valeur x > diviseur de tension externe > pour abaisser les mesures de tension des batteries a moins de 5v ,pont diviseur par 4 #define EXTERNDIV_DENOM 1 // valeur 1 > diviseur de tension externe > DENOM doit egale a 1 #define SAMPLE_DELAY_MILLIS 1000 // Nombre de mS entre les contrôles de tension #define RECOVERYTIME 20 // Nombre de secondes entre la charge/decharge et la decharge/charge La valeur maximale est 32767 #define MAXSTATETIME 21600 // Nombre de secondes autorisees dans chaque etat (c'est-à-dire chargement ou dechargement) La valeur maximale est 32767. #define ON 1 // Mettre un relais en marche #define OFF 0 // Eteindre un relais Off #define TolCurrent 2 // plage de correction du courant en mA #define VCCVOLTS 5010L // Valeur reelle du rail 5 volts LAISSER LE SUFFIXE "L car cette valeur doit être une valeur int longue #define TempPin = 2 //Sonde_3 de Temperature connectee à la Pin analogique 2 float TempTc = 0; //variable pour stocker la valeur de TempPin analogique float tmp36Voltage = 0; //calculated voltage at TempPin float temperatureC = 0; //temperature calculee de la sonde en degres C //---------------------------- Definir les parametre de la batterrie et des cycles de test int batteryCapacity = 1300; //capacite nominale de la batterie en mAh // reglages pour la charge unsigned int MosfetCValue = 1; //valeur de demarage cycle 1 ;du signal de sortie PWM (pour le Mosfet) unsigned int MosfetCStart = 1; //valeur recalcule suivant la capacite du cycle precedent #define currentMin 100 //courant de charge minimale en mA #define SpeedCharge 1.4 //Vitesse de charge > C7 > 7 = decharge en 7 heures #define V_floating 4200 //tension de floating (en #define cutoffcurrent 100 // intensite en mA de in de char #define VoltageChargeMaxi 4210 //tension limite de securite > stop charge (en mV) //reglages pour la decharge unsigned int MosfetDValue = 1; //valeur de demarage cycle 1 ;du signal de sortie PWM (pour le Mosfet) unsigned int MosfetDStart = 1; //valeur recalcule suivant la capacite du cycle precedent #define SpeedDisCharge 4 //Vitesse de decharge > C10 > 10 = decharge en 10 heures #define V_MIN 2500 // fin de decharge / Tension min de decharge (en mV) //reglages des cycles #define NUMBEROFCYCLES 3 // Nombre de cycles à executer //-------pour le calcul de la capacite-------- float mAh = 0.0; boolean finished = false; //unsigned long millis = 0; unsigned long previousMillis = 0; unsigned long millisPassed = 0; int printStart = 0; int interval = 5000; //Interval (ms) between measurements //-------- //------------------------------------------------- // variables calcule par le code double CurrentCharge = 0; //courant charge calcule (en mA) double CurrentDisCharge = 0; //courant decharge calcule (en mA) double CibleCurrentCharge = batteryCapacity / SpeedCharge; //courant de sortie cible (en mA) regle à C / 10 ou 1/10 de la capacite de la batterie par heure double CibleCurrentDisCharge = batteryCapacity / SpeedDisCharge; //courant de sortie cible (en mA) regle à C / 10 ou 1/10 de la capacite de la batterie par heure double currentChargError = 0; //difference entre le courant de consigne et le courant reel (en mA) double currentDisChargError = 0; //difference entre le courant de consigne et le courant reel (en mA) // Machine d'etat #define STATE_START 0 // Configurer et demarrer le cycle de charge #define STATE_CHARGING 1 // Surveiller le cycle de charge #define STATE_DISWAIT 2 // Delai avant et reglage pour la decharge #define STATE_DISCHARGING 3 // Surveiller la decharge #define STATE_CHGWAIT 4 // Delai avant de repeter le cycle #define STATE_DONE 5 // Termine // readVoltage() // Lire la tension de la cellule et retourner la moyenne de 4 lectures. // Le resultat est mis à l'echelle par la valeur d'etalonnage ainsi que par le diviseur externe. // La valeur de retour est en milliVolts, c'est-à-dire 0 - 5000 int readVoltage() { int temp = 0; for (int i = 0; i < 4; i++) { //Mettre à l'echelle la lecture A2D. L'A2D renvoie 0 à 1023 pour une tension // plage de 0 à la tension d'alimentation de l'Arduino (normalement 5v). temp += (int)(((long)analogRead(VOLTS) * VCCVOLTS) / 1024); // Scale the A2D result delay(20); // Un court delai entre les lectures } return (temp*EXTERNDIV_NUM)/(EXTERNDIV_DENOM*4); // Compenser le diviseur de tension externe } // readVoltage2() // Lire la tension de la cellule apres la resitance et retourner la moyenne de 4 lectures. // Le resultat est mis à l'echelle par la valeur d'etalonnage ainsi que par le diviseur externe. // La valeur de retour est en milliVolts, c'est-à-dire 0 - 5000 int readVoltage2() { int temp = 0; for (int i = 0; i < 4; i++) { //Mettre à l'echelle la lecture A2D. L'A2D renvoie 0 à 1023 pour une tension // plage de 0 à la tension d'alimentation de l'Arduino (normalement 5v). temp += (int)(((long)analogRead(CURRENT) * VCCVOLTS) / 1024); // Scale the A2D result delay(20); // Un court delai entre les lectures } return (temp*EXTERNDIV_NUM)/(EXTERNDIV_DENOM*4); // Compenser le diviseur de tension externe } //-------------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------------- // Cette fonction configure les ports à utiliser et initialise certaines variables. void setup() { // Configuration pour le debogage et l'enregistrement // Print a message to the LCD. lcd.backlight(); lcd.setCursor(0,0); lcd.print(" Testeur Cycles "); //Intro Message line 1 lcd.setCursor(0,1); //Second line lcd.print("Batterie Plante"); //Intro Message line 2 delay(3000); lcd.clear(); //----- Serial.begin(9600); Serial.println("Demarage Cycle"); // Ajoute un CR - use Serial.print() pour aucun CR numberCycles = 1; Serial.println(); currentState = STATE_START; Serial.println("STATE_START"); Serial.println(); lcd.init(); // initialize the lcd pinMode(DISCHARGE, OUTPUT); // definit la broche de decharge comme sortie digitalWrite(DISCHARGE, OFF); // Desactive le relais de decharge pinMode(RECHARGE, OUTPUT); // definit la broche de recharge comme sortie digitalWrite(RECHARGE, OFF); // Desactive le relais de recharge cellVolts = readVoltage(); // Do first read pour initialiser le port pinMode(9, OUTPUT); pinMode(10, OUTPUT); digitalWrite(gatePinC, 0); digitalWrite(gatePinD, 0); // TODO - initialisez votre affichage } //-------------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------------- // Cette fonction est appelee à plusieurs reprises par le système d'exploitation, nous avons donc besoin de savoir où dans le fichier // On est un cycle de decharge de charge, donc on utilise une machine d'etat. void loop() { unsigned long now = millis(); // Obtenir la valeur actuelle de la minuterie en mS if (now - sampleDelay > SAMPLE_DELAY_MILLIS) { sampleDelay = now; // Reinitialiser l'heure de base de l'echantillonnage switch (currentState) // Aller à l'etat actuel { //---------------------------- case STATE_START: stateTimer = MAXSTATETIME; // Valeur de temporisation de l'etat de configuration currentState = STATE_CHARGING; // L'etat suivant est charge Serial.println("------------------------------------------------"); Serial.print("CYCLE CHARGING Cycle # "); Serial.println(numberCycles); Serial.println("------------------------------------------------"); Serial.println(); cycleTime = now; // Heure de debut d'etat digitalWrite(RECHARGE, ON); // Activer le relais de charge // Serial.print("Cycle #"); // Logging // Serial.println(numberCycles); // TODO update display break; //---------------------------- case STATE_CHARGING: cellVolts = readVoltage(); // Faire une lecture cellVolts2 = readVoltage2(); // Faire une lecture MosfetCValue = MosfetCStart; analogWrite(gatePinC, MosfetCValue); //ecrit la nouvelle valeur de sortie CibleCurrentCharge = batteryCapacity / SpeedCharge; //c CurrentCharge = (cellVolts2 - cellVolts ) / resistance; //jeca calculer le courant de decharge currentChargError = CibleCurrentCharge - CurrentCharge; //jeca difference between target current and measured current // Serial.print("batteryCapacity: "); // // Serial.println(batteryCapacity); // Serial.println(); Serial.print("batterie (V): "); //afficher la tension de la batterie Serial.println(cellVolts/1000); Serial.print("Shunt (V): "); Serial.println(cellVolts2/1000); Serial.print("Mosfet: "); //afficher les valeurs de sortie pour la surveillance avec un ordinateur Serial.println(MosfetCValue); Serial.print("Cible (mA): "); Serial.println(CibleCurrentCharge); Serial.print("Charge(mA): "); //afficher le courant actuel Serial.println(CurrentCharge); Serial.println(); Serial.println(); lcd.clear(); lcd.setCursor(0,0); lcd.print(numberCycles); lcd.setCursor(4,0); lcd.print("Charg"); lcd.setCursor(11,0); lcd.print(cellVolts/1000); lcd.setCursor(15,0); lcd.print("V"); lcd.setCursor(0,1); lcd.print("Mosf:"); lcd.setCursor(5,1); lcd.print(MosfetCValue); lcd.setCursor(9,1); lcd.print(CurrentCharge); lcd.setCursor(14,1); lcd.print("mA"); //Corrections Intensite de charge if(MosfetCValue > 0) { if( ((CurrentCharge + (TolCurrent + 1)) <= CibleCurrentCharge ) && (MosfetCValue < 255) ) //while { MosfetCValue = MosfetCValue + 1; MosfetCStart = MosfetCValue; analogWrite(gatePinC, MosfetCValue); //ecrit la nouvelle valeur de sortie Serial.print("Correction Charge + Mosfet: "); //afficher les valeurs de sortie pour la surveillance avec un ordinateur Serial.println(MosfetCValue); } if( ((CurrentCharge - (TolCurrent + 1)) >= CibleCurrentCharge ) && (MosfetCValue > 0) ) // { MosfetCValue = MosfetCValue - 1; MosfetCStart = MosfetCValue; analogWrite(gatePinC, MosfetCValue); //ecrit la nouvelle valeur de sortie Serial.print("Correction Charge - Mosfet: "); //afficher les valeurs de sortie pour la surveillance avec un ordinateur Serial.println(MosfetCValue); } } //info erreur if(MosfetCValue > 255) //la sortie ne peut jamais depasser 255 { MosfetCValue = 255; analogWrite(gatePinC, MosfetCValue); //ecrit la nouvelle valeur de sortie Serial.print("Erreur calcul MosfetC: "); //afficher les valeurs de sortie pour la surveillance avec un ordinateur Serial.println(); } // arrêt de charge > fin de charge if ( (cellVolts >= V_floating) && (CurrentCharge <= cutoffcurrent) && (MosfetCValue > 0) ) { MosfetCValue = 0; analogWrite(gatePinC, MosfetCValue); //ecrit la nouvelle valeur de sortie Serial.println("------------------------------------------------"); Serial.println("Fin de charge (Floating)"); Serial.print("MosfetC: "); //afficher les valeurs de sortie pour la surveillance avec un ordinateur Serial.println(MosfetCValue); digitalWrite(RECHARGE, OFF); // Desactive le relais de charge currentState = STATE_DISWAIT; // L'etat suivant est en attente avant la decharge Serial.println("------------------------------------------------"); Serial.println("CYCLE DISWAIT"); Serial.println("------------------------------------------------"); Serial.println(); Serial.print("MosfetC: "); //afficher les valeurs de sortie pour la surveillance avec un ordinateur Serial.println(MosfetCValue); Serial.print("MosfetCStart: "); //afficher les valeurs de sortie pour la surveillance avec un ordinateur Serial.println(MosfetCStart); Serial.print("MosfetD: "); //afficher les valeurs de sortie pour la surveillance avec un ordinateur Serial.println(MosfetDValue); Serial.print("MosfetDStart: "); //afficher les valeurs de sortie pour la surveillance avec un ordinateur Serial.println(MosfetDStart); Serial.print("MosfetCValue: "); //afficher les valeurs de sortie pour la surveillance avec un ordinateur Serial.println(MosfetCValue); Serial.print("MosfetDValue: "); //afficher les valeurs de sortie pour la surveillance avec un ordinateur Serial.println(MosfetDValue); Serial.println(); Serial.print("Capacite (mAh): "); //afficher Serial.println(mAh); Serial.print("Temps: "); //afficher Serial.println(previousMillis); delayTimer = RECOVERYTIME; // Interstate delay time Serial.print("Temps de charge: (S) "); // Logging Serial.println((now - cycleTime)/1000); Serial.println(); lcd.clear(); lcd.setCursor(0,0); lcd.print("Charge fini"); lcd.setCursor(0,1); lcd.print("Temps:"); lcd.setCursor(8,1); lcd.print((now - cycleTime)/1000); // TODO update display } // arrêt de charge >surcharge if(cellVolts >= VoltageChargeMaxi) //arrêter la charge { digitalWrite(RECHARGE, OFF); // Desactive le relais de charge MosfetCValue = 0; analogWrite(gatePinC, MosfetCValue); //ecrit la nouvelle valeur de sortie Serial.print("MosfetC: "); //afficher les valeurs de sortie pour la surveillance avec un ordinateur Serial.println(MosfetCValue); Serial.println("------------------------------------------------"); Serial.print("Stop surcharge (VoltageChargeMaxi)"); Serial.println(); lcd.clear(); lcd.setCursor(0,1); lcd.print("Stop surcharge"); } // arrêt de charge > trop longtemps if (--stateTimer <= 0) { digitalWrite(RECHARGE, OFF); // Desactive le relais de charge MosfetCValue = 0; analogWrite(gatePinC, MosfetCValue); //ecrit la nouvelle valeur de sortie Serial.print("MosfetC: "); //afficher les valeurs de sortie pour la surveillance avec un ordinateur Serial.println(MosfetCValue); Serial.println("------------------------------------------------"); Serial.print("Temps de Charge maxi depasse"); Serial.println(); lcd.clear(); lcd.setCursor(0,0); lcd.print("Stop Charge"); lcd.setCursor(0,1); lcd.print("Temps maxi"); currentState = STATE_DONE; // L'etat suivant est fait Serial.println("CYCLE DONE 1"); Serial.println(); // TODO update display } break; //---------------------------- case STATE_DISWAIT: if (--delayTimer <= 0) { digitalWrite(DISCHARGE, ON); // Activer le relais de decharge currentState = STATE_DISCHARGING; // L'etat suivant est decharge Serial.println("------------------------------------------------"); Serial.print("CYCLE DECHARGE Cycle # "); Serial.println(numberCycles); Serial.println("------------------------------------------------"); Serial.println(); stateTimer = MAXSTATETIME; // Valeur de temporisation de l'etat de configuration cycleTime = now; // Heure de debut d'etat } // TODO update display break; //---------------------------- case STATE_DISCHARGING: cellVolts = readVoltage(); // Faire une lecture cellVolts2 = readVoltage2(); // Faire une lecture MosfetDValue = MosfetDStart; analogWrite(gatePinC, MosfetDValue); //ecrit la nouvelle valeur de sortie CibleCurrentDisCharge = batteryCapacity / SpeedDisCharge; //c CurrentDisCharge = (cellVolts - cellVolts2 ) / resistance; //jeca calculer le courant de decharge currentDisChargError = CibleCurrentDisCharge - CurrentDisCharge; //jeca difference between target current and measured current millisPassed = millis() - previousMillis; // mAh = mAh + (CurrentDisCharge * 1000.0) * (millisPassed / 3600000.0); mAh = mAh + (CurrentDisCharge) * (millisPassed / 3600000.0); previousMillis = millis(); Serial.print("batterie(V):"); //afficher la tension de la batterie Serial.println(cellVolts/1000); Serial.print("Shunt (V):"); Serial.println(cellVolts2/1000); Serial.print("Mosfet: "); //afficher les valeurs de sortie pour la surveillance avec un ordinateur Serial.println(MosfetDValue); Serial.print("Cible (mA): "); Serial.println(CibleCurrentDisCharge); Serial.print("Decharge(mA): "); //afficher le courant actuel Serial.println(CurrentDisCharge); Serial.print("Capacite (mAh): "); //afficher Serial.println(mAh); // Serial.print("millisPassed: "); //afficher // Serial.println(millisPassed); // Serial.print("previousMillis: "); //afficher // Serial.println(previousMillis); Serial.println(); //des espaces supplementaires pour faciliter la lecture des donnees de debogage Serial.println(); lcd.clear(); lcd.setCursor(0,0); lcd.print(numberCycles); lcd.setCursor(4,0); lcd.print("Dech."); lcd.setCursor(11,0); lcd.print(cellVolts/1000); lcd.setCursor(15,0); lcd.print("V"); lcd.setCursor(0,1); lcd.print(mAh); lcd.setCursor(5,1); lcd.print("mAh"); lcd.setCursor(9,1); lcd.print(CurrentDisCharge); lcd.setCursor(14,1); lcd.print("mA"); //Corrections Intensite de decharge if(MosfetDValue > 0) { if( ((CurrentDisCharge + (TolCurrent + 1)) <= CibleCurrentDisCharge ) && (MosfetDValue < 255) ) // { MosfetDValue = MosfetDValue + 1; MosfetDStart = MosfetDValue; analogWrite(gatePinD, MosfetDValue); //ecrit la nouvelle valeur de sortie Serial.print("Correction decharge + Mosfet: "); //afficher les valeurs de sortie pour la surveillance avec un ordinateur Serial.println(MosfetDStart); } if( ((CurrentDisCharge - (TolCurrent + 1)) >= CibleCurrentDisCharge ) && (MosfetDValue > 0) ) //while { MosfetDValue = MosfetDValue - 1; MosfetDStart = MosfetDValue; analogWrite(gatePinD, MosfetDValue); //ecrit la nouvelle valeur de sortie Serial.print("Correction decharge - Mosfet: "); //afficher les valeurs de sortie pour la surveillance avec un ordinateur Serial.println(MosfetDValue); } } //info erreur if(MosfetDValue > 255) //la sortie ne peut jamais depasser 255 { MosfetDValue = 255; analogWrite(gatePinD, MosfetDValue); //ecrit la nouvelle valeur de sortie Serial.print("Erreur calcul Mosfet: "); //afficher les valeurs de sortie pour la surveillance avec un ordinateur Serial.println(); } // arrêt de decharge > si l' intensite de decharge ateint le seuil mini de decharge if (cellVolts < V_MIN) { digitalWrite(DISCHARGE, OFF); // Desactive le relais de decharge MosfetDValue = 0; analogWrite(gatePinD, MosfetDValue); //ecrit la nouvelle valeur de sortie Serial.print("MosfetC: "); //afficher les valeurs de sortie pour la surveillance avec un ordinateur Serial.println(MosfetCValue); Serial.print("MosfetD: "); //afficher les valeurs de sortie pour la surveillance avec un ordinateur Serial.println(MosfetDValue); currentState = STATE_CHGWAIT; // L'etat suivant est en attente avant la charge Serial.println("CYCLE CHGWAIT"); Serial.println(); delayTimer = RECOVERYTIME; // Inter state delay time > Temps de retard entre etats stateTimer = MAXSTATETIME; // Valeur de temporisation de l'etat de configuration Serial.println("------------------------------------------------"); Serial.print("Fin de decharge # "); Serial.println(numberCycles); Serial.println("------------------------------------------------"); Serial.print("Temps de decharge: (S) "); // Logg Serial.println((now - cycleTime)/1000); Serial.println(); Serial.print("MosfetC: "); //afficher les valeurs de sortie pour la surveillance avec un ordinateur Serial.println(MosfetCValue); Serial.print("MosfetCStart: "); //afficher les valeurs de sortie pour la surveillance avec un ordinateur Serial.println(MosfetCStart); Serial.print("MosfetD: "); //afficher les valeurs de sortie pour la surveillance avec un ordinateur Serial.println(MosfetDValue); Serial.print("MosfetDStart: "); //afficher les valeurs de sortie pour la surveillance avec un ordinateur Serial.println(MosfetDStart); Serial.print("MosfetCValue: "); //afficher les valeurs de sortie pour la surveillance avec un ordinateur Serial.println(MosfetCValue); Serial.print("MosfetDValue: "); //afficher les valeurs de sortie pour la surveillance avec un ordinateur Serial.println(MosfetDValue); Serial.println(); Serial.print("Capacite Cycle (mAh): "); //afficher Serial.println(mAh); Serial.println("-------------------------------------------------------------"); Serial.println("-------------------------------------------------------------"); // Serial.print("Temps: "); //afficher // Serial.println(millisPassed); lcd.clear(); lcd.setCursor(0,0); lcd.print("Decha. fini"); lcd.setCursor(0,1); lcd.print("Capa:"); lcd.setCursor(11,1); lcd.print(mAh); lcd.setCursor(14,1); lcd.print("mAh"); } if (--stateTimer <= 0) { digitalWrite(DISCHARGE, OFF); // Desactive le relais de decharge MosfetDValue = 0; analogWrite(gatePinD, MosfetDValue); //ecrit la nouvelle valeur de sortie Serial.print("Temps de Decharge maxi depasse"); Serial.println(); lcd.clear(); lcd.setCursor(0,0); lcd.print("Stop Decharge"); lcd.setCursor(0,1); lcd.print("Temps maxi"); Serial.print("MosfetC: "); //afficher les valeurs de sortie pour la surveillance avec un ordinateur Serial.println(MosfetCValue); Serial.print("MosfetD: "); //afficher les valeurs de sortie pour la surveillance avec un ordinateur Serial.println(MosfetDValue); currentState = STATE_DONE; // L'etat suivant est fait Serial.println("CYCLE DONE 2"); Serial.println(); } // TODO update display break; //---------------------------- case STATE_CHGWAIT: if (--delayTimer <= 0) { if (++numberCycles <= NUMBEROFCYCLES) { currentState = STATE_START; // L'etat suivant est configure pour charger Serial.println("------------------------------------------------"); Serial.println("CYCLE START"); Serial.println("------------------------------------------------"); Serial.println(); Serial.print("Capacite precedente: "); // Serial.println(batteryCapacity); batteryCapacity = mAh; mAh = 0; Serial.print("Nouvelle Capacite: "); // Serial.println(batteryCapacity); } else { digitalWrite(DISCHARGE, OFF); // Desactive le relais de decharge digitalWrite(RECHARGE, OFF); // Desactive le relais de charge currentState = STATE_DONE; // L'etat suivant est fait Serial.println("CYCLE DONE 3"); Serial.println(); MosfetDValue = 0; analogWrite(gatePinD, MosfetDValue); //ecrit la nouvelle valeur de sortie Serial.print("MosfetC: "); //afficher les valeurs de sortie pour la surveillance avec un ordinateur Serial.println(MosfetCValue); Serial.print("MosfetD: "); //afficher les valeurs de sortie pour la surveillance avec un ordinateur Serial.println(MosfetDValue); Serial.println("------------------------------------------------"); Serial.println("Cycles finished"); // Logging Serial.println("------------------------------------------------"); Serial.println(); } } // TODO update display break; case STATE_DONE: // TODO update display break; } } // delay(2000); //delay x/1000 secondes avant la prochaine iteration }
-BOTTOM CODE-

Immagine Allegata: Arduino_Planté_cell_cycle_tester_7.Jpg
 

attualizzazione

ora tutto funziona. (eccetto la misurazione della temperatura)

Ho rimosso il mosfet per la carica perché alla fine non è utile. L'intensità di carica viene regolata variando la tensione di carica con il potenziometro digitale MCP4132 e il regolatore LM317T.

Continuerò i test e perfezionerò la parte di carica perché a volte ho variazioni di +- 10 mA. L'ideale sarebbe rimanere a +- 5mA.

-TOP CODE-
//Arduino_Planté_cell_cycle_tester_27.ino #include <Wire.h> #include <LiquidCrystal_I2C.h> LiquidCrystal_I2C lcd(0x27,16,2); #include <SPI.h> const int ss = 10; #define VMaxPower 9 //tension max du chargeur #define SepstPot 129 //pas du potentiometer numerique int ValuePot = 0; // Definir les variables système double cellVolts; double cellVolts2; double cellVolts3; double CibleChargeShunt; int chargeCurrent; int numberCycles; int currentState; int delayTimer; int stateTimer; unsigned long sampleDelay; unsigned long cycleTime; //int MosfetCValue; int MosfetDValue; // Definir le materiels #define RELAIS_DISCHARGE 8 // Relais de decharge #define RELAIS_RECHARGE 7 // Relais de RELAIS_RECHARGE #define VOLTS A1 // Tension de cellule #define CURRENT A2 // CHARGE courant (pas de decharge ...jeca ) #define VOLTSCHARGEUR A6 // Tension du chargeur int gatePinD = 9; // jeca - Câble de signal de sortie (pour le Mosfet) connecte à la Pin numerique 9 float resistance = 2.5; //resistance mesuree de la resistance R2 de puissance (+0.5 pour le mosfet) #define EXTERNDIV_NUM 2 // valeur x > diviseur de tension externe > pour abaisser les mesures de tension des batteries a moins de 5v ,pont diviseur par 4 #define EXTERNDIV_DENOM 1 // valeur 1 > diviseur de tension externe > DENOM doit egale a 1 #define SAMPLE_DELAY_MILLIS 1000 // Nombre de mS entre les contrôles de tension #define RECOVERYTIME 20 // Nombre de secondes entre la charge/decharge et la decharge/charge La valeur maximale est 32767 #define MAXSTATETIME 21600 // Nombre de secondes autorisees dans chaque etat (c'est-à-dire chargement ou dechargement) La valeur maximale est 32767. #define ON 1 // Mettre un relais en marche #define OFF 0 // Eteindre un relais Off #define TolCurrent 4 // plage de correction du courant en mA #define VCCVOLTS 5010L // Valeur reelle du rail 5 volts LAISSER LE SUFFIXE "L car cette valeur doit être une valeur int longue #define TempPin = 2 //Sonde_3 de Temperature connectee à la Pin analogique 2 float TempTc = 0; //variable pour stocker la valeur de TempPin analogique float tmp36Voltage = 0; //calculated voltage at TempPin float temperatureC = 0; //temperature calculee de la sonde en degres C //---------------------------- Definir les parametre de la batterrie et des cycles de test int batteryCapacity = 900; //capacite nominale de la batterie en mAh // reglages pour la charge #define currentMin 40 //courant de charge minimale en mA #define Speed_CHARGE 10 //Vitesse de charge > C7 > 7 = decharge en 7 heures #define V_floating 1400 //tension de floating (en #define cutoffcurrent 90 // intensite en mA de in de char #define VoltageChargeMaxi 1500 //tension limite de securite > stop charge (en mV) //reglages pour la decharge //unsigned int MosfetDValue = 10; //valeur de demarage cycle 1 ;du signal de sortie PWM (pour le Mosfet) float MosfetDInit = 10; //valeur de demarage cycle float MosfetDStart = 100; //valeur recalcule #define currentMinD 40 //courant de decharge minimale en mA #define Speed_DISCHARGE 10 //Vitesse de decharge > C10 > 10 = decharge en 10 heures #define V_MIN 1000 // fin de decharge / Tension min de decharge (en mV) //reglages des cycles #define NUMBEROFCYCLES 3 // Nombre de cycles à executer //-------pour le calcul de la capacite-------- float mAh = 0.0; boolean finished = false; unsigned long previousMillis = 0; unsigned long millisPassed = 0; int printStart = 0; int interval = 5000; //Interval (ms) between measurements //-------- //------------------------------------------------- // variables calcule par le code double CurrentCharge = 0; //courant charge calcule (en mA) double CurrentDischarge = 0; //courant decharge calcule (en mA) double CibleCurrentCharge = batteryCapacity / Speed_CHARGE; //courant de sortie cible (en mA) regle à C / 10 ou 1/10 de la capacite de la batterie par heure double CibleCurrentDISCHARGE = batteryCapacity / Speed_DISCHARGE; //courant de sortie cible (en mA) regle à C / 10 ou 1/10 de la capacite de la batterie par heure double CurrentDischargerror = 0; //difference entre le courant de consigne et le courant reel (en mA) int ValuePotStart = (VMaxPower / SepstPot) * (V_floating/1000) + ((CibleCurrentCharge/1000) * resistance ); // Machine d'etat #define STATE_START 0 // Configurer et demarrer le cycle de charge #define STATE_CHARGING 1 // Surveiller le cycle de charge #define STATE_DISWAIT 2 // Delai avant et reglage pour la decharge #define STATE_DISCHARGING 3 // Surveiller la decharge #define STATE_CHGWAIT 4 // Delai avant de repeter le cycle #define STATE_DONE 5 // Termine // readVoltage() // Lire la tension de la cellule et retourner la moyenne de 4 lectures. // Le resultat est mis à l'echelle par la valeur d'etalonnage ainsi que par le diviseur externe. // La valeur de retour est en milliVolts, c'est-à-dire 0 - 5000 int readVoltage() { int temp = 0; for (int i = 0; i < 4; i++) { //Mettre à l'echelle la lecture A2D. L'A2D renvoie 0 à 1023 pour une tension // plage de 0 à la tension d'alimentation de l'Arduino (normalement 5v). temp += (int)(((long)analogRead(VOLTS) * VCCVOLTS) / 1024); // Scale the A2D result delay(20); // Un court delai entre les lectures } return (temp*EXTERNDIV_NUM)/(EXTERNDIV_DENOM*4); // Compenser le diviseur de tension externe } // readVoltage2() // Lire la tension de la cellule apres la resitance et retourner la moyenne de 4 lectures. // Le resultat est mis à l'echelle par la valeur d'etalonnage ainsi que par le diviseur externe. // La valeur de retour est en milliVolts, c'est-à-dire 0 - 5000 int readVoltage2() { int temp = 0; for (int i = 0; i < 4; i++) { //Mettre à l'echelle la lecture A2D. L'A2D renvoie 0 à 1023 pour une tension // plage de 0 à la tension d'alimentation de l'Arduino (normalement 5v). temp += (int)(((long)analogRead(CURRENT) * VCCVOLTS) / 1024); // Scale the A2D result delay(20); // Un court delai entre les lectures } return (temp*EXTERNDIV_NUM)/(EXTERNDIV_DENOM*4); // Compenser le diviseur de tension externe } int readVoltage3() { int temp = 0; for (int i = 0; i < 4; i++) { //Mettre à l'echelle la lecture A2D. L'A2D renvoie 0 à 1023 pour une tension // plage de 0 à la tension d'alimentation de l'Arduino (normalement 5v). temp += (int)(((long)analogRead(VOLTSCHARGEUR) * VCCVOLTS) / 1024); // Scale the A2D result delay(20); // Un court delai entre les lectures } return (temp*EXTERNDIV_NUM)/(EXTERNDIV_DENOM*4); // Compenser le diviseur de tension externe } //-------------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------------- // Cette fonction configure les ports à utiliser et initialise certaines variables. void setValuePot(int value) { digitalWrite(ss, LOW); SPI.transfer(0); // send command byte SPI.transfer(value); // send value (0~255) digitalWrite(ss, HIGH); } void setup() { // Configuration pour le debogage et l'enregistrement // Print a message to the LCD. lcd.backlight(); lcd.setCursor(0,0); lcd.print(" Testeur Cycles "); //Intro Message line 1 lcd.setCursor(0,1); //Second line lcd.print("Batterie Plante"); //Intro Message line 2 delay(3000); lcd.clear(); //----- Serial.begin(9600); Serial.println("Demarage Cycle"); // Ajoute un CR - use Serial.print() pour aucun CR numberCycles = 1; Serial.println(); currentState = STATE_START; Serial.println("STATE_START"); Serial.println(); lcd.init(); // initialize the lcd pinMode(RELAIS_DISCHARGE, OUTPUT); // definit la broche de decharge comme sortie digitalWrite(RELAIS_DISCHARGE, OFF); // Desactive le relais de decharge pinMode(RELAIS_RECHARGE, OUTPUT); // definit la broche de RELAIS_RECHARGE comme sortie digitalWrite(RELAIS_RECHARGE, OFF); // Desactive le relais de RELAIS_RECHARGE pinMode(ss, OUTPUT); // we use this for SS pin SPI.begin(); // wake up the SPI bus. SPI.setBitOrder(MSBFIRST); // our MCP4162 requires data to be sent MSB (most significant byte) first cellVolts = readVoltage(); // Do first read pour initialiser le port pinMode(9, OUTPUT); // digitalWrite(gatePinC, 0); digitalWrite(gatePinD, 0); setValuePot(ValuePotStart); delay(1000); cellVolts3 = readVoltage3(); // Faire une lecture Serial.print("pot:"); Serial.println(ValuePotStart); Serial.print("v:"); Serial.println(cellVolts3/1000); Serial.println(); // TODO - initialisez votre affichage } //-------------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------------- // Cette fonction est appelee à plusieurs reprises par le système d'exploitation, nous avons donc besoin de savoir où dans le fichier // On est un cycle de decharge de charge, donc on utilise une machine d'etat. void loop() { unsigned long now = millis(); // Obtenir la valeur actuelle de la minuterie en mS if (now - sampleDelay > SAMPLE_DELAY_MILLIS) { sampleDelay = now; // Reinitialiser l'heure de base de l'echantillonnage switch (currentState) // Aller à l'etat actuel { //---------------------------- case STATE_START: stateTimer = MAXSTATETIME; // Valeur de temporisation de l'etat de configuration currentState = STATE_CHARGING; // L'etat suivant est charge Serial.println("------------------------------------------------"); Serial.print("CYCLE CHARGING Cycle # "); Serial.println(numberCycles); Serial.println("------------------------------------------------"); Serial.println(); cycleTime = now; // Heure de debut d'etat // Serial.print("Cycle #"); // Logging // Serial.println(numberCycles); // TODO update display break; //---------------------------- case STATE_CHARGING: digitalWrite(RELAIS_RECHARGE, ON); // Activer le relais de charge cellVolts = readVoltage(); // Faire une lecture cellVolts2 = readVoltage2(); // Faire une lecture cellVolts3 = readVoltage3(); // Faire une lectur // MosfetCValue = MosfetCStart; // analogWrite(gatePinC, MosfetCValue); //ecrit la nouvelle valeur de sortie if(CibleCurrentCharge < currentMin) { CibleCurrentCharge = currentMin; } CurrentCharge = (cellVolts2 - cellVolts ) / resistance; //jeca calculer le courant de decharge // Serial.print("batteryCapacity: "); // // Serial.println(batteryCapacity); // Serial.println(); Serial.print("batterie (V): "); //afficher la tension de la batterie Serial.println(cellVolts/1000); Serial.print("Shunt Cible : "); Serial.println(CibleChargeShunt); Serial.print("Shunt (V): "); Serial.println(cellVolts2/1000); Serial.print("Charge Cible : "); Serial.println(CibleCurrentCharge); Serial.print("Charge (mA): "); //afficher le courant actuel Serial.println(CurrentCharge); Serial.println(); Serial.println(); lcd.clear(); lcd.setCursor(0,0); lcd.print(numberCycles); lcd.setCursor(4,0); lcd.print("Charge"); lcd.setCursor(11,0); lcd.print(cellVolts/1000); lcd.setCursor(15,0); lcd.print("V"); lcd.setCursor(0,1); lcd.print("Curent:"); lcd.setCursor(9,1); lcd.print(CurrentCharge); lcd.setCursor(14,1); lcd.print("mA"); //Corrections Intensite de charge if(cellVolts <V_floating) { CibleChargeShunt = (cellVolts/1000) + ((CibleCurrentCharge/1000) * resistance ); // if( ((CurrentCharge + (TolCurrent + 1)) <= CibleCurrentCharge ) && (ValuePot < SepstPot) ) //while { ValuePot = ValuePot + 1; setValuePot(ValuePot); Serial.print("Correction Charge + Pot: "); //afficher les valeurs de sortie pour la surveillance avec un ordinateur Serial.println(ValuePot); } if( ((CurrentCharge - (TolCurrent + 1)) >= CibleCurrentCharge ) && (ValuePot > 0) ) // { ValuePot = ValuePot - 1; setValuePot(ValuePot); Serial.print("Correction Charge - Pot: "); //afficher les valeurs de sortie pour la surveillance avec un ordinateur Serial.println(ValuePot); } } //info erreur if(ValuePot > SepstPot) //la sortie ne peut jamais depasser 255 { ValuePot = SepstPot; setValuePot(ValuePot); Serial.print("Erreur calcul Pot: "); //afficher les valeurs de sortie pour la surveillance avec un ordinateur Serial.println(); } // arrêt de charge > fin de charge if ( (cellVolts >= V_floating) && (CurrentCharge <= cutoffcurrent) ) { Serial.println("------------------------------------------------"); Serial.println("Fin de charge (Floating)"); digitalWrite(RELAIS_RECHARGE, OFF); // Desactive le relais de charge setValuePot(ValuePotStart); currentState = STATE_DISWAIT; // L'etat suivant est en attente avant la decharge Serial.println("------------------------------------------------"); Serial.println("CYCLE DISWAIT"); Serial.println("------------------------------------------------"); Serial.println(); Serial.print("MosfetD: "); //afficher les valeurs de sortie pour la surveillance avec un ordinateur Serial.println(MosfetDValue); Serial.print("MosfetDStart: "); //afficher les valeurs de sortie pour la surveillance avec un ordinateur Serial.println(MosfetDStart); Serial.print("MosfetDValue: "); //afficher les valeurs de sortie pour la surveillance avec un ordinateur Serial.println(MosfetDValue); Serial.println(); Serial.print("Capacite (mAh): "); //afficher Serial.println(mAh); Serial.print("Temps: "); //afficher Serial.println(previousMillis); delayTimer = RECOVERYTIME; // Interstate delay time Serial.print("Temps de charge: (S) "); // Logging Serial.println((now - cycleTime)/1000); Serial.println(); lcd.clear(); lcd.setCursor(0,0); lcd.print("Charge fini"); lcd.setCursor(0,1); lcd.print("Temps:"); lcd.setCursor(8,1); lcd.print((now - cycleTime)/1000); // TODO update display } // arrêt de charge >surcharge if(cellVolts >= VoltageChargeMaxi) //arrêter la charge { digitalWrite(RELAIS_RECHARGE, OFF); // Desactive le relais de charge setValuePot(ValuePotStart); Serial.println("------------------------------------------------"); Serial.print("Stop surcharge (VoltageChargeMaxi)"); Serial.println(); lcd.clear(); lcd.setCursor(0,1); lcd.print("Stop surcharge"); currentState = STATE_DISWAIT; // L'etat suivant est en attente avant la decharge } // arrêt de charge > trop longtemps if (--stateTimer <= 0) { digitalWrite(RELAIS_RECHARGE, OFF); // Desactive le relais de charge setValuePot(ValuePotStart); Serial.println("------------------------------------------------"); Serial.print("Temps de Charge maxi depasse"); Serial.println(); lcd.clear(); lcd.setCursor(0,0); lcd.print("Stop Charge"); lcd.setCursor(0,1); lcd.print("Temps maxi"); currentState = STATE_DISWAIT; // L'etat suivant est en attente avant la decharge Serial.println("CYCLE DISWAIT"); Serial.println(); // TODO update display } break; //---------------------------- case STATE_DISWAIT: if (--delayTimer <= 0) { digitalWrite(RELAIS_DISCHARGE, ON); // Activer le relais de decharge currentState = STATE_DISCHARGING; // L'etat suivant est decharge Serial.println("------------------------------------------------"); Serial.print("CYCLE DECHARGE Cycle # "); Serial.println(numberCycles); Serial.println("------------------------------------------------"); Serial.println(); stateTimer = MAXSTATETIME; // Valeur de temporisation de l'etat de configuration cycleTime = now; // Heure de debut d'etat } // TODO update display break; //---------------------------- case STATE_DISCHARGING: cellVolts = readVoltage(); // Faire une lecture cellVolts2 = readVoltage2(); // Faire une lecture MosfetDValue = MosfetDStart; analogWrite(gatePinD, MosfetDValue); //ecrit la nouvelle valeur de sortie CibleCurrentDISCHARGE = batteryCapacity / Speed_DISCHARGE; //c if(CibleCurrentDISCHARGE < currentMinD) {CibleCurrentDISCHARGE = currentMinD; } CurrentDischarge = (cellVolts - cellVolts2 ) / resistance; //jeca calculer le courant de decharge CurrentDischargerror = CibleCurrentDISCHARGE - CurrentDischarge; //jeca difference between target current and measured current millisPassed = millis() - previousMillis; // mAh = mAh + (CurrentDischarge * 1000.0) * (millisPassed / 3600000.0); mAh = mAh + (CurrentDischarge) * (millisPassed / 3600000.0); previousMillis = millis(); Serial.print("batterie(V):"); //afficher la tension de la batterie Serial.println(cellVolts/1000); Serial.print("Shunt (V):"); Serial.println(cellVolts2/1000); Serial.print("Mosfet: "); //afficher les valeurs de sortie pour la surveillance avec un ordinateur Serial.println(MosfetDValue); Serial.print("Decharge Cible: "); Serial.println(CibleCurrentDISCHARGE); Serial.print("Decharge( mA): "); //afficher le courant actuel Serial.println(CurrentDischarge); Serial.print("Capacite (mAh): "); //afficher Serial.println(mAh); // Serial.print("millisPassed: "); //afficher // Serial.println(millisPassed); // Serial.print("previousMillis: "); //afficher // Serial.println(previousMillis); Serial.println(); //des espaces supplementaires pour faciliter la lecture des donnees de debogage Serial.println(); lcd.clear(); lcd.setCursor(0,0); lcd.print(numberCycles); lcd.setCursor(4,0); lcd.print("Dech."); lcd.setCursor(11,0); lcd.print(cellVolts/1000); lcd.setCursor(15,0); lcd.print("V"); lcd.setCursor(0,1); lcd.print(mAh); lcd.setCursor(5,1); lcd.print("mAh"); lcd.setCursor(9,1); lcd.print(CurrentDischarge); lcd.setCursor(14,1); lcd.print("mA"); //Corrections Intensite de decharge if(cellVolts >= V_MIN) { if( ((CurrentDischarge + (TolCurrent + 1)) <= CibleCurrentDISCHARGE ) && (MosfetDValue < 255) ) // { MosfetDValue = MosfetDValue + 1; MosfetDStart = MosfetDValue; analogWrite(gatePinD, MosfetDValue); //ecrit la nouvelle valeur de sortie Serial.print("Correction decharge + Mosfet: "); //afficher les valeurs de sortie pour la surveillance avec un ordinateur Serial.println(MosfetDStart); } if( ((CurrentDischarge - (TolCurrent + 1)) >= CibleCurrentDISCHARGE ) && (MosfetDValue > 0) ) //while { MosfetDValue = MosfetDValue - 1; MosfetDStart = MosfetDValue; analogWrite(gatePinD, MosfetDValue); //ecrit la nouvelle valeur de sortie Serial.print("Correction decharge - Mosfet: "); //afficher les valeurs de sortie pour la surveillance avec un ordinateur Serial.println(MosfetDValue); } } //info erreur if(MosfetDValue > 255) //la sortie ne peut jamais depasser 255 { MosfetDValue = 255; analogWrite(gatePinD, MosfetDValue); //ecrit la nouvelle valeur de sortie Serial.print("Erreur calcul Mosfet: "); //afficher les valeurs de sortie pour la surveillance avec un ordinateur Serial.println(); } // arrêt de decharge > si l' intensite de decharge ateint le seuil mini de decharge if (cellVolts < V_MIN) { digitalWrite(RELAIS_DISCHARGE, OFF); // Desactive le relais de decharge MosfetDValue = 0; analogWrite(gatePinD, MosfetDValue); //ecrit la nouvelle valeur de sortie // MosfetDStart = MosfetDInit; Serial.print("MosfetD: "); //afficher les valeurs de sortie pour la surveillance avec un ordinateur Serial.println(MosfetDValue); currentState = STATE_CHGWAIT; // L'etat suivant est en attente avant la charge Serial.println("CYCLE CHGWAIT"); Serial.println(); delayTimer = RECOVERYTIME; // Inter state delay time > Temps de retard entre etats stateTimer = MAXSTATETIME; // Valeur de temporisation de l'etat de configuration Serial.println("------------------------------------------------"); Serial.print("Fin de decharge # "); Serial.println(numberCycles); Serial.println("------------------------------------------------"); Serial.print("Temps de decharge: (S) "); // Logg Serial.println((now - cycleTime)/1000); Serial.println(); Serial.print("MosfetD: "); //afficher les valeurs de sortie pour la surveillance avec un ordinateur Serial.println(MosfetDValue); Serial.print("MosfetDStart: "); //afficher les valeurs de sortie pour la surveillance avec un ordinateur Serial.println(MosfetDStart); Serial.print("MosfetDValue: "); //afficher les valeurs de sortie pour la surveillance avec un ordinateur Serial.println(MosfetDValue); Serial.println(); Serial.print("Capacite Cycle (mAh): "); //afficher Serial.println(mAh); Serial.println("-------------------------------------------------------------"); Serial.println("-------------------------------------------------------------"); // Serial.print("Temps: "); //afficher // Serial.println(millisPassed); lcd.clear(); lcd.setCursor(0,0); lcd.print("Decha. fini"); lcd.setCursor(0,1); lcd.print("Capa:"); lcd.setCursor(11,1); lcd.print(mAh); lcd.setCursor(14,1); lcd.print("mAh"); } if (--stateTimer <= 0) { digitalWrite(RELAIS_DISCHARGE, OFF); // Desactive le relais de decharge MosfetDValue = 0; analogWrite(gatePinD, MosfetDValue); //ecrit la nouvelle valeur de sortie Serial.print("Temps de Decharge maxi depasse"); Serial.println(); lcd.clear(); lcd.setCursor(0,0); lcd.print("Stop Decharge"); lcd.setCursor(0,1); lcd.print("Temps maxi"); Serial.print("MosfetD: "); //afficher les valeurs de sortie pour la surveillance avec un ordinateur Serial.println(MosfetDValue); currentState = STATE_DONE; // L'etat suivant est fait Serial.println("CYCLE DONE 2"); Serial.println(); } // TODO update display break; //---------------------------- case STATE_CHGWAIT: if (--delayTimer <= 0) { if (++numberCycles <= NUMBEROFCYCLES) { currentState = STATE_START; // L'etat suivant est configure pour charger Serial.println("------------------------------------------------"); Serial.println("CYCLE START"); Serial.println("------------------------------------------------"); Serial.println(); Serial.print("Capacite precedente: "); // Serial.println(batteryCapacity); batteryCapacity = mAh; mAh = 0; Serial.print("Nouvelle Capacite: "); // Serial.println(batteryCapacity); } else { digitalWrite(RELAIS_DISCHARGE, OFF); // Desactive le relais de decharge digitalWrite(RELAIS_RECHARGE, OFF); // Desactive le relais de charge currentState = STATE_DONE; // L'etat suivant est fait Serial.println("CYCLE DONE 3"); Serial.println(); MosfetDValue = 0; analogWrite(gatePinD, MosfetDValue); //ecrit la nouvelle valeur de sortie Serial.print("MosfetD: "); //afficher les valeurs de sortie pour la surveillance avec un ordinateur Serial.println(MosfetDValue); Serial.println("------------------------------------------------"); Serial.println("Cycles finished"); // Logging Serial.println("------------------------------------------------"); Serial.println(); } } // TODO update display break; case STATE_DONE: // TODO update display break; } } // delay(2000); //delay x/1000 secondes avant la prochaine iteration }
-BOTTOM CODE-

Immagine Allegata: Arduino_Planté_cell_cycle_tester_9.Jpg
 

attualizzazione

modifica della funzione di carica per avere un carico di corrente costante (CC), poi un carico di tensione costante (CV).
il tester è quasi pronto per la produzione.....

Immagine Allegata: Arduino_Planté_cell_cycle_tester_9b.Jpg
 

attualizzazione
aggiunta di "efficienza energetica" dei cicli.
Penso di aver integrato tutte le impostazioni e le funzioni possibilmente in questo test della batteria.
ovvero tutti i parametri che saranno utili per l'analisi di una batteria Planté in funzione della sua intera vita utile (compresa la formazione).

il passo successivo sarà la creazione automatica di curve di analisi (capacità, efficienza, ecc.)

ps:Vi ricordo anche che questo tester è anche un tester universale e può essere utilizzato senza modifiche per 18650 batterie.

complimenti vedo che vai avanti bello spedito!
Bravissimo!

grazie per il commento

anche se questo progetto non entusiasma la folla (o forse si sta nascondendo e aspettando il risultato finale.... ), continuo a dare tutto il mio lavoro.

e come mio primo Arduino, posso assicurarti che sto lottando parecchio.
un esempio dalla versione 34, ho avuto grossi bug alla minima modifica del codice e mi ci sono voluti 4 giorni per capire che i log di debug stavano travolgendo la mia memoria.

ora che tutto è stato risolto, posso passare alla creazione automatica delle curve di analisi.

ps:Ricordo inoltre che questo progetto, grazie alla sua totale libertà di funzioni e parametri, sarà lo strumento ideale per la formazione di batterie al piombo di tipo Planté.

Capi tranquillo che ti seguiamo!

Certo che ti seguiamo
bien sûr nous vous suivons

Ok, prometto che smettero' di lamentarmi....
e poi no.
un francese si lamenta e con 1/4 di italiano in più, sono un grande brontolone!