Cargador inteligente para baterías recargables NiMH de 9V V1

Código

• charger.ino
• main.ino
• hw.ino
• lcd.ino
• calculations.ino
• Nueva biblioteca LiquidCrystal utilizada para este proyecto

charger.ino Arduino

 // Esto es para cargar batería NiMH de 9V // La batería puede tener 6,7 u 8 celdas de 1.25V // Esto hace que el voltaje nominal entre 7.5 y 10V # incluya  #include  #include  #include  #include  LiquidCrystal_I2C lcd (0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVO); // establecer la dirección de LCD en 0x27 para una pantalla de 16 caracteres y 2 líneas // Defensas de hardware # definir MCP4725_ADDR 0x60 // Dirección DAC # definir DAC_REF_VOLTAGE 5.0 # definir CHARGE_RELAY_PIN 2 # definir DISCONNECT_CHARGE_RELAY HIGH # definir CONNECT_CHARGE_RELAY_SISTOW # definir A2 CURRENT_SENSING_SESISTOR 10.2 // OHm # define BATTERY_VOLTAGE_PIN A0 # define R1 5090 // Resistencia del lado bajo del divisor de detección de voltaje # define R2 19910 // Resistencia del lado alto del divisor de detección de voltaje # define ADC_REF_VOLTAGE 4.89 // Voltaje de suministro real de Arduino o voltaje AREF para el correcto ADC a traducción de voltaje # definir R3 3300.0 # definir R4 6800.0 # definir AMP_GAIN (1 + R4 / R3) // Varias definiciones // # definir MINIMUM_VOLTAGE 8.1 // Voltaje mínimo después del regulador # definir BATTERY_GOOD_VOLTAGE_THRESHOLD 7.0 # definir MAXIMIM_ALLOWED_CURRENT 200 // Máximo permitido corriente de la batería mA (corte duro) #define MAXIMUM_BATTERY_VOLTAGE 15.0 // Voltaje máximo permitido de la batería V (corte duro) #define VOLTAGE_STEP 0.001 // Paso para voltaje regulación # define POINTS_FOR_AVERAGING 100 // Cuántos puntos tomados para promediar # define MEASURE2MEASURE_US 5000 // Tiempo entre mediciones en microsegundos (necesita ser más de 200 debido a dos lecturas analógicas) #define VOLTAGE_LOG_TIME_MIN 30.0 // Tiempo en minutos para ahorrar voltaje para dV / dt de corte # define MINUTES_TO_LOG 5 # define TRICKLE_CURRENT_RATIO 40 // cargador Unidos # definen INICIALIZACIÓN 0 # definir NO_BATTERY 5 # define BATTERY_CONNECTED 10 # define BATTERY_VOLTAGE_LOW 15 # define CURRENT_RAMP_UP 20 # define CARGA 30 # define CURRENT_RAMP_DOWN 32 # define TRICKLE 35 # define END_OF_TRICKLE 37 # define UNEXPECTED_CURRENT_FALL 40 # define UNABLE_TO_REACH_CURRENT 60 # define FULLY_CHARGED 70 # define CURRENT_TOO_HIGH 80 # define REGULATION_FAILED 90 # define OVERCURRENT 100 # define OVERVOLTAGE 101 # define FINAL_STATEVERAG_CURRENT_INFORMA_de_información_inferior; // Para promediar int sin signo largo voltaje_sum, suma_corriente; // Suma de promediarf loat regulator_voltage_code, resistor_voltage, csr_voltage_code, regulator_voltage, current_mA, battery_voltage; // Measurmentsfloat tmp_resistor_voltage, tmp_current_mA, tmp_regulator_voltage, tmp_battery_voltage; int i, j, string_state_last_voltage, lcdtrcd, lcd, ltl, ltl, lt; lcd, lcd, ltl, ltl, ltimo, lcd; String msg, eoc_line1, eoc_line2; unsigned char sec_index, min_index; // long long int charge_started; float sec_log [60], min_log [MINUTES_TO_LOG], last_blf; float trickle_current_mA; int total_minutes_average =0; elapsedTimeMillis ChargingTime 0; float last_dac_voltage =0; // Messagesconst char msg_battery_detected [] PROGMEM ="Batería detectada"; const char msg_no_battery [] PROGMEM ="Sin batería"; const char msg_battery_ok [] PROGMEM ="Batería ok"; const char msglow_voltage_too_battery PROGMEM ="Voltaje de la batería demasiado bajo"; const char msg_voltage_too_low_short [] PROGMEM ="V Batería baja"; const char msg_ramp_up [] PROGM EM ="Ramp up"; const char msg_charging [] PROGMEM ="Charging"; const char msg_space [] PROGMEM =""; const char msg_ramp_down [] PROGMEM ="Ramp down"; const char msg_trickle_charge [] PROGMEM ="Carga lenta "; const char msg_no_current [] PROGMEM =" Sin corriente "; const char msg_current_unreachable [] PROGMEM =" I unreachable "; const char msg_current_unreachable_long [] PROGMEM =" No se puede alcanzar la corriente deseada "; const char msg_completed =" Completado PROGMEM "; const char msg_charge [] PROGMEM =" Carga "; const char msg_high_current [] PROGMEM =" Corriente alta "; const char msg_regulation_fault [] PROGMEM =" Fallo de regulación "; const char msg_overcurrent [] PROGMEM =" Corriente demasiado alta "; const char msg_overvoltage [] PROGMEM ="Voltaje demasiado alto"; const char msg_trickle_completed [] PROGMEM ="Goteo terminado"; // ********************** **** Parámetros de carga *************************************** // * *********************************************** ************************************* flotar target_current_mA =30; // Corriente de carga mAfloat battery_nominal_capacity_mA =170; // Capacidad nominal de la batería mAfloat max_time_for_trickle_charge =6; // Tiempo máximo de carga lenta en minutos // ************************************* *********************************************** / / ********************************************** *************************************** struct mytime {unsigned char hours; actas de caracteres sin firmar; unsigned int total_minutes;} transcurrido_time; void setup () {pinMode (CHARGE_RELAY_PIN, OUTPUT); desconectar_circuito_de_carga (); // Desconecte el cargador de la batería Wire.begin (); // I2C dac_write_voltage (0); // Asegúrese de que el conjunto de corriente sea más bajo posible Serial.begin (115200); último_segundo =segundo (); lcd_last_second =segundo (); log_last_second =segundo (); Timer1.initialize (MEASURE2MEASURE_US); // Se utilizará para medir el voltaje y la corriente de la batería (microsegundos) Timer1.attachInterrupt (read_hw); // adjunta read_hw () como una interrupción de desbordamiento del temporizador averaging_index =0; sec_index =0; índice_mín =0; charger_state =0; // Estado inicial de la máquina de estado want_dac_voltage =0; // Hacer que el voltaje mínimo salga last_blf =1.0; goteo_corriente_mA =batería_nominal_capacity_mA / TRICKLE_CURRENT_RATIO; // ChargingTimeMillis =0; // LCD lcd.begin (16,2); LCD luz de fondo(); lcd.clear (); update_lcd (F ("Encendido ..."), cadena_vacia); delay (1000);} float log_battery_voltage () {// Registrar solo una vez por segundo if (log_last_second ==second ()) return last_blf; más log_last_second =segundo (); sec_log [sec_index] =voltaje_batería; si (sec_index <59) {sec_index ++; } else {// Si se registra un minuto // Calcula el promedio por minuto if (min_index> =MINUTES_TO_LOG) min_index =0; sec_index =0; flotante sum_v =0; para (i =0; i <60; i ++) {sum_v + =sec_log [i]; } float min_average =sum_v / 60.0; para (i =1; i  
 main.ino  Arduino  
 
 bucle vacío () {String msg1; switch (charger_state) {case INICIALIZACIÓN:// Estado inicial desconectar_circuito_de_carga (); // Hacer que el relé shure esté desconectado dac_write_voltage (0); // Asegurarse de que el conjunto de corriente más bajo posible deseado_dac_voltage =0; // Hacer un retardo de salida de voltaje mínimo (100); read_status (); if (battery_voltage> 0.1) {charger_state =BATTERY_CONNECTED; // Batería detectada update_lcd (M2S (msg_battery_detected), empty_string); Serial.println (M2S (msg_battery_detected)); retraso (2000); } else {// Sin batería Serial.println (M2S (msg_no_battery)); update_lcd (M2S (msg_no_battery), construct_status_string ()); charger_state =NO_BATTERY; // Retardo de batería detectado (1000); } descanso; case NO_BATTERY:// Sin batería read_status (); if (battery_voltage> 0.1) {charger_state =BATTERY_CONNECTED; // Batería detectada Serial.println (M2S (msg_battery_detected)); update_lcd (M2S (msg_battery_detected), construct_status_string ()); retraso (1500); } else {// Si ninguna batería permanece en este estado update_lcd (M2S (msg_no_battery), construct_status_string ()); retraso (1100); } descanso; case BATTERY_CONNECTED:// Batería conectada dac_write_voltage (0); // Asegúrese de que el conjunto de corriente más bajo posible deseado_dac_voltage =0; retraso (100); read_status (); if (battery_voltage> BATTERY_GOOD_VOLTAGE_THRESHOLD) {charger_state =CURRENT_RAMP_UP; // Iniciar carga actual rampup // snprintf (welcome, sizeof (welcome), "Firmware:V% d.% d% d", ver, ver2, ver3); update_lcd (M2S (msg_battery_ok), construct_status_string ()); Serial.println (M2S (msg_battery_ok)); retraso (2000); want_dac_voltage =get_approximated_dac_voltage (battery_voltage); // Establecer el voltaje del regulador necesario //Serial.println(get_approximated_dac_voltage(battery_voltage)); connect_charging_circuit (); retraso (200); } else {charger_state =BATTERY_VOLTAGE_LOW; // Voltaje de la batería demasiado bajo Serial.println (M2S (msg_voltage_too_low)); update_lcd (M2S (msg_voltage_too_low_short), construct_status_string ()); retraso (1000); } descanso; case BATTERY_VOLTAGE_LOW:// Voltaje de la batería demasiado bajo update_lcd (M2S (msg_voltage_too_low_short), construct_status_string ()); Serial.println (M2S (msg_voltage_too_low)); charger_state =FINAL_STATE; // Detener la pausa; case CURRENT_RAMP_UP:/// Current rampup // if (current_mA <1.0) charger_state =40; // La corriente cayó inesperadamente read_status (); update_lcd (M2S (msg_ramp_up), construct_status_string ()); retraso (50); if (current_mA  MAXIMUM_BATTERY_VOLTAGE) charger_state =OVERVOLTAGE; // Sobretensión if (abs (current_mA-target_current_mA)> 0.2) {// Si la corriente se desvía del objetivo  0.01) quería_dac_voltaje =quería_dac_voltaje-VOLTAGE_STEP; else charger_state =CURRENT_TOO_HIGH; // Corriente demasiado alta, no se puede bajar}} if (abs (current_mA-target_current_mA)> 5) {// Error de regulación, diferencia demasiado alta charger_state =REGULATION_FAILED; // Error de regulación, diferencia demasiado alta} dac_write_voltage (voltaje_de_dac_de_seado); if (total_minutes_average  goteo_corriente_mA) {if (deseado_dac_voltaje> VOLTAGE_STEP) {deseado_dac_voltage =deseado_dac_voltage-VOLTAGE_STEP; dac_write_voltage (deseado_dac_voltage); } else charger_state =CURRENT_TOO_HIGH; // No se puede reducir la corriente a la tasa de goteo} else {charger_state =TRICKLE; // Cargando TrickleChargingTimeMillis =0; Serial.println (M2S (msg_trickle_charge)); } descanso; case TRICKLE:// Retardo de carga (200); read_status (); if (current_mA <0.2) charger_state =UNEXPECTED_CURRENT_FALL; // La corriente cayó inesperadamente if (battery_voltage> MAXIMUM_BATTERY_VOLTAGE) charger_state =OVERVOLTAGE; // Sobretensión if (abs (current_mA-trickle_current_mA)> 0.2_mA  0.01) quería_dac_voltaje =quería_dac_voltaje-VOLTAGE_STEP; else charger_state =CURRENT_TOO_HIGH; // Corriente demasiado alta, no se puede bajar}} if (abs (current_mA-trickle_current_mA)> 5) {// Error de regulación, diferencia demasiado alta charger_state =REGULATION_FAILED; // Error de regulación, diferencia demasiado alta} dac_write_voltage (voltaje_de_dac_de_seado); // if (total_minutes_average  max_time_for_trickle_charge) {// Carga de goteo máxima permitida update_lcd (eoc_line1, eoc_line2); cargador_state =END_OF_TRICKLE; // Detener desconectar_cargar_circuito (); // Desconecte el cargador de la batería} break; caso END_OF_TRICKLE:if ((segundo ()% 8) <4) update_lcd (M2S (msg_trickle_completed), construct_status_string ()); else update_lcd (eoc_line1, eoc_line2); descanso; case UNEXPECTED_CURRENT_FALL:// La corriente cayó inesperadamente Serial.println (F ("La corriente cayó inesperadamente")); desconectar_circuito_de_carga (); querido_dac_voltaje =0; update_lcd (M2S (msg_no_current), construct_status_string ()); charger_state =FINAL_STATE; // Detener el retraso (1000); descanso; case UNABLE_TO_REACH_CURRENT:// No se puede alcanzar el Serial.println actual deseado (M2S (msg_current_unreachable_long)); desconectar_circuito_de_carga (); querido_dac_voltaje =0; dac_write_voltage (deseado_dac_voltage); retraso (1000); update_lcd (M2S (msg_current_unreachable), construct_status_string ()); charger_state =FINAL_STATE; // Detener la pausa; case FULLY_CHARGED:// Tiempo transcurrido completamente cargado =mills2time (ChargingTimeMillis); int charge_mAh; charge_mAh =calcular_carga (ChargingTimeMillis); msg =Cadena (M2S (msg_completed) + M2S (msg_space) + construct_time_string (elapsed_time)); msg1 =Cadena (M2S (msg_carga) + M2S (msg_space) + Cadena (carga_mAh) + Cadena ("mAh")); eoc_line1 =msg; eoc_line2 =msg1; update_lcd (msg, msg1); Serial.println (msg); // desconectar_circuito_de_carga (); // Voltaje_dac_de_seado =0; // dac_write_voltage (quería_dac_voltage); retraso (3000); charger_state =CURRENT_RAMP_DOWN; // Detener la pausa; case CURRENT_TOO_HIGH:// Corriente demasiado alta Serial.println (F ("No se puede reducir la corriente al objetivo")); desconectar_circuito_de_carga (); querido_dac_voltaje =0; dac_write_voltage (0); update_lcd (M2S (msg_high_current), construct_status_string ()); retraso (1000); charger_state =FINAL_STATE; // Detener la pausa; case REGULATION_FAILED:// Error de regulación Serial.println (M2S (msg_regulation_fault)); desconectar_circuito_de_carga (); querido_dac_voltaje =0; dac_write_voltage (0); update_lcd (M2S (msg_regulation_fault), construct_status_string ()); retraso (1000); charger_state =FINAL_STATE; // Detener la pausa; case OVERCURRENT:// Sobrecorriente desconexión_carga_circuito (); Serial.println (M2S (msg_overcurrent)); querido_dac_voltaje =0; dac_write_voltage (deseado_dac_voltage); update_lcd (M2S (msg_overcurrent), construct_status_string ()); retraso (1000); charger_state =FINAL_STATE; // Detener la pausa; case OVERVOLTAGE:// Sobretensión desconectar_circuito_de_carga (); Serial.println (M2S (msg_overvoltage)); querido_dac_voltaje =0; dac_write_voltage (deseado_dac_voltage); update_lcd (M2S (msg_overvoltage), construct_status_string ()); retraso (1000); charger_state =FINAL_STATE; // Detener la pausa; case FINAL_STATE:// Detener retraso (10000); descanso; predeterminado:quería_dac_voltaje =0; estado_cargador =0; } //Serial.println(current_mA); //Serial.print("Current="); //Serial.print(current_mA); //Serial.println("mA "); //Serial.print("DAC voltage "); //Serial.println(dac_voltage); //Serial.print("Wanted DAC voltage "); //Serial.println(wanted_dac_voltage); //Serial.print(current_mA); //Serial.print (""); //Serial.print(dac_voltage); //Serial.print (""); read_status (); if (last_second! =second ()) {Serial.print (current_mA); Serial.print (","); //Serial.print(resistor_voltage); //Serial.print (","); //Serial.print(dac_voltage); //Serial.print (","); //Serial.print(regulator_voltage); //Serial.print (","); Serial.println (batería_voltaje); último_segundo =segundo (); }} 
 
 hw.ino  Arduino  
 
 float get_approximated_dac_voltage (float vbat) {// float offset_voltage =1.2 / R3 * (R3 + R4); float offset_voltage =1.2; flotador adc_voltage =(vbat-offset_voltage) /AMP_GAIN-0.5; if (adc_voltage <0) adc_voltage =0; return adc_voltage;} int voltage_to_code (voltaje de flotación) {int code =4095.0 / DAC_REF_VOLTAGE * voltage; código de retorno;} void dac_write (código int) {Wire.beginTransmission (MCP4725_ADDR); Wire.write (64); // cmd para actualizar el DAC Wire.write (código>> 4); // los 8 bits más significativos ... Wire.write ((código &15) <<4); // los 4 bits menos significativos ... Wire.endTransmission ();} void read_status () {voltage_sum =0; suma_actual =0; para (i =0; i  =PUNTOS_PARA_PROMEDIAR) índice_promedio =0; if (tmp_battery_voltage> MAXIMUM_BATTERY_VOLTAGE) {desconectar_circuito_de_carga (); // Desconecte el cargador de la batería charger_state =OVERVOLTAGE; } if (tmp_current_mA> MAXIMIM_ALLOWED_CURRENT) {desconectar_circuito_de_carga (); // Desconecte el cargador de la batería charger_state =OVERCURRENT; }} vacío desconectar_circuito_de_carga () {digitalWrite (CHARGE_RELAY_PIN, DISCONNECT_CHARGE_RELAY); // Desconecte el cargador de la batería} void connect_charging_circuit () {digitalWrite (CHARGE_RELAY_PIN, CONNECT_CHARGE_RELAY); // Conectar el cargador a la batería} // sec_index =0; // min_index =0; 
 
 lcd.ino  Arduino  
 
 void update_lcd (String first_line, String second_line) {//Serial.print("update_lcd "); //Serial.print(lcd_last_string2); //Serial.print (""); //Serial.println(second_line); if (lcd_last_string1! =first_line) {lcd.clear (); lcd.setCursor (0,0); lcd.print (primera_línea); lcd_last_string1 =primera_línea; lcd.setCursor (0,1); lcd.print (segunda_línea); lcd_last_string2 =second_line; } if (lcd_last_second! =second ()) {if (lcd_last_string2! =second_line) {lcd.setCursor (0,1); lcd.print (segunda_línea); lcd_last_string2 =second_line; }} lcd_last_second =second ();} String construct_status_string (void) {String v, i; if (voltaje_batería <10) v =String (voltaje_batería, 2); else v=String(battery_voltage, 1); if (current_mA<10) i=String(current_mA, 2); else i=String(current_mA, 1); //Serial.println(v); mytime elapsed; String msg,msg_time; //Serial.print(charging_started); //Serial.print(" "); //Serial.println(String(millis()-charging_started)); switch(charger_state){ case CHARGING:elapsed=mills2time(ChargingTimeMillis); descanso; case TRICKLE:elapsed=mills2time(TrickleChargingTimeMillis); descanso; } if (charger_state==CHARGING || charger_state==TRICKLE){ if (elapsed.total_minutes<10) msg_time=String(elapsed.total_minutes)+" "; else if (elapsed.total_minutes<100) msg_time=String(elapsed.total_minutes)+" "; else msg_time=String(elapsed.total_minutes); } switch(charger_state){ case CHARGING:msg=v+String(F("V "))+i+String(F("mA"))+" "+msg_time; descanso; case TRICKLE:msg=v+String(F("V "))+i+String(F("mA"))+" "+msg_time; descanso; default:msg=v+String(F("V "))+i+String(F("mA")); } msg.replace("-","");//Remove minus sign return msg;}String construct_time_string(mytime timeinfo){ String mystring=String(timeinfo.hours,DEC)+String(F(":"))+String(timeinfo.minutes,DEC); //return String(timeinfo.hours,DEC)+String(F(":"))+String(timeinfo.minutes,DEC); return mystring;}
 
calculations.inoArduino 
 
float best_linear_fit(float y[MINUTES_TO_LOG]){ float sx =0.0, sy =0.0, sxx =0.0, sxy =0.0; //int n =y.size(); for (i =0; i  
New LiquidCrystal library used for this projectArduino 
 
 Sin vista previa (solo descarga). 
  
 
   Esquemas     
  charger_AgK96zxw2T.zip
 

            


            

               BrewBench        
                Cómo realizar múltiples subprocesos en un Arduino (Tutorial de protothreading)