mirror of https://github.com/arendst/Tasmota.git
using Berry driver
This commit is contained in:
Jason2866
GitHub
parent
c5a57f0174
commit
39a0c67d06
|
|
@ -1,614 +0,0 @@
|
|||
#include "AXP192.h"
|
||||
|
||||
//#define AXP192_DEBUG
|
||||
|
||||
AXP192::AXP192()
|
||||
{
|
||||
}
|
||||
|
||||
void AXP192::begin(void)
|
||||
{
|
||||
|
||||
Wire1.begin(21, 22);
|
||||
Wire1.setClock(400000);
|
||||
|
||||
//AXP192 30H
|
||||
Write1Byte(0x30, (Read8bit(0x30) & 0x04) | 0X02);
|
||||
#ifdef AXP192_DEBUG
|
||||
Serial.printf("axp: vbus limit off\n");
|
||||
#endif
|
||||
|
||||
//AXP192 GPIO1:OD OUTPUT
|
||||
Write1Byte(0x92, Read8bit(0x92) & 0xf8);
|
||||
#ifdef AXP192_DEBUG
|
||||
Serial.printf("axp: gpio1 init\n");
|
||||
#endif
|
||||
//AXP192 GPIO2:OD OUTPUT
|
||||
Write1Byte(0x93, Read8bit(0x93) & 0xf8);
|
||||
#ifdef AXP192_DEBUG
|
||||
Serial.printf("axp: gpio2 init\n");
|
||||
#endif
|
||||
//AXP192 RTC CHG
|
||||
Write1Byte(0x35, (Read8bit(0x35) & 0x1c) | 0xa2);
|
||||
#ifdef AXP192_DEBUG
|
||||
Serial.printf("axp: rtc battery charging enabled\n");
|
||||
#endif
|
||||
SetESPVoltage(3350);
|
||||
#ifdef AXP192_DEBUG
|
||||
Serial.printf("axp: esp32 power voltage was set to 3.35v\n");
|
||||
#endif
|
||||
SetLcdVoltage(2800);
|
||||
#ifdef AXP192_DEBUG
|
||||
Serial.printf("axp: lcd backlight voltage was set to 2.80v\n");
|
||||
#endif
|
||||
SetLDOVoltage(2, 3300); //Periph power voltage preset (LCD_logic, SD card)
|
||||
#ifdef AXP192_DEBUG
|
||||
Serial.printf("axp: lcd logic and sdcard voltage preset to 3.3v\n");
|
||||
#endif
|
||||
SetLDOVoltage(3, 2000); //Vibrator power voltage preset
|
||||
#ifdef AXP192_DEBUG
|
||||
Serial.printf("axp: vibrator voltage preset to 2v\n");
|
||||
#endif
|
||||
|
||||
SetLDOEnable(2, true);
|
||||
SetDCDC3(true); // LCD backlight
|
||||
SetLed(true);
|
||||
|
||||
SetCHGCurrent(kCHG_100mA);
|
||||
//SetAxpPriphPower(1);
|
||||
//Serial.printf("axp: lcd_logic and sdcard power enabled\n\n");
|
||||
|
||||
//pinMode(39, INPUT_PULLUP);
|
||||
|
||||
//AXP192 GPIO4
|
||||
Write1Byte(0X95, (Read8bit(0x95) & 0x72) | 0X84);
|
||||
|
||||
Write1Byte(0X36, 0X4C);
|
||||
|
||||
Write1Byte(0x82,0xff);
|
||||
|
||||
SetLCDRSet(0);
|
||||
delay(100);
|
||||
SetLCDRSet(1);
|
||||
delay(100);
|
||||
// I2C_WriteByteDataAt(0X15,0XFE,0XFF);
|
||||
|
||||
// bus power mode_output
|
||||
SetBusPowerMode(0);
|
||||
}
|
||||
|
||||
void AXP192::Write1Byte(uint8_t Addr, uint8_t Data)
|
||||
{
|
||||
Wire1.beginTransmission(0x34);
|
||||
Wire1.write(Addr);
|
||||
Wire1.write(Data);
|
||||
Wire1.endTransmission();
|
||||
}
|
||||
|
||||
uint8_t AXP192::Read8bit(uint8_t Addr)
|
||||
{
|
||||
Wire1.beginTransmission(0x34);
|
||||
Wire1.write(Addr);
|
||||
Wire1.endTransmission();
|
||||
Wire1.requestFrom(0x34, 1);
|
||||
return Wire1.read();
|
||||
}
|
||||
|
||||
uint16_t AXP192::Read12Bit(uint8_t Addr)
|
||||
{
|
||||
uint16_t Data = 0;
|
||||
uint8_t buf[2];
|
||||
ReadBuff(Addr, 2, buf);
|
||||
Data = ((buf[0] << 4) + buf[1]); //
|
||||
return Data;
|
||||
}
|
||||
|
||||
uint16_t AXP192::Read13Bit(uint8_t Addr)
|
||||
{
|
||||
uint16_t Data = 0;
|
||||
uint8_t buf[2];
|
||||
ReadBuff(Addr, 2, buf);
|
||||
Data = ((buf[0] << 5) + buf[1]); //
|
||||
return Data;
|
||||
}
|
||||
|
||||
uint16_t AXP192::Read16bit(uint8_t Addr)
|
||||
{
|
||||
uint16_t ReData = 0;
|
||||
Wire1.beginTransmission(0x34);
|
||||
Wire1.write(Addr);
|
||||
Wire1.endTransmission();
|
||||
Wire1.requestFrom(0x34, 2);
|
||||
for (int i = 0; i < 2; i++)
|
||||
{
|
||||
ReData <<= 8;
|
||||
ReData |= Wire1.read();
|
||||
}
|
||||
return ReData;
|
||||
}
|
||||
|
||||
uint32_t AXP192::Read24bit(uint8_t Addr)
|
||||
{
|
||||
uint32_t ReData = 0;
|
||||
Wire1.beginTransmission(0x34);
|
||||
Wire1.write(Addr);
|
||||
Wire1.endTransmission();
|
||||
Wire1.requestFrom(0x34, 3);
|
||||
for (int i = 0; i < 3; i++)
|
||||
{
|
||||
ReData <<= 8;
|
||||
ReData |= Wire1.read();
|
||||
}
|
||||
return ReData;
|
||||
}
|
||||
|
||||
uint32_t AXP192::Read32bit(uint8_t Addr)
|
||||
{
|
||||
uint32_t ReData = 0;
|
||||
Wire1.beginTransmission(0x34);
|
||||
Wire1.write(Addr);
|
||||
Wire1.endTransmission();
|
||||
Wire1.requestFrom(0x34, 2);
|
||||
for (int i = 0; i < 4; i++)
|
||||
{
|
||||
ReData <<= 8;
|
||||
ReData |= Wire1.read();
|
||||
}
|
||||
return ReData;
|
||||
}
|
||||
|
||||
void AXP192::ReadBuff(uint8_t Addr, uint8_t Size, uint8_t *Buff)
|
||||
{
|
||||
Wire1.beginTransmission(0x34);
|
||||
Wire1.write(Addr);
|
||||
Wire1.endTransmission();
|
||||
Wire1.requestFrom(0x34, (int)Size);
|
||||
for (int i = 0; i < Size; i++)
|
||||
{
|
||||
*(Buff + i) = Wire1.read();
|
||||
}
|
||||
}
|
||||
|
||||
void AXP192::ScreenBreath(uint8_t brightness)
|
||||
{
|
||||
if (brightness > 12)
|
||||
{
|
||||
brightness = 12;
|
||||
}
|
||||
uint8_t buf = Read8bit(0x28);
|
||||
Write1Byte(0x28, ((buf & 0x0f) | (brightness << 4)));
|
||||
}
|
||||
|
||||
bool AXP192::GetBatState()
|
||||
{
|
||||
if (Read8bit(0x01) | 0x20)
|
||||
return true;
|
||||
else
|
||||
return false;
|
||||
}
|
||||
//---------coulombcounter_from_here---------
|
||||
//enable: void EnableCoulombcounter(void);
|
||||
//disable: void DisableCOulombcounter(void);
|
||||
//stop: void StopCoulombcounter(void);
|
||||
//clear: void ClearCoulombcounter(void);
|
||||
//get charge data: uint32_t GetCoulombchargeData(void);
|
||||
//get discharge data: uint32_t GetCoulombdischargeData(void);
|
||||
//get coulomb val affter calculation: float GetCoulombData(void);
|
||||
//------------------------------------------
|
||||
void AXP192::EnableCoulombcounter(void)
|
||||
{
|
||||
Write1Byte(0xB8, 0x80);
|
||||
}
|
||||
|
||||
void AXP192::DisableCoulombcounter(void)
|
||||
{
|
||||
Write1Byte(0xB8, 0x00);
|
||||
}
|
||||
|
||||
void AXP192::StopCoulombcounter(void)
|
||||
{
|
||||
Write1Byte(0xB8, 0xC0);
|
||||
}
|
||||
|
||||
void AXP192::ClearCoulombcounter(void)
|
||||
{
|
||||
Write1Byte(0xB8, 0xA0);
|
||||
}
|
||||
|
||||
uint32_t AXP192::GetCoulombchargeData(void)
|
||||
{
|
||||
return Read32bit(0xB0);
|
||||
}
|
||||
|
||||
uint32_t AXP192::GetCoulombdischargeData(void)
|
||||
{
|
||||
return Read32bit(0xB4);
|
||||
}
|
||||
|
||||
float AXP192::GetCoulombData(void)
|
||||
{
|
||||
|
||||
uint32_t coin = 0;
|
||||
uint32_t coout = 0;
|
||||
|
||||
coin = GetCoulombchargeData();
|
||||
coout = GetCoulombdischargeData();
|
||||
|
||||
//c = 65536 * current_LSB * (coin - coout) / 3600 / ADC rate
|
||||
//Adc rate can be read from 84H ,change this variable if you change the ADC reate
|
||||
float ccc = 65536 * 0.5 * (coin - coout) / 3600.0 / 25.0;
|
||||
return ccc;
|
||||
}
|
||||
|
||||
// Cut all power, except for LDO1 (RTC)
|
||||
void AXP192::PowerOff(void)
|
||||
{
|
||||
Write1Byte(0x32, Read8bit(0x32) | 0b10000000);
|
||||
}
|
||||
|
||||
void AXP192::SetAdcState(bool state)
|
||||
{
|
||||
// Enable / Disable all ADCs
|
||||
Write1Byte(0x82, state ? 0xff : 0x00);
|
||||
}
|
||||
|
||||
void AXP192::PrepareToSleep(void)
|
||||
{
|
||||
// Disable ADCs
|
||||
SetAdcState(false);
|
||||
|
||||
// Turn LED off
|
||||
SetLed(false);
|
||||
|
||||
// Turn LCD backlight off
|
||||
SetDCDC3(false);
|
||||
}
|
||||
|
||||
void AXP192::RestoreFromLightSleep(void)
|
||||
{
|
||||
// Turn LCD backlight on
|
||||
SetDCDC3(true);
|
||||
|
||||
// Turn LED on
|
||||
SetLed(true);
|
||||
|
||||
// Enable ADCs
|
||||
SetAdcState(true);
|
||||
}
|
||||
|
||||
uint8_t AXP192::GetWarningLeve(void)
|
||||
{
|
||||
Wire1.beginTransmission(0x34);
|
||||
Wire1.write(0x47);
|
||||
Wire1.endTransmission();
|
||||
Wire1.requestFrom(0x34, 1);
|
||||
uint8_t buf = Wire1.read();
|
||||
return (buf & 0x01);
|
||||
}
|
||||
|
||||
// -- sleep
|
||||
void AXP192::DeepSleep(uint64_t time_in_us)
|
||||
{
|
||||
PrepareToSleep();
|
||||
|
||||
if (time_in_us > 0)
|
||||
{
|
||||
esp_sleep_enable_timer_wakeup(time_in_us);
|
||||
}
|
||||
else
|
||||
{
|
||||
esp_sleep_disable_wakeup_source(ESP_SLEEP_WAKEUP_TIMER);
|
||||
}
|
||||
(time_in_us == 0) ? esp_deep_sleep_start() : esp_deep_sleep(time_in_us);
|
||||
|
||||
// Never reached - after deep sleep ESP32 restarts
|
||||
}
|
||||
|
||||
void AXP192::LightSleep(uint64_t time_in_us)
|
||||
{
|
||||
PrepareToSleep();
|
||||
|
||||
if (time_in_us > 0)
|
||||
{
|
||||
esp_sleep_enable_timer_wakeup(time_in_us);
|
||||
}
|
||||
else
|
||||
{
|
||||
esp_sleep_disable_wakeup_source(ESP_SLEEP_WAKEUP_TIMER);
|
||||
}
|
||||
esp_light_sleep_start();
|
||||
|
||||
RestoreFromLightSleep();
|
||||
}
|
||||
|
||||
uint8_t AXP192::GetWarningLevel(void)
|
||||
{
|
||||
return Read8bit(0x47) & 0x01;
|
||||
}
|
||||
|
||||
float AXP192::GetBatVoltage()
|
||||
{
|
||||
float ADCLSB = 1.1 / 1000.0;
|
||||
uint16_t ReData = Read12Bit(0x78);
|
||||
return ReData * ADCLSB;
|
||||
}
|
||||
|
||||
float AXP192::GetBatCurrent()
|
||||
{
|
||||
float ADCLSB = 0.5;
|
||||
uint16_t CurrentIn = Read13Bit(0x7A);
|
||||
uint16_t CurrentOut = Read13Bit(0x7C);
|
||||
return (CurrentIn - CurrentOut) * ADCLSB;
|
||||
}
|
||||
|
||||
float AXP192::GetVinVoltage()
|
||||
{
|
||||
float ADCLSB = 1.7 / 1000.0;
|
||||
uint16_t ReData = Read12Bit(0x56);
|
||||
return ReData * ADCLSB;
|
||||
}
|
||||
|
||||
float AXP192::GetVinCurrent()
|
||||
{
|
||||
float ADCLSB = 0.625;
|
||||
uint16_t ReData = Read12Bit(0x58);
|
||||
return ReData * ADCLSB;
|
||||
}
|
||||
|
||||
float AXP192::GetVBusVoltage()
|
||||
{
|
||||
float ADCLSB = 1.7 / 1000.0;
|
||||
uint16_t ReData = Read12Bit(0x5A);
|
||||
return ReData * ADCLSB;
|
||||
}
|
||||
|
||||
float AXP192::GetVBusCurrent()
|
||||
{
|
||||
float ADCLSB = 0.375;
|
||||
uint16_t ReData = Read12Bit(0x5C);
|
||||
return ReData * ADCLSB;
|
||||
}
|
||||
|
||||
float AXP192::GetTempInAXP192()
|
||||
{
|
||||
float ADCLSB = 0.1;
|
||||
const float OFFSET_DEG_C = -144.7;
|
||||
uint16_t ReData = Read12Bit(0x5E);
|
||||
return OFFSET_DEG_C + ReData * ADCLSB;
|
||||
}
|
||||
|
||||
float AXP192::GetBatPower()
|
||||
{
|
||||
float VoltageLSB = 1.1;
|
||||
float CurrentLCS = 0.5;
|
||||
uint32_t ReData = Read24bit(0x70);
|
||||
return VoltageLSB * CurrentLCS * ReData / 1000.0;
|
||||
}
|
||||
|
||||
float AXP192::GetBatChargeCurrent()
|
||||
{
|
||||
float ADCLSB = 0.5;
|
||||
uint16_t ReData = Read12Bit(0x7A);
|
||||
return ReData * ADCLSB;
|
||||
}
|
||||
float AXP192::GetAPSVoltage()
|
||||
{
|
||||
float ADCLSB = 1.4 / 1000.0;
|
||||
uint16_t ReData = Read12Bit(0x7E);
|
||||
return ReData * ADCLSB;
|
||||
}
|
||||
|
||||
float AXP192::GetBatCoulombInput()
|
||||
{
|
||||
uint32_t ReData = Read32bit(0xB0);
|
||||
return ReData * 65536 * 0.5 / 3600 / 25.0;
|
||||
}
|
||||
|
||||
float AXP192::GetBatCoulombOut()
|
||||
{
|
||||
uint32_t ReData = Read32bit(0xB4);
|
||||
return ReData * 65536 * 0.5 / 3600 / 25.0;
|
||||
}
|
||||
|
||||
void AXP192::SetCoulombClear()
|
||||
{
|
||||
Write1Byte(0xB8, 0x20);
|
||||
}
|
||||
|
||||
void AXP192::SetLDO2(bool State)
|
||||
{
|
||||
uint8_t buf = Read8bit(0x12);
|
||||
if (State == true)
|
||||
buf = (1 << 2) | buf;
|
||||
else
|
||||
buf = ~(1 << 2) & buf;
|
||||
Write1Byte(0x12, buf);
|
||||
}
|
||||
|
||||
void AXP192::SetDCDC3(bool State)
|
||||
{
|
||||
uint8_t buf = Read8bit(0x12);
|
||||
if (State == true)
|
||||
buf = (1 << 1) | buf;
|
||||
else
|
||||
buf = ~(1 << 1) & buf;
|
||||
Write1Byte(0x12, buf);
|
||||
}
|
||||
|
||||
uint8_t AXP192::AXPInState()
|
||||
{
|
||||
return Read8bit(0x00);
|
||||
}
|
||||
bool AXP192::isACIN()
|
||||
{
|
||||
return ( Read8bit(0x00) & 0x80 ) ? true : false;
|
||||
}
|
||||
bool AXP192::isCharging()
|
||||
{
|
||||
return ( Read8bit(0x00) & 0x04 ) ? true : false;
|
||||
}
|
||||
bool AXP192::isVBUS()
|
||||
{
|
||||
return ( Read8bit(0x00) & 0x20 ) ? true : false;
|
||||
}
|
||||
|
||||
void AXP192::SetLDOVoltage(uint8_t number, uint16_t voltage)
|
||||
{
|
||||
voltage = (voltage > 3300) ? 15 : (voltage / 100) - 18;
|
||||
switch (number)
|
||||
{
|
||||
//uint8_t reg, data;
|
||||
case 2:
|
||||
Write1Byte(0x28, (Read8bit(0x28) & 0X0F) | (voltage << 4));
|
||||
break;
|
||||
case 3:
|
||||
Write1Byte(0x28, (Read8bit(0x28) & 0XF0) | voltage);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void AXP192::SetDCVoltage(uint8_t number, uint16_t voltage)
|
||||
{
|
||||
uint8_t addr;
|
||||
if (number > 2)
|
||||
return;
|
||||
voltage = (voltage < 700) ? 0 : (voltage - 700) / 25;
|
||||
switch (number)
|
||||
{
|
||||
case 0:
|
||||
addr = 0x26;
|
||||
break;
|
||||
case 1:
|
||||
addr = 0x25;
|
||||
break;
|
||||
case 2:
|
||||
addr = 0x27;
|
||||
break;
|
||||
}
|
||||
Write1Byte(addr, (Read8bit(addr) & 0X80) | (voltage & 0X7F));
|
||||
}
|
||||
|
||||
void AXP192::SetESPVoltage(uint16_t voltage)
|
||||
{
|
||||
if (voltage >= 3000 && voltage <= 3400)
|
||||
{
|
||||
SetDCVoltage(0, voltage);
|
||||
}
|
||||
}
|
||||
void AXP192::SetLcdVoltage(uint16_t voltage)
|
||||
{
|
||||
if (voltage >= 2500 && voltage <= 3300)
|
||||
{
|
||||
SetDCVoltage(2, voltage);
|
||||
}
|
||||
}
|
||||
|
||||
void AXP192::SetLDOEnable(uint8_t number, bool state)
|
||||
{
|
||||
uint8_t mark = 0x01;
|
||||
if ((number < 2) || (number > 3))
|
||||
return;
|
||||
|
||||
mark <<= number;
|
||||
if (state)
|
||||
{
|
||||
Write1Byte(0x12, (Read8bit(0x12) | mark));
|
||||
}
|
||||
else
|
||||
{
|
||||
Write1Byte(0x12, (Read8bit(0x12) & (~mark)));
|
||||
}
|
||||
}
|
||||
|
||||
void AXP192::SetLCDRSet(bool state)
|
||||
{
|
||||
uint8_t reg_addr = 0x96;
|
||||
uint8_t gpio_bit = 0x02;
|
||||
uint8_t data;
|
||||
data = Read8bit(reg_addr);
|
||||
|
||||
if (state)
|
||||
{
|
||||
data |= gpio_bit;
|
||||
}
|
||||
else
|
||||
{
|
||||
data &= ~gpio_bit;
|
||||
}
|
||||
|
||||
Write1Byte(reg_addr, data);
|
||||
}
|
||||
|
||||
void AXP192::SetBusPowerMode(uint8_t state)
|
||||
{
|
||||
uint8_t data;
|
||||
if (state == 0)
|
||||
{
|
||||
data = Read8bit(0x91);
|
||||
Write1Byte(0x91, (data & 0X0F) | 0XF0);
|
||||
|
||||
data = Read8bit(0x90);
|
||||
Write1Byte(0x90, (data & 0XF8) | 0X02); //set GPIO0 to LDO OUTPUT , pullup N_VBUSEN to disable supply from BUS_5V
|
||||
|
||||
data = Read8bit(0x91);
|
||||
|
||||
data = Read8bit(0x12); //read reg 0x12
|
||||
Write1Byte(0x12, data | 0x40); //set EXTEN to enable 5v boost
|
||||
}
|
||||
else
|
||||
{
|
||||
data = Read8bit(0x12); //read reg 0x10
|
||||
Write1Byte(0x12, data & 0XBF); //set EXTEN to disable 5v boost
|
||||
|
||||
//delay(2000);
|
||||
|
||||
data = Read8bit(0x90);
|
||||
Write1Byte(0x90, (data & 0xF8) | 0X01); //set GPIO0 to float , using enternal pulldown resistor to enable supply from BUS_5VS
|
||||
}
|
||||
}
|
||||
|
||||
void AXP192::SetLed(uint8_t state)
|
||||
{
|
||||
uint8_t reg_addr=0x94;
|
||||
uint8_t data;
|
||||
data=Read8bit(reg_addr);
|
||||
|
||||
if(state)
|
||||
{
|
||||
data=data&0XFD;
|
||||
}
|
||||
else
|
||||
{
|
||||
data|=0X02;
|
||||
}
|
||||
|
||||
Write1Byte(reg_addr,data);
|
||||
}
|
||||
|
||||
//set led state(GPIO high active,set 1 to enable amplifier)
|
||||
void AXP192::SetSpkEnable(uint8_t state)
|
||||
{
|
||||
uint8_t reg_addr=0x94;
|
||||
uint8_t gpio_bit=0x04;
|
||||
uint8_t data;
|
||||
data=Read8bit(reg_addr);
|
||||
|
||||
if(state)
|
||||
{
|
||||
data|=gpio_bit;
|
||||
}
|
||||
else
|
||||
{
|
||||
data&=~gpio_bit;
|
||||
}
|
||||
|
||||
Write1Byte(reg_addr,data);
|
||||
}
|
||||
|
||||
void AXP192::SetCHGCurrent(uint8_t state)
|
||||
{
|
||||
uint8_t data = Read8bit(0x33);
|
||||
data &= 0xf0;
|
||||
data = data | ( state & 0x0f );
|
||||
Write1Byte(0x33,data);
|
||||
}
|
||||
|
|
@ -1,106 +0,0 @@
|
|||
#ifndef __AXP192_H__
|
||||
#define __AXP192_H__
|
||||
|
||||
#include <Wire.h>
|
||||
#include <Arduino.h>
|
||||
|
||||
#define SLEEP_MSEC(us) (((uint64_t)us) * 1000L)
|
||||
#define SLEEP_SEC(us) (((uint64_t)us) * 1000000L)
|
||||
#define SLEEP_MIN(us) (((uint64_t)us) * 60L * 1000000L)
|
||||
#define SLEEP_HR(us) (((uint64_t)us) * 60L * 60L * 1000000L)
|
||||
|
||||
#define AXP_ADDR 0X34
|
||||
|
||||
#define PowerOff(x) SetSleep(x)
|
||||
|
||||
class AXP192 {
|
||||
public:
|
||||
|
||||
enum CHGCurrent{
|
||||
kCHG_100mA = 0,
|
||||
kCHG_190mA,
|
||||
kCHG_280mA,
|
||||
kCHG_360mA,
|
||||
kCHG_450mA,
|
||||
kCHG_550mA,
|
||||
kCHG_630mA,
|
||||
kCHG_700mA,
|
||||
kCHG_780mA,
|
||||
kCHG_880mA,
|
||||
kCHG_960mA,
|
||||
kCHG_1000mA,
|
||||
kCHG_1080mA,
|
||||
kCHG_1160mA,
|
||||
kCHG_1240mA,
|
||||
kCHG_1320mA,
|
||||
};
|
||||
|
||||
AXP192();
|
||||
void begin(void);
|
||||
void ScreenBreath(uint8_t brightness);
|
||||
bool GetBatState();
|
||||
|
||||
void EnableCoulombcounter(void);
|
||||
void DisableCoulombcounter(void);
|
||||
void StopCoulombcounter(void);
|
||||
void ClearCoulombcounter(void);
|
||||
uint32_t GetCoulombchargeData(void);
|
||||
uint32_t GetCoulombdischargeData(void);
|
||||
float GetCoulombData(void);
|
||||
void PowerOff(void);
|
||||
void SetAdcState(bool state);
|
||||
// -- sleep
|
||||
void PrepareToSleep(void);
|
||||
void RestoreFromLightSleep(void);
|
||||
void DeepSleep(uint64_t time_in_us = 0);
|
||||
void LightSleep(uint64_t time_in_us = 0);
|
||||
uint8_t GetWarningLeve(void);
|
||||
|
||||
public:
|
||||
// void SetChargeVoltage( uint8_t );
|
||||
// void SetChargeCurrent( uint8_t );
|
||||
float GetBatVoltage();
|
||||
float GetBatCurrent();
|
||||
float GetVinVoltage();
|
||||
float GetVinCurrent();
|
||||
float GetVBusVoltage();
|
||||
float GetVBusCurrent();
|
||||
float GetTempInAXP192();
|
||||
float GetBatPower();
|
||||
float GetBatChargeCurrent();
|
||||
float GetAPSVoltage();
|
||||
float GetBatCoulombInput();
|
||||
float GetBatCoulombOut();
|
||||
uint8_t GetWarningLevel(void);
|
||||
void SetCoulombClear();
|
||||
void SetLDO2( bool State );
|
||||
void SetDCDC3( bool State );
|
||||
|
||||
uint8_t AXPInState();
|
||||
bool isACIN();
|
||||
bool isCharging();
|
||||
bool isVBUS();
|
||||
|
||||
void SetLDOVoltage(uint8_t number , uint16_t voltage);
|
||||
void SetDCVoltage(uint8_t number , uint16_t voltage);
|
||||
void SetESPVoltage(uint16_t voltage);
|
||||
void SetLcdVoltage(uint16_t voltage);
|
||||
void SetLDOEnable( uint8_t number ,bool state );
|
||||
void SetLCDRSet( bool state );
|
||||
void SetBusPowerMode( uint8_t state );
|
||||
void SetLed(uint8_t state);
|
||||
void SetSpkEnable(uint8_t state);
|
||||
void SetCHGCurrent(uint8_t state);
|
||||
|
||||
private:
|
||||
void Write1Byte( uint8_t Addr , uint8_t Data );
|
||||
uint8_t Read8bit( uint8_t Addr );
|
||||
uint16_t Read12Bit( uint8_t Addr);
|
||||
uint16_t Read13Bit( uint8_t Addr);
|
||||
uint16_t Read16bit( uint8_t Addr );
|
||||
uint32_t Read24bit( uint8_t Addr );
|
||||
uint32_t Read32bit( uint8_t Addr );
|
||||
void ReadBuff( uint8_t Addr , uint8_t Size , uint8_t *Buff );
|
||||
};
|
||||
|
||||
#endif
|
||||
|
|
@ -1,353 +0,0 @@
|
|||
#include "BM8563_RTC.h"
|
||||
|
||||
BM8563_RTC::BM8563_RTC()
|
||||
{
|
||||
}
|
||||
|
||||
void BM8563_RTC::begin(void)
|
||||
{
|
||||
Wire1.begin(21, 22);
|
||||
WriteReg(0x00,0x00);
|
||||
WriteReg(0x01,0x00);
|
||||
WriteReg(0x0D,0x00);
|
||||
}
|
||||
|
||||
void BM8563_RTC::WriteReg(uint8_t reg, uint8_t data)
|
||||
{
|
||||
Wire1.beginTransmission(RTC_ADRESS);
|
||||
Wire1.write(reg);
|
||||
Wire1.write(data);
|
||||
Wire1.endTransmission();
|
||||
}
|
||||
|
||||
uint8_t BM8563_RTC::ReadReg(uint8_t reg)
|
||||
{
|
||||
Wire1.beginTransmission(0x51);
|
||||
Wire1.write(reg);
|
||||
Wire1.endTransmission();
|
||||
Wire1.requestFrom(0x51, 1);
|
||||
return Wire1.read();
|
||||
}
|
||||
|
||||
void BM8563_RTC::GetBm8563Time(void)
|
||||
{
|
||||
Wire1.beginTransmission(0x51);
|
||||
Wire1.write(0x02);
|
||||
Wire1.endTransmission();
|
||||
Wire1.requestFrom(0x51, 7);
|
||||
while (Wire1.available())
|
||||
{
|
||||
|
||||
trdata[0] = Wire1.read();
|
||||
trdata[1] = Wire1.read();
|
||||
trdata[2] = Wire1.read();
|
||||
trdata[3] = Wire1.read();
|
||||
trdata[4] = Wire1.read();
|
||||
trdata[5] = Wire1.read();
|
||||
trdata[6] = Wire1.read();
|
||||
}
|
||||
|
||||
DataMask();
|
||||
Bcd2asc();
|
||||
Str2Time();
|
||||
}
|
||||
|
||||
void BM8563_RTC::Str2Time(void)
|
||||
{
|
||||
|
||||
Second = (asc[0] - 0x30) * 10 + asc[1] - 0x30;
|
||||
Minute = (asc[2] - 0x30) * 10 + asc[3] - 0x30;
|
||||
Hour = (asc[4] - 0x30) * 10 + asc[5] - 0x30;
|
||||
/*
|
||||
uint8_t Hour;
|
||||
uint8_t Week;
|
||||
uint8_t Day;
|
||||
uint8_t Month;
|
||||
uint8_t Year;
|
||||
*/
|
||||
}
|
||||
|
||||
void BM8563_RTC::DataMask()
|
||||
{
|
||||
|
||||
trdata[0] = trdata[0] & 0x7f; //秒
|
||||
trdata[1] = trdata[1] & 0x7f; //分
|
||||
trdata[2] = trdata[2] & 0x3f; //时
|
||||
|
||||
trdata[3] = trdata[3] & 0x3f; //日
|
||||
trdata[4] = trdata[4] & 0x07; //星期
|
||||
trdata[5] = trdata[5] & 0x1f; //月
|
||||
|
||||
trdata[6] = trdata[6] & 0xff; //年
|
||||
}
|
||||
/********************************************************************
|
||||
函 数 名： void Bcd2asc(void)
|
||||
功 能： bcd 码转换成 asc 码，供Lcd显示用
|
||||
说 明：
|
||||
调 用：
|
||||
入口参数：
|
||||
返 回 值：无
|
||||
***********************************************************************/
|
||||
void BM8563_RTC::Bcd2asc(void)
|
||||
{
|
||||
uint8_t i, j;
|
||||
for (j = 0, i = 0; i < 7; i++)
|
||||
{
|
||||
asc[j++] = (trdata[i] & 0xf0) >> 4 | 0x30; /*格式为: 秒 分 时 日 月 星期 年 */
|
||||
asc[j++] = (trdata[i] & 0x0f) | 0x30;
|
||||
}
|
||||
}
|
||||
|
||||
uint8_t BM8563_RTC::Bcd2ToByte(uint8_t Value)
|
||||
{
|
||||
uint8_t tmp = 0;
|
||||
tmp = ((uint8_t)(Value & (uint8_t)0xF0) >> (uint8_t)0x4) * 10;
|
||||
return (tmp + (Value & (uint8_t)0x0F));
|
||||
}
|
||||
|
||||
uint8_t BM8563_RTC::ByteToBcd2(uint8_t Value)
|
||||
{
|
||||
uint8_t bcdhigh = 0;
|
||||
|
||||
while (Value >= 10)
|
||||
{
|
||||
bcdhigh++;
|
||||
Value -= 10;
|
||||
}
|
||||
|
||||
return ((uint8_t)(bcdhigh << 4) | Value);
|
||||
}
|
||||
|
||||
void BM8563_RTC::GetTime(RTC_TimeTypeDef *RTC_TimeStruct)
|
||||
{
|
||||
|
||||
//if()
|
||||
uint8_t buf[3] = {0};
|
||||
|
||||
Wire1.beginTransmission(0x51);
|
||||
Wire1.write(0x02);
|
||||
Wire1.endTransmission();
|
||||
Wire1.requestFrom(0x51, 3);
|
||||
|
||||
while (Wire1.available())
|
||||
{
|
||||
|
||||
buf[0] = Wire1.read();
|
||||
buf[1] = Wire1.read();
|
||||
buf[2] = Wire1.read();
|
||||
}
|
||||
|
||||
RTC_TimeStruct->Seconds = Bcd2ToByte(buf[0] & 0x7f); //秒
|
||||
RTC_TimeStruct->Minutes = Bcd2ToByte(buf[1] & 0x7f); //分
|
||||
RTC_TimeStruct->Hours = Bcd2ToByte(buf[2] & 0x3f); //时
|
||||
}
|
||||
|
||||
void BM8563_RTC::SetTime(RTC_TimeTypeDef *RTC_TimeStruct)
|
||||
{
|
||||
|
||||
if (RTC_TimeStruct == NULL)
|
||||
return;
|
||||
|
||||
Wire1.beginTransmission(0x51);
|
||||
Wire1.write(0x02);
|
||||
Wire1.write(ByteToBcd2(RTC_TimeStruct->Seconds));
|
||||
Wire1.write(ByteToBcd2(RTC_TimeStruct->Minutes));
|
||||
Wire1.write(ByteToBcd2(RTC_TimeStruct->Hours));
|
||||
Wire1.endTransmission();
|
||||
}
|
||||
|
||||
void BM8563_RTC::GetDate(RTC_DateTypeDef *RTC_DateStruct)
|
||||
{
|
||||
|
||||
uint8_t buf[4] = {0};
|
||||
|
||||
Wire1.beginTransmission(0x51);
|
||||
Wire1.write(0x05);
|
||||
Wire1.endTransmission();
|
||||
Wire1.requestFrom(0x51, 4);
|
||||
|
||||
while (Wire1.available())
|
||||
{
|
||||
|
||||
buf[0] = Wire1.read();
|
||||
buf[1] = Wire1.read();
|
||||
buf[2] = Wire1.read();
|
||||
buf[3] = Wire1.read();
|
||||
}
|
||||
|
||||
RTC_DateStruct->Date = Bcd2ToByte(buf[0] & 0x3f);
|
||||
RTC_DateStruct->WeekDay = Bcd2ToByte(buf[1] & 0x07);
|
||||
RTC_DateStruct->Month = Bcd2ToByte(buf[2] & 0x1f);
|
||||
|
||||
if (buf[2] & 0x80)
|
||||
{
|
||||
RTC_DateStruct->Year = 1900 + Bcd2ToByte(buf[3] & 0xff);
|
||||
}
|
||||
else
|
||||
{
|
||||
RTC_DateStruct->Year = 2000 + Bcd2ToByte(buf[3] & 0xff);
|
||||
}
|
||||
}
|
||||
|
||||
void BM8563_RTC::SetDate(RTC_DateTypeDef *RTC_DateStruct)
|
||||
{
|
||||
|
||||
if (RTC_DateStruct == NULL)
|
||||
return;
|
||||
Wire1.beginTransmission(0x51);
|
||||
Wire1.write(0x05);
|
||||
Wire1.write(ByteToBcd2(RTC_DateStruct->Date));
|
||||
Wire1.write(ByteToBcd2(RTC_DateStruct->WeekDay));
|
||||
|
||||
if (RTC_DateStruct->Year < 2000)
|
||||
{
|
||||
|
||||
Wire1.write(ByteToBcd2(RTC_DateStruct->Month) | 0x80);
|
||||
Wire1.write(ByteToBcd2((uint8_t)(RTC_DateStruct->Year % 100)));
|
||||
}
|
||||
else
|
||||
{
|
||||
/* code */
|
||||
Wire1.write(ByteToBcd2(RTC_DateStruct->Month) | 0x00);
|
||||
Wire1.write(ByteToBcd2((uint8_t)(RTC_DateStruct->Year % 100)));
|
||||
}
|
||||
|
||||
Wire1.endTransmission();
|
||||
}
|
||||
|
||||
int BM8563_RTC::SetAlarmIRQ(int afterSeconds)
|
||||
{
|
||||
uint8_t reg_value = 0;
|
||||
reg_value = ReadReg(0x01);
|
||||
|
||||
if (afterSeconds < 0)
|
||||
{
|
||||
reg_value &= ~(1 << 0);
|
||||
WriteReg(0x01, reg_value);
|
||||
reg_value = 0x03;
|
||||
WriteReg(0x0E, reg_value);
|
||||
return -1;
|
||||
}
|
||||
|
||||
uint8_t type_value = 2;
|
||||
uint8_t div = 1;
|
||||
if (afterSeconds > 255)
|
||||
{
|
||||
div = 60;
|
||||
type_value = 0x83;
|
||||
}
|
||||
else
|
||||
{
|
||||
type_value = 0x82;
|
||||
}
|
||||
|
||||
afterSeconds = (afterSeconds / div) & 0xFF;
|
||||
WriteReg(0x0F, afterSeconds);
|
||||
WriteReg(0x0E, type_value);
|
||||
|
||||
reg_value |= (1 << 0);
|
||||
reg_value &= ~(1 << 7);
|
||||
WriteReg(0x01, reg_value);
|
||||
return afterSeconds * div;
|
||||
}
|
||||
|
||||
int BM8563_RTC::SetAlarmIRQ(const RTC_TimeTypeDef &RTC_TimeStruct)
|
||||
{
|
||||
uint8_t irq_enable = false;
|
||||
uint8_t out_buf[4] = {0x80, 0x80, 0x80, 0x80};
|
||||
|
||||
if (RTC_TimeStruct.Minutes >= 0)
|
||||
{
|
||||
irq_enable = true;
|
||||
out_buf[0] = ByteToBcd2(RTC_TimeStruct.Minutes) & 0x7f;
|
||||
}
|
||||
|
||||
if (RTC_TimeStruct.Hours >= 0)
|
||||
{
|
||||
irq_enable = true;
|
||||
out_buf[1] = ByteToBcd2(RTC_TimeStruct.Hours) & 0x3f;
|
||||
}
|
||||
|
||||
//out_buf[2] = 0x00;
|
||||
//out_buf[3] = 0x00;
|
||||
|
||||
uint8_t reg_value = ReadReg(0x01);
|
||||
|
||||
if (irq_enable)
|
||||
{
|
||||
reg_value |= (1 << 1);
|
||||
}
|
||||
else
|
||||
{
|
||||
reg_value &= ~(1 << 1);
|
||||
}
|
||||
|
||||
for (int i = 0; i < 4; i++)
|
||||
{
|
||||
WriteReg(0x09 + i, out_buf[i]);
|
||||
}
|
||||
WriteReg(0x01, reg_value);
|
||||
|
||||
return irq_enable ? 1 : 0;
|
||||
}
|
||||
|
||||
int BM8563_RTC::SetAlarmIRQ(const RTC_DateTypeDef &RTC_DateStruct, const RTC_TimeTypeDef &RTC_TimeStruct)
|
||||
{
|
||||
uint8_t irq_enable = false;
|
||||
uint8_t out_buf[4] = {0x80, 0x80, 0x80, 0x80};
|
||||
|
||||
if (RTC_TimeStruct.Minutes >= 0)
|
||||
{
|
||||
irq_enable = true;
|
||||
out_buf[0] = ByteToBcd2(RTC_TimeStruct.Minutes) & 0x7f;
|
||||
}
|
||||
|
||||
if (RTC_TimeStruct.Hours >= 0)
|
||||
{
|
||||
irq_enable = true;
|
||||
out_buf[1] = ByteToBcd2(RTC_TimeStruct.Hours) & 0x3f;
|
||||
}
|
||||
|
||||
if (RTC_DateStruct.Date >= 0)
|
||||
{
|
||||
irq_enable = true;
|
||||
out_buf[2] = ByteToBcd2(RTC_DateStruct.Date) & 0x3f;
|
||||
}
|
||||
|
||||
if (RTC_DateStruct.WeekDay >= 0)
|
||||
{
|
||||
irq_enable = true;
|
||||
out_buf[3] = ByteToBcd2(RTC_DateStruct.WeekDay) & 0x07;
|
||||
}
|
||||
|
||||
uint8_t reg_value = ReadReg(0x01);
|
||||
|
||||
if (irq_enable)
|
||||
{
|
||||
reg_value |= (1 << 1);
|
||||
}
|
||||
else
|
||||
{
|
||||
reg_value &= ~(1 << 1);
|
||||
}
|
||||
|
||||
for (int i = 0; i < 4; i++)
|
||||
{
|
||||
WriteReg(0x09 + i, out_buf[i]);
|
||||
}
|
||||
WriteReg(0x01, reg_value);
|
||||
|
||||
return irq_enable ? 1 : 0;
|
||||
}
|
||||
|
||||
void BM8563_RTC::clearIRQ()
|
||||
{
|
||||
uint8_t data = ReadReg(0x01);
|
||||
WriteReg(0x01, data & 0xf3);
|
||||
}
|
||||
void BM8563_RTC::disableIRQ()
|
||||
{
|
||||
clearIRQ();
|
||||
uint8_t data = ReadReg(0x01);
|
||||
WriteReg(0x01, data & 0xfC);
|
||||
}
|
||||
|
|
@ -1,76 +0,0 @@
|
|||
#ifndef __RTC_H__
|
||||
#define __RTC_H__
|
||||
|
||||
#include <Wire.h>
|
||||
|
||||
#define RTC_ADRESS 0x51
|
||||
|
||||
typedef struct
|
||||
{
|
||||
uint8_t Hours;
|
||||
uint8_t Minutes;
|
||||
uint8_t Seconds;
|
||||
}RTC_TimeTypeDef;
|
||||
|
||||
|
||||
typedef struct
|
||||
{
|
||||
uint8_t WeekDay;
|
||||
uint8_t Month;
|
||||
uint8_t Date;
|
||||
uint16_t Year;
|
||||
}RTC_DateTypeDef;
|
||||
|
||||
class BM8563_RTC {
|
||||
public:
|
||||
BM8563_RTC();
|
||||
|
||||
void begin(void);
|
||||
void GetBm8563Time(void);
|
||||
|
||||
void SetTime(RTC_TimeTypeDef* RTC_TimeStruct);
|
||||
void SetDate(RTC_DateTypeDef* RTC_DateStruct);
|
||||
|
||||
void GetTime(RTC_TimeTypeDef* RTC_TimeStruct);
|
||||
void GetDate(RTC_DateTypeDef* RTC_DateStruct);
|
||||
|
||||
int SetAlarmIRQ(int afterSeconds);
|
||||
int SetAlarmIRQ( const RTC_TimeTypeDef &RTC_TimeStruct);
|
||||
int SetAlarmIRQ( const RTC_DateTypeDef &RTC_DateStruct, const RTC_TimeTypeDef &RTC_TimeStruct);
|
||||
|
||||
void clearIRQ();
|
||||
void disableIRQ();
|
||||
|
||||
public:
|
||||
uint8_t Second;
|
||||
uint8_t Minute;
|
||||
uint8_t Hour;
|
||||
uint8_t Week;
|
||||
uint8_t Day;
|
||||
uint8_t Month;
|
||||
uint8_t Year;
|
||||
uint8_t DateString[9];
|
||||
uint8_t TimeString[9];
|
||||
|
||||
uint8_t asc[14];
|
||||
|
||||
|
||||
private:
|
||||
void Bcd2asc(void);
|
||||
void DataMask();
|
||||
void Str2Time(void);
|
||||
void WriteReg(uint8_t reg, uint8_t data);
|
||||
uint8_t ReadReg(uint8_t reg);
|
||||
uint8_t Bcd2ToByte(uint8_t Value);
|
||||
uint8_t ByteToBcd2(uint8_t Value);
|
||||
|
||||
private:
|
||||
|
||||
/*定义数组用来存储读取的时间数据 */
|
||||
uint8_t trdata[7];
|
||||
/*定义数组用来存储转换的 asc 码时间数据*/
|
||||
//uint8_t asc[14];
|
||||
|
||||
};
|
||||
|
||||
#endif
|
||||
|
|
@ -1,8 +0,0 @@
|
|||
{
|
||||
"name": "M5 Stack Core2 library",
|
||||
"keywords": "esp32, sensor, mqtt, m2m, iot",
|
||||
"description": "M5 Stack Core2 library",
|
||||
"version": "1.0",
|
||||
"frameworks": "arduino",
|
||||
"platforms": "espressif32"
|
||||
}
|
||||
|
|
@ -1,9 +0,0 @@
|
|||
name=M5 Stack Core2 library
|
||||
version=1.0
|
||||
author=Gerhard Mutz
|
||||
maintainer=Gerhard Mutz
|
||||
sentence=Allows Tasmota to use Core2
|
||||
paragraph=Allows Tasmota to Core2 for esp32
|
||||
category=ESP32
|
||||
url=
|
||||
architectures=esp32
|
||||
Loading…
Reference in New Issue