Battery detection not working on Heltec V3

[alligitor]

I probably should open this as an issue ....

I've been digging into the battery reporting on Heltec V3 boards.
Basically, RNode always reports a percentage of 0 where I know battery is charged.

I poked around a bit and figured I ask here, if people have some history on it, before I dig further.

I did some other troubleshooting and verified that values, if set properly, do get to the host.
I then I modified the following to use the existing message for sending direct reads of pin 1 (pin_vbat).

void kiss_indicate_battery() {
	#if MCU_VARIANT == MCU_ESP32 || MCU_VARIANT == MCU_NRF52
		serial_write(FEND);
		serial_write(CMD_STAT_BAT);
		//escaped_serial_write(battery_state);
		//escaped_serial_write((uint8_t)int(battery_percent));
		escaped_serial_write(analogRead(pin_vbat));
		escaped_serial_write(analogRead(pin_vbat)>>2);
		serial_write(FEND);
	#endif
}

This code uses the two bytes in CMD_STAT_BAT to send direct read from analyRead. I also shifted it over by 2 to see if any of the other 12 bits have values.
I verified that pin_vbat is 1, as it should be based on the schematic.

Based on my calculation, if the battery is there and functional, it should result in a ADC read of around 800-900 due to the voltage divider on the V3 board.

Based on my modified code, I would have expected the firmware to report some value other than 0 for state and voltage based on how I modified the code.

I get 0 and 0 on the host side.

Anybody have historical info on this?

Any thoughts on why analogRead is returning 0?

P.S.
I'm using my newly modified LoRaMon to look at KISS messages.

[alligitor]

To verify the logic that averages the readings, computes state and percentages, I pulled out the code and ran it on my X86 linux.
Seems like the logic works. It's the analogRead that returns 0.

#include <stdio.h>
#include <stdint.h>
#include <stdbool.h>

#define BOARD_HELTEC32_V3   323
#define BOARD_MODEL         BOARD_HELTEC32_V3    

#define MCU_ESP32 1
#define MCU_VARIANT MCU_ESP32


#if BOARD_MODEL == BOARD_HELTEC32_V3
  #define BAT_V_MIN       3.15
  #define BAT_V_MAX       4.3
  #define BAT_V_CHG       4.48
  #define BAT_V_FLOAT     4.33
  #define BAT_SAMPLES     7
  const uint8_t pin_vbat = 1;
  const uint8_t pin_ctrl = 37;
  float bat_p_samples[BAT_SAMPLES];
  float bat_v_samples[BAT_SAMPLES];
  uint8_t bat_samples_count = 0;
  int bat_discharging_samples = 0;
  int bat_charging_samples = 0;
  int bat_charged_samples = 0;
  bool bat_voltage_dropping = false;
  float bat_delay_v = 0;
  float bat_state_change_v = 0;
#endif


// from RNode_Firmware/Config.h
// Power management
#define BATTERY_STATE_UNKNOWN     0x00
#define BATTERY_STATE_DISCHARGING 0x01
#define BATTERY_STATE_CHARGING    0x02
#define BATTERY_STATE_CHARGED     0x03
bool battery_installed = false;
bool battery_indeterminate = false;
bool external_power = false;
bool battery_ready = false;
float battery_voltage = 0.0;
float battery_percent = 0.0;
uint8_t battery_state = 0x00;


uint32_t analogRead(int pin) {
    // return some pretent voltage
    float voltage = 3.9;
    float dividedVoltage = (100.0 * voltage) / (100.0 + 390.0);

    // recalculate with HELTEC V3's voltage divider
    uint32_t adcVal = (dividedVoltage * 4095) / 3.3;
    return adcVal;
}

void kiss_indicate_battery(void)
{
    printf("Battery State: %d, Battery Percent: %d\n", battery_state, (uint8_t)(battery_percent));
}

