Умное зарядное устройство для 9В NiMH аккумуляторов — точное, надежное, версия 1

main.ino (автомат состояний)

void loop() {
  String msg1;
  switch(charger_state) {
    case INITIALIZATION:
      disconnect_charging_circuit(); dac_write_voltage(0); wanted_dac_voltage = 0; delay(100);
      read_status();
      if (battery_voltage > 0.1) {
        charger_state = BATTERY_CONNECTED;
        update_lcd(F("Battery detected"), ""); Serial.println(F("Battery detected")); delay(2000);
      } else {
        Serial.println(F("No battery"));
        update_lcd(F("No battery"), construct_status_string());
        charger_state = NO_BATTERY; delay(1000);
      }
      break;
    case NO_BATTERY:
      read_status();
      if (battery_voltage > 0.1) {
        charger_state = BATTERY_CONNECTED;
        Serial.println(F("Battery detected"));
        update_lcd(F("Battery detected"), construct_status_string()); delay(1500);
      } else {
        update_lcd(F("No battery"), construct_status_string()); delay(1100);
      }
      break;
    case BATTERY_CONNECTED:
      dac_write_voltage(0); wanted_dac_voltage = 0; delay(100);
      read_status();
      if (battery_voltage > BATTERY_GOOD_VOLTAGE_THRESHOLD) {
        charger_state = CURRENT_RAMP_UP;
        update_lcd(F("Battery ok"), construct_status_string()); Serial.println(F("Battery ok")); delay(2000);
        wanted_dac_voltage = get_approximated_dac_voltage(battery_voltage);
        connect_charging_circuit(); delay(200);
      } else {
        charger_state = BATTERY_VOLTAGE_LOW;
        Serial.println(F("Battery voltage too low"));
        update_lcd(F("V Battery low"), construct_status_string()); delay(1000);
      }
      break;
    case BATTERY_VOLTAGE_LOW:
      update_lcd(F("V Battery low"), construct_status_string());
      Serial.println(F("Battery voltage too low"));
      charger_state = FINAL_STATE; break;
    case CURRENT_RAMP_UP:
      read_status(); update_lcd(F("Ramp up"), construct_status_string()); delay(50);
      if (current_mA < target_current_mA) {
        if (wanted_dac_voltage < 4.99) { wanted_dac_voltage += VOLTAGE_STEP; dac_write_voltage(wanted_dac_voltage); }
        else charger_state = UNABLE_TO_REACH_CURRENT;
      } else {
        charger_state = CHARGING; ChargingTimeMillis = 0;
      }
      break;
    case CHARGING:
      delay(200); read_status();
      if (current_mA < 1.0) charger_state = UNEXPECTED_CURRENT_FALL;
      if (battery_voltage > MAXIMUM_BATTERY_VOLTAGE) charger_state = OVERVOLTAGE;
      if (abs(current_mA - target_current_mA) > 0.2) {
        if (current_mA < target_current_mA) {
          if (wanted_dac_voltage < 4.99) wanted_dac_voltage += VOLTAGE_STEP;
          else charger_state = UNABLE_TO_REACH_CURRENT;
        } else {
          if (wanted_dac_voltage > 0.01) wanted_dac_voltage -= VOLTAGE_STEP;
          else charger_state = CURRENT_TOO_HIGH;
        }
      }
      if (abs(current_mA - target_current_mA) > 5) charger_state = REGULATION_FAILED;
      dac_write_voltage(wanted_dac_voltage);
      if (total_minutes_average < MINUTES_TO_LOG) msg = String(F("Charging ")) + "---";
      else msg = String(F("Charging ")) + String(last_blf, 3);
      update_lcd(msg, construct_status_string());
      log_battery_voltage();
      if (last_blf < 0) charger_state = FULLY_CHARGED;
      break;
    case CURRENT_RAMP_DOWN:
      read_status(); update_lcd(F("Ramp down"), construct_status_string()); Serial.println(F("Ramp down")); delay(50);
      if (current_mA > trickle_current_mA) {
        if (wanted_dac_voltage > VOLTAGE_STEP) { wanted_dac_voltage -= VOLTAGE_STEP; dac_write_voltage(wanted_dac_voltage); }
        else charger_state = CURRENT_TOO_HIGH;
      } else {
        charger_state = TRICKLE; TrickleChargingTimeMillis = 0; Serial.println(F("Trickle charge"));
      }
      break;
    case TRICKLE:
      delay(200); read_status();
      if (current_mA < 0.2) charger_state = UNEXPECTED_CURRENT_FALL;
      if (battery_voltage > MAXIMUM_BATTERY_VOLTAGE) charger_state = OVERVOLTAGE;
      if (abs(current_mA - trickle_current_mA) > 0.2) {
        if (current_mA < trickle_current_mA) {
          if (wanted_dac_voltage < 4.99) wanted_dac_voltage += VOLTAGE_STEP;
          else charger_state = UNABLE_TO_REACH_CURRENT;
        } else {
          if (wanted_dac_voltage > 0.01) wanted_dac_voltage -= VOLTAGE_STEP;
          else charger_state = CURRENT_TOO_HIGH;
        }
      }
      if (abs(current_mA - trickle_current_mA) > 5) charger_state = REGULATION_FAILED;
      dac_write_voltage(wanted_dac_voltage);
      if ((second() % 8) < 4) update_lcd(F("Trickle charge"), construct_status_string());
      else update_lcd(eoc_line1, eoc_line2);
      elapsed_time = mills2time(TrickleChargingTimeMillis);
      if (elapsed_time.total_minutes > max_time_for_trickle_charge) {
        update_lcd(eoc_line1, eoc_line2);
        charger_state = END_OF_TRICKLE;
        disconnect_charging_circuit();
      }
      break;
    case END_OF_TRICKLE:
      if ((second() % 8) < 4) update_lcd(F("Trickle finished"), construct_status_string());
      else update_lcd(eoc_line1, eoc_line2);
      break;
    case UNEXPECTED_CURRENT_FALL:
      Serial.println(F("Current unexpectedly fell"));
      disconnect_charging_circuit(); wanted_dac_voltage = 0;
      update_lcd(F("No current"), construct_status_string());
      charger_state = FINAL_STATE; delay(1000); break;
    case UNABLE_TO_REACH_CURRENT:
      Serial.println(F("Unable to reach desired current"));
      disconnect_charging_circuit(); wanted_dac_voltage = 0; dac_write_voltage(0); delay(1000);
      update_lcd(F("I unreachable"), construct_status_string());
      charger_state = FINAL_STATE; break;
    case FULLY_CHARGED:
      elapsed_time = mills2time(ChargingTimeMillis);
      int charge_mAh = calculate_charge(ChargingTimeMillis);
      msg = String(F("Completed ")) + construct_time_string(elapsed_time);
      msg1 = String(F("Charge ")) + String(charge_mAh) + "mAh";
      eoc_line1 = msg; eoc_line2 = msg1;
      update_lcd(msg, msg1); Serial.println(msg); delay(3000);
      charger_state = CURRENT_RAMP_DOWN; break;
    case CURRENT_TOO_HIGH:
      Serial.println(F("Unable to lower current to target"));
      disconnect_charging_circuit(); wanted_dac_voltage = 0; dac_write_voltage(0);
      update_lcd(F("High current"), construct_status_string()); delay(1000);
      charger_state = FINAL_STATE; break;
    case REGULATION_FAILED:
      Serial.println(F("Regulation fault"));
      disconnect_charging_circuit(); wanted_dac_voltage = 0; dac_write_voltage(0);
      update_lcd(F("Regulation fault"), construct_status_string()); delay(1000);
      charger_state = FINAL_STATE; break;
    case OVERCURRENT:
      disconnect_charging_circuit(); Serial.println(F("Current too high"));
      wanted_dac_voltage = 0; dac_write_voltage(wanted_dac_voltage);
      update_lcd(F("Current too high"), construct_status_string()); delay(1000);
      charger_state = FINAL_STATE; break;
    case OVERVOLTAGE:
      disconnect_charging_circuit(); Serial.println(F("Voltage too high"));
      wanted_dac_voltage = 0; dac_write_voltage(wanted_dac_voltage);
      update_lcd(F("Voltage too high"), construct_status_string()); delay(1000);
      charger_state = FINAL_STATE; break;
    case FINAL_STATE: delay(10000); break;
    default: wanted_dac_voltage = 0; charger_state = 0;
  }
  read_status();
  if (last_second != second()) {
    Serial.print(current_mA); Serial.print(","); Serial.println(battery_voltage);
    last_second = second();
  }
}

hw.ino (работа с железом)

float get_approximated_dac_voltage(float vbat) {
  float offset_voltage = 1.2;
  float adc_voltage = (vbat - offset_voltage) / AMP_GAIN - 0.5;
  if (adc_voltage < 0) adc_voltage = 0;
  return adc_voltage;
}

int voltage_to_code(float voltage) { return 4095.0 / DAC_REF_VOLTAGE * voltage; }

void dac_write(int code) {
  Wire.beginTransmission(MCP4725_ADDR);
  Wire.write(64); Wire.write(code >> 4); Wire.write((code & 15) << 4);
  Wire.endTransmission();
}

void read_status() {
  voltage_sum = 0; current_sum = 0;
  for (int i=0; i= POINTS_FOR_AVERAGING) averaging_index = 0;
  if (tmp_battery_voltage > MAXIMUM_BATTERY_VOLTAGE) { disconnect_charging_circuit(); charger_state = OVERVOLTAGE; }
  if (tmp_current_mA > MAXIMIM_ALLOWED_CURRENT) { disconnect_charging_circuit(); charger_state = OVERCURRENT; }
}

void disconnect_charging_circuit() { digitalWrite(CHARGE_RELAY_PIN, DISCONNECT_CHARGE_RELAY); }
void connect_charging_circuit() { digitalWrite(CHARGE_RELAY_PIN, CONNECT_CHARGE_RELAY); }