void measure_battery() {
    #if BOARD_MODEL == BOARD_RNODE_NG_21 || BOARD_MODEL == BOARD_LORA32_V2_1 || BOARD_MODEL == BOARD_HELTEC32_V3 || BOARD_MODEL == BOARD_TDECK || BOARD_MODEL == BOARD_T3S3 || BOARD_MODEL == BOARD_HELTEC_T114 || BOARD_MODEL == BOARD_TECHO
      battery_installed = true;
      battery_indeterminate = true;
  
      #if BOARD_MODEL == BOARD_HELTEC32_V3
        float battery_measurement = (float)(analogRead(pin_vbat)) * 0.0041;
      #elif BOARD_MODEL == BOARD_T3S3
        float battery_measurement = (float)(analogRead(pin_vbat)) / 4095.0*6.7828;
      #elif BOARD_MODEL == BOARD_HELTEC_T114
        float battery_measurement = (float)(analogRead(pin_vbat)) * 0.017165;
      #elif BOARD_MODEL == BOARD_TECHO
        float battery_measurement = (float)(analogRead(pin_vbat)) * 0.007067;
      #else
        float battery_measurement = (float)(analogRead(pin_vbat)) / 4095.0*7.26;
      #endif
  
      bat_v_samples[bat_samples_count%BAT_SAMPLES] = battery_measurement;
      bat_p_samples[bat_samples_count%BAT_SAMPLES] = ((battery_voltage-BAT_V_MIN) / (BAT_V_MAX-BAT_V_MIN))*100.0;
      
      bat_samples_count++;
      if (!battery_ready && bat_samples_count >= BAT_SAMPLES) {
        battery_ready = true;
      }
  
      if (battery_ready) {
  
        battery_percent = 0;
        for (uint8_t bi = 0; bi < BAT_SAMPLES; bi++) {
          battery_percent += bat_p_samples[bi];
        }
        battery_percent = battery_percent/BAT_SAMPLES;
        
        battery_voltage = 0;
        for (uint8_t bi = 0; bi < BAT_SAMPLES; bi++) {
          battery_voltage += bat_v_samples[bi];
        }
        battery_voltage = battery_voltage/BAT_SAMPLES;
        
        if (bat_delay_v == 0) bat_delay_v = battery_voltage;
        if (bat_state_change_v == 0) bat_state_change_v = battery_voltage;
        if (battery_percent > 100.0) battery_percent = 100.0;
        if (battery_percent < 0.0) battery_percent = 0.0;
  
        if (bat_samples_count%BAT_SAMPLES == 0) {
          float bat_delay_diff = bat_state_change_v-battery_voltage;
          if (bat_delay_diff < 0) { bat_delay_diff *= -1; }
  
          if (battery_voltage < bat_delay_v && battery_voltage < BAT_V_FLOAT) {
            if (bat_voltage_dropping == false) {
              if (bat_delay_diff > 0.008) {
                bat_voltage_dropping = true;
                bat_state_change_v = battery_voltage;
                // SerialBT.printf("STATE CHANGE to DISCHARGE at delta=%.3fv. State change v is now %.3fv.\n", bat_delay_diff, bat_state_change_v);
              }
            }
          } else {
            if (bat_voltage_dropping == true) {
              if (bat_delay_diff > 0.01) {
                bat_voltage_dropping = false;
                bat_state_change_v = battery_voltage;
                // SerialBT.printf("STATE CHANGE to CHARGE at delta=%.3fv. State change v is now %.3fv.\n", bat_delay_diff, bat_state_change_v);
              }
            }
          }
          bat_samples_count = 0;
          bat_delay_v = battery_voltage;
        }
  
        if (bat_voltage_dropping && battery_voltage < BAT_V_FLOAT) {
          battery_state = BATTERY_STATE_DISCHARGING;
        } else {
          if (battery_percent < 100.0) {
            battery_state = BATTERY_STATE_CHARGING;
          } else {
            battery_state = BATTERY_STATE_CHARGED;
          }
        }
  
        #if MCU_VARIANT == MCU_NRF52
          if (bt_state != BT_STATE_OFF) { blebas.write(battery_percent); }
        #endif
  
        // if (bt_state == BT_STATE_CONNECTED) {
        //   SerialBT.printf("Bus voltage %.3fv. Unfiltered %.3fv.", battery_voltage, bat_v_samples[BAT_SAMPLES-1]);
        //   if (bat_voltage_dropping) { SerialBT.printf(" Voltage is dropping. Percentage %.1f%%.", battery_percent); }
        //   else                      { SerialBT.printf(" Voltage is not dropping. Percentage %.1f%%.", battery_percent); }
        //   if (battery_state == BATTERY_STATE_DISCHARGING) { SerialBT.printf(" Battery discharging. delay_v %.3fv", bat_delay_v); }
        //   if (battery_state == BATTERY_STATE_CHARGING) { SerialBT.printf(" Battery charging. delay_v %.3fv", bat_delay_v); }
        //   if (battery_state == BATTERY_STATE_CHARGED) { SerialBT.print(" Battery is charged."); }
        //   SerialBT.print("\n");
        // }
      }
  
    #elif BOARD_MODEL == BOARD_TBEAM || BOARD_MODEL == BOARD_TBEAM_S_V1
      if (PMU) {
        float discharge_current = 0;
        float charge_current    = 0;
        float ext_voltage       = 0;
        float ext_current       = 0;
        if (PMU->getChipModel() == XPOWERS_AXP192) {
          discharge_current       = ((XPowersAXP192*)PMU)->getBattDischargeCurrent();
          charge_current          = ((XPowersAXP192*)PMU)->getBatteryChargeCurrent();
          battery_voltage         = PMU->getBattVoltage()/1000.0;
          // battery_percent         = PMU->getBattPercentage()*1.0;
          battery_installed       = PMU->isBatteryConnect();
          external_power          = PMU->isVbusIn();
          ext_voltage             = PMU->getVbusVoltage()/1000.0;
          ext_current             = ((XPowersAXP192*)PMU)->getVbusCurrent();
        }
        else if (PMU->getChipModel() == XPOWERS_AXP2101) {
          battery_voltage         = PMU->getBattVoltage()/1000.0;
          // battery_percent         = PMU->getBattPercentage()*1.0;
          battery_installed       = PMU->isBatteryConnect();
          external_power          = PMU->isVbusIn();
          ext_voltage             = PMU->getVbusVoltage()/1000.0;
        }
  
        if (battery_installed) {
          if (PMU->isCharging()) {
            battery_state = BATTERY_STATE_CHARGING;
            battery_percent = ((battery_voltage-BAT_V_MIN) / (BAT_V_MAX-BAT_V_MIN))*100.0;
          } else {
            if (PMU->isDischarge()) {
              battery_state = BATTERY_STATE_DISCHARGING;
              battery_percent = ((battery_voltage-BAT_V_MIN) / (BAT_V_MAX-BAT_V_MIN))*100.0;
            } else {
              battery_state = BATTERY_STATE_CHARGED;
              battery_percent = 100.0;
            }
          }
        } else {
          battery_state = BATTERY_STATE_UNKNOWN;
          battery_percent = 0.0;
          battery_voltage = 0.0;
        }
  
        if (battery_percent > 100.0) battery_percent = 100.0;
        if (battery_percent < 0.0) battery_percent = 0.0;
  
        float charge_watts    = battery_voltage*(charge_current/1000.0);
        float discharge_watts = battery_voltage*(discharge_current/1000.0);
        float ext_watts       = ext_voltage*(ext_current/1000.0);
  
        battery_ready = true;
  
        // if (bt_state == BT_STATE_CONNECTED) {
        //   if (battery_installed) {
        //     if (external_power) {
        //       SerialBT.printf("External power connected, drawing %.2fw, %.1fmA at %.1fV\n", ext_watts, ext_current, ext_voltage);
        //     } else {
        //       SerialBT.println("Running on battery");
        //     }
        //     SerialBT.printf("Battery percentage %.1f%%\n", battery_percent);
        //     SerialBT.printf("Battery voltage %.2fv\n", battery_voltage);
        //     // SerialBT.printf("Temperature %.1f%\n", auxillary_temperature);
  
        //     if (battery_state == BATTERY_STATE_CHARGING) {
        //       SerialBT.printf("Charging with %.2fw, %.1fmA at %.1fV\n", charge_watts, charge_current, battery_voltage);
        //     } else if (battery_state == BATTERY_STATE_DISCHARGING) {
        //       SerialBT.printf("Discharging at %.2fw, %.1fmA at %.1fV\n", discharge_watts, discharge_current, battery_voltage);
        //     } else if (battery_state == BATTERY_STATE_CHARGED) {
        //       SerialBT.printf("Battery charged\n");
        //     }
        //   } else {
        //     SerialBT.println("No battery installed");
        //   }
        //   SerialBT.println("");
        // }
      }
      else {
        battery_ready = false;
      }
    #endif
  
    if (battery_ready) {
        kiss_indicate_battery();
      }
  }
  

  void main(void)
  {
    while(1) {
        measure_battery();
    }
  }

[alligitor]

I'm starting to answer my own question. It seems like Heltec has made a change to the schematic. Not all V3s are the same.

Schematics:
https://resource.heltec.cn/download/WiFi_LoRa_32_V3

Schematic for V3

Schematic for V3.1

Schematic for V3.2

The function of ADC control seems active low for V3 and V3.1.
I think it has to be active high for V3.2.

Now, have to figure out how to tell part what version the code is running on

[markqvist]

Yes, I added battery support and some other things after merging. It's working on V3 and V3.1, so it's probably down to the circuitry changes in v3.2. Nice detective work!

[alligitor]

Nice work, I have not tested battery myself and the initial submission for Heltec V3 didn't have the battery code. I recall that Mark probably added it when he merged. But it may not be tested against V3.1 or 3.2. What kind of battery did you use?

To answer the battery question:
The Kits I bought are these:
https://www.amazon.com/ESP32-Development-1100mAh-Battery-Protect/dp/B0DP6BNZ4M

I also bought some batteries separately, which are these:
https://www.amazon.com/dp/B0D7MC714N

Advertised as 1100mAH. Charged voltage: 4.2 discharged voltage 3.

[alligitor]

Yes, I added battery support and some other things after merging. It's working on V3 and V3.1, so it's probably down to the circuitry changes in v3.2. Nice detective work!

@markqvist , will the two merge requests I made for RNode_Firmware be merged? I wasn't sure exactly what your process is. I went ahead and made the changes on my repo's branch and created the pull request.

[markqvist]

That's cool. I'll look at it as soon as I have time, but I am a bit tied up right now. I usually review and merge it all in when I am about to prepare a new release anyways, so unless you are in a super rush to get this out everywhere, that is what I'll do :)

[alligitor]

No rush at all. Honestly, I was just asking to make sure these PRs are helpful to the project and I;m not wasting peoples time.