lcd.ino (дисплей)

void update_lcd(String first_line, String second_line) {
  if (lcd_last_string1 != first_line) {
    lcd.clear(); lcd.setCursor(0,0); lcd.print(first_line); lcd_last_string1 = first_line;
    lcd.setCursor(0,1); lcd.print(second_line); lcd_last_string2 = second_line;
  }
  if (lcd_last_second != second()) {
    if (lcd_last_string2 != second_line) {
      lcd.setCursor(0,1); lcd.print(second_line); lcd_last_string2 = second_line;
    }
  }
  lcd_last_second = second();
}

String construct_status_string() {
  String v = (battery_voltage < 10) ? String(battery_voltage, 2) : String(battery_voltage, 1);
  String i = (current_mA < 10) ? String(current_mA, 2) : String(current_mA, 1);
  mytime elapsed; String msg, msg_time;
  switch(charger_state) {
    case CHARGING: elapsed = mills2time(ChargingTimeMillis); break;
    case TRICKLE: elapsed = mills2time(TrickleChargingTimeMillis); break;
  }
  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 + "V " + i + "mA " + msg_time; break;
    case TRICKLE: msg = v + "V " + i + "mA " + msg_time; break;
    default: msg = v + "V " + i + "mA";
  }
  msg.replace("-", "");
  return msg;
}

String construct_time_string(mytime t) {
  return String(t.hours) + ":" + (t.minutes < 10 ? "0" : "") + String(t.minutes);
}

calculations.ino (математика)

float best_linear_fit(float y[MINUTES_TO_LOG]) {
  float sx=0, sy=0, sxx=0, sxy=0;
  for (int i=0; i

Библиотека New LiquidCrystal

Требуется для YwRobot I2C LCD. Скачать и установить в Arduino IDE.

Схемы

charger_AgK96zxw2T.zip (файл схемы)

BrewBench: набор для мониторинга температуры на Arduino и ESP32 Мастер-класс по многопоточности Arduino с протопотоками: пошаговое руководство