jackcartersmith/picocalc_BIOS
1
0
Fork 0
Code Issues Releases 5 Activity

Some fix

Browse Source 
Missalign PMIC IRQ flag
This commit is contained in:
JackCarterSmith 2025-05-05 21:23:48 +02:00
parent 53114bfd16
commit 8d796385ee
Signed by: JackCarterSmith
GPG Key ID: 832E52F4E23F8F24
7 changed files with 98 additions and 117 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

59
Core/Inc/axp2101.h
View File

@ -266,42 +266,39 @@ typedef enum __xpowers_chg_led_mode {
XPOWERS_CHG_LED_CTRL_CHG, // The charging indicator is controlled by the charger
} xpowers_chg_led_mode_t;
/**
* @brief axp2101 interrupt control mask parameters.
/*
* ------------- axp2101 interrupt control mask -------------
*/
typedef enum __xpowers_axp2101_irq {
//! IRQ1 REG 40H
XPOWERS_AXP2101_BAT_NOR_UNDER_TEMP_IRQ = _BV(0), // Battery Under Temperature in Work
XPOWERS_AXP2101_BAT_NOR_OVER_TEMP_IRQ = _BV(1), // Battery Over Temperature in Work mode
XPOWERS_AXP2101_BAT_CHG_UNDER_TEMP_IRQ = _BV(2), // Battery Under Temperature in Charge mode IRQ(bcut_irq)
XPOWERS_AXP2101_BAT_CHG_OVER_TEMP_IRQ = _BV(3), // Battery Over Temperature in Charge mode IRQ(bcot_irq) enable
XPOWERS_AXP2101_GAUGE_NEW_SOC_IRQ = _BV(4), // Gauge New SOC IRQ(lowsoc_irq) enable ???
XPOWERS_AXP2101_WDT_TIMEOUT_IRQ = _BV(5), // Gauge Watchdog Timeout IRQ(gwdt_irq) enable
XPOWERS_AXP2101_WARNING_LEVEL1_IRQ = _BV(6), // SOC drop to Warning Level1 IRQ(socwl1_irq) enable
XPOWERS_AXP2101_WARNING_LEVEL2_IRQ = _BV(7), // SOC drop to Warning Level2 IRQ(socwl2_irq) enable
#define XPOWERS_AXP2101_BAT_NOR_UNDER_TEMP_IRQ _BV(0) //!< Battery Under Temperature in Work
#define XPOWERS_AXP2101_BAT_NOR_OVER_TEMP_IRQ _BV(1) //!< Battery Over Temperature in Work mode
#define XPOWERS_AXP2101_BAT_CHG_UNDER_TEMP_IRQ _BV(2) //!< Battery Under Temperature in Charge mode IRQ(bcut_irq)
#define XPOWERS_AXP2101_BAT_CHG_OVER_TEMP_IRQ _BV(3) //!< Battery Over Temperature in Charge mode IRQ(bcot_irq) enable
#define XPOWERS_AXP2101_GAUGE_NEW_SOC_IRQ _BV(4) //!< Gauge New SOC IRQ(lowsoc_irq) enable ???
#define XPOWERS_AXP2101_WDT_TIMEOUT_IRQ _BV(5) //!< Gauge Watchdog Timeout IRQ(gwdt_irq) enable
#define XPOWERS_AXP2101_WARNING_LEVEL1_IRQ _BV(6) //!< SOC drop to Warning Level1 IRQ(socwl1_irq) enable
#define XPOWERS_AXP2101_WARNING_LEVEL2_IRQ _BV(7) //!< SOC drop to Warning Level2 IRQ(socwl2_irq) enable
//! IRQ2 REG 41H
XPOWERS_AXP2101_PKEY_POSITIVE_IRQ = _BV(8), // POWERON Positive Edge IRQ(ponpe_irq_en) enable
XPOWERS_AXP2101_PKEY_NEGATIVE_IRQ = _BV(9), // POWERON Negative Edge IRQ(ponne_irq_en) enable
XPOWERS_AXP2101_PKEY_LONG_IRQ = _BV(10), // POWERON Long PRESS IRQ(ponlp_irq) enable
XPOWERS_AXP2101_PKEY_SHORT_IRQ = _BV(11), // POWERON Short PRESS IRQ(ponsp_irq_en) enable
XPOWERS_AXP2101_BAT_REMOVE_IRQ = _BV(12), // Battery Remove IRQ(bremove_irq) enable
XPOWERS_AXP2101_BAT_INSERT_IRQ = _BV(13), // Battery Insert IRQ(binsert_irq) enabl
XPOWERS_AXP2101_VBUS_REMOVE_IRQ = _BV(14), // VBUS Remove IRQ(vremove_irq) enabl
XPOWERS_AXP2101_VBUS_INSERT_IRQ = _BV(15), // VBUS Insert IRQ(vinsert_irq) enable
#define XPOWERS_AXP2101_PKEY_POSITIVE_IRQ _BV(8) //!< POWERON Positive Edge IRQ(ponpe_irq_en) enable
#define XPOWERS_AXP2101_PKEY_NEGATIVE_IRQ _BV(9) //!< POWERON Negative Edge IRQ(ponne_irq_en) enable
#define XPOWERS_AXP2101_PKEY_LONG_IRQ _BV(10) //!< POWERON Long PRESS IRQ(ponlp_irq) enable
#define XPOWERS_AXP2101_PKEY_SHORT_IRQ _BV(11) //!< POWERON Short PRESS IRQ(ponsp_irq_en) enable
#define XPOWERS_AXP2101_BAT_REMOVE_IRQ _BV(12) //!< Battery Remove IRQ(bremove_irq) enable
#define XPOWERS_AXP2101_BAT_INSERT_IRQ _BV(13) //!< Battery Insert IRQ(binsert_irq) enabl
#define XPOWERS_AXP2101_VBUS_REMOVE_IRQ _BV(14) //!< VBUS Remove IRQ(vremove_irq) enabl
#define XPOWERS_AXP2101_VBUS_INSERT_IRQ _BV(15) //!< VBUS Insert IRQ(vinsert_irq) enable
//! IRQ3 REG 42H
XPOWERS_AXP2101_BAT_OVER_VOL_IRQ = _BV(16), // Battery Over Voltage Protection IRQ(bovp_irq) enable
XPOWERS_AXP2101_CHAGER_TIMER_IRQ = _BV(17), // Charger Safety Timer1/2 expire IRQ(chgte_irq) enable
XPOWERS_AXP2101_DIE_OVER_TEMP_IRQ = _BV(18), // DIE Over Temperature level1 IRQ(dotl1_irq) enable
XPOWERS_AXP2101_BAT_CHG_START_IRQ = _BV(19), // Charger start IRQ(chgst_irq) enable
XPOWERS_AXP2101_BAT_CHG_DONE_IRQ = _BV(20), // Battery charge done IRQ(chgdn_irq) enable
XPOWERS_AXP2101_BATFET_OVER_CURR_IRQ = _BV(21), // BATFET Over Current Protection IRQ(bocp_irq) enable
XPOWERS_AXP2101_LDO_OVER_CURR_IRQ = _BV(22), // LDO Over Current IRQ(ldooc_irq) enable
XPOWERS_AXP2101_WDT_EXPIRE_IRQ = _BV(23), // Watchdog Expire IRQ(wdexp_irq) enable
#define XPOWERS_AXP2101_BAT_OVER_VOL_IRQ _BV(16) //!< Battery Over Voltage Protection IRQ(bovp_irq) enable
#define XPOWERS_AXP2101_CHAGER_TIMER_IRQ _BV(17) //!< Charger Safety Timer1/2 expire IRQ(chgte_irq) enable
#define XPOWERS_AXP2101_DIE_OVER_TEMP_IRQ _BV(18) //!< DIE Over Temperature level1 IRQ(dotl1_irq) enable
#define XPOWERS_AXP2101_BAT_CHG_START_IRQ _BV(19) //!< Charger start IRQ(chgst_irq) enable
#define XPOWERS_AXP2101_BAT_CHG_DONE_IRQ _BV(20) //!< Battery charge done IRQ(chgdn_irq) enable
#define XPOWERS_AXP2101_BATFET_OVER_CURR_IRQ _BV(21) //!< BATFET Over Current Protection IRQ(bocp_irq) enable
#define XPOWERS_AXP2101_LDO_OVER_CURR_IRQ _BV(22) //!< LDO Over Current IRQ(ldooc_irq) enable
#define XPOWERS_AXP2101_WDT_EXPIRE_IRQ _BV(23) //!< Watchdog Expire IRQ(wdexp_irq) enable
#define XPOWERS_AXP2101_ALL_IRQ (0xFFFFFFFFUL)
XPOWERS_AXP2101_ALL_IRQ = (0xFFFFFFFFUL)
} xpowers_axp2101_irq_t;
uint32_t AXP2101_shutdown(void);

56
Core/Src/axp2101.c
View File

@ -2,6 +2,8 @@
#include "main.h"
#include "stm32_assert.h"
#define AXP2101_DEV_I2C_ID 0x68
static uint8_t statusRegister[XPOWERS_AXP2101_INTSTS_CNT] = {0};
static uint8_t intRegister[XPOWERS_AXP2101_INTSTS_CNT] = {0};
@ -11,19 +13,19 @@ __STATIC_INLINE uint8_t clrRegisterBit(uint8_t registers, uint8_t bit) {
uint8_t reg_value = 0;
HAL_StatusTypeDef status;
status = HAL_I2C_Mem_Read(&hi2c2, 0x68, registers, 1, &reg_value, 1, 60);
status = HAL_I2C_Mem_Read(&hi2c2, AXP2101_DEV_I2C_ID, registers, 1, &reg_value, 1, 60);
if (status != HAL_OK)
return 1;
reg_value &= (uint8_t)(~_BV(bit));
return HAL_I2C_Mem_Write(&hi2c2, 0x68, registers, 1, &reg_value, 1, 60);
return HAL_I2C_Mem_Write(&hi2c2, AXP2101_DEV_I2C_ID, registers, 1, &reg_value, 1, 60);
}
__STATIC_INLINE uint8_t getRegisterBit(uint8_t registers, uint8_t bit) {
uint8_t reg_value = 0;
HAL_StatusTypeDef status;
status = HAL_I2C_Mem_Read(&hi2c2, 0x68, registers, 1, &reg_value, 1, 60);
status = HAL_I2C_Mem_Read(&hi2c2, AXP2101_DEV_I2C_ID, registers, 1, &reg_value, 1, 60);
if (status != HAL_OK)
return 1;
@ -34,12 +36,12 @@ __STATIC_INLINE uint8_t setRegisterBit(uint8_t registers, uint8_t bit) {
uint8_t reg_value = 0;
HAL_StatusTypeDef status;
status = HAL_I2C_Mem_Read(&hi2c2, 0x68, registers, 1, &reg_value, 1, 60);
status = HAL_I2C_Mem_Read(&hi2c2, AXP2101_DEV_I2C_ID, registers, 1, &reg_value, 1, 60);
if (status != HAL_OK)
return 1;
reg_value |= (uint8_t)(_BV(bit));
return HAL_I2C_Mem_Write(&hi2c2, 0x68, registers, 1, &reg_value, 1, 60);
return HAL_I2C_Mem_Write(&hi2c2, AXP2101_DEV_I2C_ID, registers, 1, &reg_value, 1, 60);
}
uint32_t setInterruptImpl(uint32_t opts, uint8_t enable) {
@ -47,17 +49,17 @@ uint32_t setInterruptImpl(uint32_t opts, uint8_t enable) {
HAL_StatusTypeDef status = HAL_OK;
if (opts & 0x0000FF) {
HAL_I2C_Mem_Read(&hi2c2, 0x68, XPOWERS_AXP2101_INTEN1, 1, &reg_value, 1, 60);
HAL_I2C_Mem_Read(&hi2c2, AXP2101_DEV_I2C_ID, XPOWERS_AXP2101_INTEN1, 1, &reg_value, 1, 60);
intRegister[0] = enable ? (uint8_t)(reg_value | (opts & 0xFF)) : (uint8_t)(reg_value & (~(opts & 0xFF)));
status |= HAL_I2C_Mem_Write(&hi2c2, 0x68, XPOWERS_AXP2101_INTEN1, 1, &intRegister[0], 1, 60);
}
if (opts & 0x00FF00) {
HAL_I2C_Mem_Read(&hi2c2, 0x68, XPOWERS_AXP2101_INTEN2, 1, &reg_value, 1, 60);
HAL_I2C_Mem_Read(&hi2c2, AXP2101_DEV_I2C_ID, XPOWERS_AXP2101_INTEN2, 1, &reg_value, 1, 60);
intRegister[1] = enable ? (uint8_t)(reg_value | (opts >> 8)) : (uint8_t)(reg_value & (~(opts >> 8)));
status |= HAL_I2C_Mem_Write(&hi2c2, 0x68, XPOWERS_AXP2101_INTEN2, 1, &intRegister[1], 1, 60);
}
if (opts & 0xFF0000) {
HAL_I2C_Mem_Read(&hi2c2, 0x68, XPOWERS_AXP2101_INTEN3, 1, &reg_value, 1, 60);
HAL_I2C_Mem_Read(&hi2c2, AXP2101_DEV_I2C_ID, XPOWERS_AXP2101_INTEN3, 1, &reg_value, 1, 60);
intRegister[2] = enable ? (uint8_t)(reg_value | (opts >> 16)) : (uint8_t)(reg_value & (~(opts >> 16)));
status |= HAL_I2C_Mem_Write(&hi2c2, 0x68, XPOWERS_AXP2101_INTEN3, 1, &intRegister[2], 1, 60);
}
@ -103,7 +105,7 @@ uint32_t AXP2101_clearIrqStatus(void) {
uint8_t fbuff = 0xFF;
for (size_t i = 0; i < XPOWERS_AXP2101_INTSTS_CNT; i++) {
status |= HAL_I2C_Mem_Write(&hi2c2, 0x68, XPOWERS_AXP2101_INTSTS1 + (uint8_t)i, 1, &fbuff, 1, 60);
status |= HAL_I2C_Mem_Write(&hi2c2, AXP2101_DEV_I2C_ID, XPOWERS_AXP2101_INTSTS1 + (uint8_t)i, 1, &fbuff, 1, 60);
statusRegister[i] = 0;
}
@ -111,7 +113,7 @@ uint32_t AXP2101_clearIrqStatus(void) {
}
uint8_t AXP2101_isDropWarningLevel1Irq(void) {
uint8_t mask = XPOWERS_AXP2101_WARNING_LEVEL1_IRQ >> 8;
uint8_t mask = XPOWERS_AXP2101_WARNING_LEVEL1_IRQ;
if (intRegister[0] & mask)
return ((statusRegister[0] & mask) == mask);
return 0;
@ -153,14 +155,14 @@ uint8_t AXP2101_isPekeyLongPressIrq(void) {
}
uint8_t AXP2101_isBatChargeDoneIrq(void) {
uint8_t mask = XPOWERS_AXP2101_BAT_CHG_DONE_IRQ >> 8;
uint8_t mask = XPOWERS_AXP2101_BAT_CHG_DONE_IRQ >> 16;
if (intRegister[2] & mask)
return ((statusRegister[2] & mask) == mask);
return 0;
}
uint8_t AXP2101_isBatChargeStartIrq(void) {
uint8_t mask = XPOWERS_AXP2101_BAT_CHG_START_IRQ >> 8;
uint8_t mask = XPOWERS_AXP2101_BAT_CHG_START_IRQ >> 16;
if (intRegister[2] & mask)
return ((statusRegister[2] & mask) == mask);
return 0;
@ -184,13 +186,13 @@ uint32_t AXP2101_setSysPowerDownVoltage(uint16_t value) {
return 10;
}
status = HAL_I2C_Mem_Read(&hi2c2, 0x68, XPOWERS_AXP2101_VOFF_SET, 1, &reg_value, 1, 60);
status = HAL_I2C_Mem_Read(&hi2c2, AXP2101_DEV_I2C_ID, XPOWERS_AXP2101_VOFF_SET, 1, &reg_value, 1, 60);
if (status != HAL_OK)
return 1;
reg_value &= 0xF8;
reg_value |= (uint8_t)((value - XPOWERS_AXP2101_VSYS_VOL_THRESHOLD_MIN) / XPOWERS_AXP2101_VSYS_VOL_THRESHOLD_STEPS);
return (uint32_t)HAL_I2C_Mem_Write(&hi2c2, 0x68, XPOWERS_AXP2101_VOFF_SET, 1, &reg_value, 1, 60);
return (uint32_t)HAL_I2C_Mem_Write(&hi2c2, AXP2101_DEV_I2C_ID, XPOWERS_AXP2101_VOFF_SET, 1, &reg_value, 1, 60);
}
uint32_t AXP2101_setChargingLedMode(uint8_t mode) {
@ -204,7 +206,7 @@ uint32_t AXP2101_setChargingLedMode(uint8_t mode) {
case XPOWERS_CHG_LED_BLINK_1HZ:
case XPOWERS_CHG_LED_BLINK_4HZ:
case XPOWERS_CHG_LED_ON:
status = HAL_I2C_Mem_Read(&hi2c2, 0x68, XPOWERS_AXP2101_CHGLED_SET_CTRL, 1, &reg_value, 1, 60);
status = HAL_I2C_Mem_Read(&hi2c2, AXP2101_DEV_I2C_ID, XPOWERS_AXP2101_CHGLED_SET_CTRL, 1, &reg_value, 1, 60);
if (status != HAL_OK)
return 1;
@ -212,10 +214,10 @@ uint32_t AXP2101_setChargingLedMode(uint8_t mode) {
reg_value |= 0x05; //use manual ctrl
reg_value |= (mode << 4);
status = HAL_I2C_Mem_Write(&hi2c2, 0x68, XPOWERS_AXP2101_CHGLED_SET_CTRL, 1, &reg_value, 1, 60);
status = HAL_I2C_Mem_Write(&hi2c2, AXP2101_DEV_I2C_ID, XPOWERS_AXP2101_CHGLED_SET_CTRL, 1, &reg_value, 1, 60);
break;
case XPOWERS_CHG_LED_CTRL_CHG:
status = HAL_I2C_Mem_Read(&hi2c2, 0x68, XPOWERS_AXP2101_CHGLED_SET_CTRL, 1, &reg_value, 1, 60);
status = HAL_I2C_Mem_Read(&hi2c2, AXP2101_DEV_I2C_ID, XPOWERS_AXP2101_CHGLED_SET_CTRL, 1, &reg_value, 1, 60);
if (status != HAL_OK)
return 1;
@ -223,7 +225,7 @@ uint32_t AXP2101_setChargingLedMode(uint8_t mode) {
reg_value |= 0x01; // use type A mode
//reg_value |= 0x02; // use type B mode
status = HAL_I2C_Mem_Write(&hi2c2, 0x68, XPOWERS_AXP2101_CHGLED_SET_CTRL, 1, &reg_value, 1, 60);
status = HAL_I2C_Mem_Write(&hi2c2, AXP2101_DEV_I2C_ID, XPOWERS_AXP2101_CHGLED_SET_CTRL, 1, &reg_value, 1, 60);
break;
default:
status = 10;
@ -245,13 +247,13 @@ uint32_t AXP2101_setLowBatWarnThreshold(uint8_t percentage) {
uint8_t reg_value = 0;
HAL_StatusTypeDef status;
status = HAL_I2C_Mem_Read(&hi2c2, 0x68, XPOWERS_AXP2101_LOW_BAT_WARN_SET, 1, &reg_value, 1, 60);
status = HAL_I2C_Mem_Read(&hi2c2, AXP2101_DEV_I2C_ID, XPOWERS_AXP2101_LOW_BAT_WARN_SET, 1, &reg_value, 1, 60);
if (status != HAL_OK)
return 1;
reg_value &= 0x0F;
reg_value |= (uint8_t)((percentage - 5) << 4);
return HAL_I2C_Mem_Write(&hi2c2, 0x68, XPOWERS_AXP2101_LOW_BAT_WARN_SET, 1, &reg_value, 1, 60);
return HAL_I2C_Mem_Write(&hi2c2, AXP2101_DEV_I2C_ID, XPOWERS_AXP2101_LOW_BAT_WARN_SET, 1, &reg_value, 1, 60);
}
/**
@ -266,13 +268,13 @@ uint32_t AXP2101_setLowBatShutdownThreshold(uint8_t opt) {
if (opt > 15)
opt = 15;
status = HAL_I2C_Mem_Read(&hi2c2, 0x68, XPOWERS_AXP2101_LOW_BAT_WARN_SET, 1, &reg_value, 1, 60);
status = HAL_I2C_Mem_Read(&hi2c2, AXP2101_DEV_I2C_ID, XPOWERS_AXP2101_LOW_BAT_WARN_SET, 1, &reg_value, 1, 60);
if (status != HAL_OK)
return 1;
reg_value &= 0xF0;
reg_value |= opt;
return HAL_I2C_Mem_Write(&hi2c2, 0x68, XPOWERS_AXP2101_LOW_BAT_WARN_SET, 1, &reg_value, 1, 60);
return HAL_I2C_Mem_Write(&hi2c2, AXP2101_DEV_I2C_ID, XPOWERS_AXP2101_LOW_BAT_WARN_SET, 1, &reg_value, 1, 60);
}
@ -283,7 +285,7 @@ uint8_t AXP2101_isBatteryConnect(void) {
uint8_t AXP2101_isCharging(void) {
uint8_t reg_value = 0;
HAL_I2C_Mem_Read(&hi2c2, 0x68, XPOWERS_AXP2101_STATUS2, 1, &reg_value, 1, 60);
HAL_I2C_Mem_Read(&hi2c2, AXP2101_DEV_I2C_ID, XPOWERS_AXP2101_STATUS2, 1, &reg_value, 1, 60);
return (reg_value >> 5) == 0x01;
}
@ -291,9 +293,9 @@ uint8_t AXP2101_isCharging(void) {
uint32_t AXP2101_getIrqStatus(uint32_t* out_value) {
HAL_StatusTypeDef status = HAL_OK;
status |= HAL_I2C_Mem_Read(&hi2c2, 0x68, XPOWERS_AXP2101_INTSTS1, 1, &statusRegister[0], 1, 60);
status |= HAL_I2C_Mem_Read(&hi2c2, 0x68, XPOWERS_AXP2101_INTSTS2, 1, &statusRegister[1], 1, 60);
status |= HAL_I2C_Mem_Read(&hi2c2, 0x68, XPOWERS_AXP2101_INTSTS3, 1, &statusRegister[2], 1, 60);
status |= HAL_I2C_Mem_Read(&hi2c2, AXP2101_DEV_I2C_ID, XPOWERS_AXP2101_INTSTS1, 1, &statusRegister[0], 1, 60);
status |= HAL_I2C_Mem_Read(&hi2c2, AXP2101_DEV_I2C_ID, XPOWERS_AXP2101_INTSTS2, 1, &statusRegister[1], 1, 60);
status |= HAL_I2C_Mem_Read(&hi2c2, AXP2101_DEV_I2C_ID, XPOWERS_AXP2101_INTSTS3, 1, &statusRegister[2], 1, 60);
((uint8_t*)&out_value)[0] = statusRegister[0];
((uint8_t*)&out_value)[0] = statusRegister[1];
@ -307,5 +309,5 @@ uint32_t AXP2101_getBatteryPercent(uint8_t* out_value) {
if (!AXP2101_isBatteryConnect())
return 1;
return HAL_I2C_Mem_Read(&hi2c2, 0x68, XPOWERS_AXP2101_BAT_PERCENT_DATA, 1, out_value, 1, 60);
return HAL_I2C_Mem_Read(&hi2c2, AXP2101_DEV_I2C_ID, XPOWERS_AXP2101_BAT_PERCENT_DATA, 1, out_value, 1, 60);
}

2
Core/Src/batt.c
View File

@ -34,7 +34,7 @@ void low_bat(void) {
if (AXP2101_getBatteryPercent(&pcnt) != HAL_OK)
return;
if ((pcnt >= 0) && (pcnt <= (uint8_t)LOW_BAT_VAL)) {
if ((pcnt != 0) && (pcnt <= (uint8_t)LOW_BAT_VAL)) {
low_bat_count++;
LL_GPIO_SetOutputPin(SYS_LED_GPIO_Port, SYS_LED_Pin);

39
Core/Src/eeprom.c
View File

@ -58,10 +58,10 @@ EEPROM_Result EEPROM_Init()
EraseDefinitions.NbPages = 2;
uint32_t PageError;
result = HAL_FLASHEx_Erase(&EraseDefinitions, &PageError);
result = (EEPROM_Result)HAL_FLASHEx_Erase(&EraseDefinitions, &PageError);
if (result != EEPROM_SUCCESS) return result;
result = HAL_FLASH_Program(EEPROM_SIZE16, EEPROM_PAGE0, EEPROM_VALID);
result = (EEPROM_Result)HAL_FLASH_Program(EEPROM_SIZE16, EEPROM_PAGE0, EEPROM_VALID);
if (result != EEPROM_SUCCESS) return result;
PageStatus0 = EEPROM_VALID;
@ -159,7 +159,7 @@ EEPROM_Result EEPROM_WriteVariable(uint16_t VariableName, EEPROM_Value Value, ui
uint32_t PageEndAddress = WritingPage + FLASH_PAGE_SIZE;
//calculate memory usage of variable
uint8_t Bytes = 2 + (1 << Size);
uint8_t Bytes = (uint8_t)(2 + (1 << Size));
if (Size == EEPROM_SIZE_DELETED) Bytes = 2;
//check if enough free space or page full
@ -169,8 +169,8 @@ EEPROM_Result EEPROM_WriteVariable(uint16_t VariableName, EEPROM_Value Value, ui
uint16_t RequiredMemory = 2;
for (uint16_t i = 0; i < EEPROM_VARIABLE_COUNT; i++)
{
if (i == VariableName) RequiredMemory += 2 + (1 << Size);
else if (EEPROM_SizeTable[i] != EEPROM_SIZE_DELETED) RequiredMemory += 2 + (1 << EEPROM_SizeTable[i]);
if (i == VariableName) RequiredMemory += (uint16_t)(2 + (1 << Size));
else if (EEPROM_SizeTable[i] != EEPROM_SIZE_DELETED) RequiredMemory += (uint16_t)(2 + (1 << EEPROM_SizeTable[i]));
}
if (RequiredMemory > FLASH_PAGE_SIZE) return EEPROM_FULL;
@ -196,17 +196,17 @@ EEPROM_Result EEPROM_WriteVariable(uint16_t VariableName, EEPROM_Value Value, ui
//write variable value
if (Size != EEPROM_SIZE_DELETED)
{
result = HAL_FLASH_Program(Size, EEPROM_NextIndex + 2, Value.uInt64);
result = (EEPROM_Result)HAL_FLASH_Program(Size, EEPROM_NextIndex + 2, Value.uInt64);
if (result != EEPROM_SUCCESS) return result;
}
//create and write variable header (size and name)
uint16_t VariableHeader = VariableName + (Size << 14);
result = HAL_FLASH_Program(FLASH_TYPEPROGRAM_HALFWORD, EEPROM_NextIndex, VariableHeader);
uint16_t VariableHeader = (uint16_t)(VariableName + (Size << 14));
result = (EEPROM_Result)HAL_FLASH_Program(FLASH_TYPEPROGRAM_HALFWORD, EEPROM_NextIndex, VariableHeader);
if (result != EEPROM_SUCCESS) return result;
//update index & size table
EEPROM_Index[VariableName] = EEPROM_NextIndex + 2 - EEPROM_START_ADDRESS;
EEPROM_Index[VariableName] = (uint16_t)(EEPROM_NextIndex + 2 - EEPROM_START_ADDRESS);
EEPROM_SizeTable[VariableName] = Size;
if (Size == EEPROM_SIZE_DELETED) EEPROM_Index[VariableName] = 0;
@ -246,8 +246,8 @@ static EEPROM_Result EEPROM_PageTransfer()
EEPROM_Value Value;
//get start & end address of valid page (source) (as offset to EEPROM start)
uint16_t StartAddress = EEPROM_ValidPage - EEPROM_START_ADDRESS;
uint16_t EndAddress = EEPROM_ValidPage - EEPROM_START_ADDRESS + FLASH_PAGE_SIZE;
uint16_t StartAddress = (uint16_t)(EEPROM_ValidPage - EEPROM_START_ADDRESS);
uint16_t EndAddress = (uint16_t)(EEPROM_ValidPage - EEPROM_START_ADDRESS + FLASH_PAGE_SIZE);
//copy each variable
for (uint16_t i = 0; i < EEPROM_VARIABLE_COUNT; i++)
@ -296,8 +296,8 @@ static EEPROM_Result EEPROM_SetPageStatus(EEPROM_Page Page, EEPROM_PageStatus Pa
if (PageStatus == EEPROM_ERASED)
{
//remove every variable from index, that is stored on erase page
uint16_t StartAddress = Page - EEPROM_START_ADDRESS;
uint16_t EndAddress = Page - EEPROM_START_ADDRESS + FLASH_PAGE_SIZE;
uint16_t StartAddress = (uint16_t)(Page - EEPROM_START_ADDRESS);
uint16_t EndAddress = (uint16_t)(Page - EEPROM_START_ADDRESS + FLASH_PAGE_SIZE);
for (uint16_t i = 0; i < EEPROM_VARIABLE_COUNT; i++)
{
if (StartAddress < EEPROM_Index[i] && EEPROM_Index[i] < EndAddress) EEPROM_Index[i] = 0;
@ -312,14 +312,14 @@ static EEPROM_Result EEPROM_SetPageStatus(EEPROM_Page Page, EEPROM_PageStatus Pa
uint32_t PageError;
//erase page
result = HAL_FLASHEx_Erase(&EraseDefinitions, &PageError);
result = (EEPROM_Result)HAL_FLASHEx_Erase(&EraseDefinitions, &PageError);
if (result != EEPROM_SUCCESS) return result;
}
//else write status to flash
else
{
result = HAL_FLASH_Program(FLASH_TYPEPROGRAM_HALFWORD, Page, PageStatus);
result = (EEPROM_Result)HAL_FLASH_Program(FLASH_TYPEPROGRAM_HALFWORD, Page, PageStatus);
if (result != EEPROM_SUCCESS) return result;
}
@ -397,14 +397,13 @@ static EEPROM_Result EEPROM_PageToIndex(EEPROM_Page Page)
else
{
//get size code
SizeCode = VariableHeader >> 14;
SizeCode = (uint8_t)(VariableHeader >> 14);
//check for valid name (VARIABLE_COUNT might have been reduced between builds, but old variables are still in flash)
Name = VariableHeader & 0b0011111111111111;
if (Name < EEPROM_VARIABLE_COUNT)
{
Name = VariableHeader & 0x3FFF;
if (Name < EEPROM_VARIABLE_COUNT) {
//if everything valid, update the index and the size table
EEPROM_Index[Name] = Address + 2 - EEPROM_START_ADDRESS;
EEPROM_Index[Name] = (uint16_t)(Address + 2 - EEPROM_START_ADDRESS);
EEPROM_SizeTable[Name] = SizeCode;
if (SizeCode == EEPROM_SIZE_DELETED) EEPROM_Index[Name] = 0;
}

30
Core/Src/main.c
View File

@ -197,11 +197,9 @@ extern void HAL_I2C_SlaveRxCpltCallback(I2C_HandleTypeDef *hi2c) {
const uint8_t is_write = (uint8_t)(i2cs_r_buff[0] & (1 << 7));
const uint8_t reg = (uint8_t)(i2cs_r_buff[0] & ~(1 << 7));
if (reg == REG_ID_BKL) { // We wait an another byte for these registers
if (is_write) {
HAL_I2C_Slave_Sequential_Receive_IT(hi2c, i2cs_r_buff + i2cs_r_idx, 1, I2C_NEXT_FRAME); // This write the second received byte to i2cs_r_buff[1]
}
} else if (reg == REG_ID_BK2) {
// We wait an another byte for these registers
if (reg == REG_ID_BKL ||
reg == REG_ID_BK2) {
if (is_write) {
HAL_I2C_Slave_Sequential_Receive_IT(hi2c, i2cs_r_buff + i2cs_r_idx, 1, I2C_NEXT_FRAME); // This write the second received byte to i2cs_r_buff[1]
}
@ -210,21 +208,6 @@ extern void HAL_I2C_SlaveRxCpltCallback(I2C_HandleTypeDef *hi2c) {
}
}
/*extern void HAL_I2C_SlaveTxCpltCallback(I2C_HandleTypeDef *hi2c) {
if (hi2c == &hi2c1) {
if (i2cs_state == I2CS_STATE_REG_ANSWER) {
if (++i2cs_w_idx < i2cs_w_len) {
HAL_I2C_Slave_Sequential_Transmit_IT(hi2c, i2cs_w_buff + i2cs_w_idx, 1, I2C_NEXT_FRAME); // This write the next answer byte on I2C bus
} else {
i2cs_w_buff[31] = 0;
HAL_I2C_Slave_Sequential_Transmit_IT(hi2c, &i2cs_w_buff[31], 1, I2C_NEXT_FRAME); // send a 0 value to avoid stalling - TODO: usefull? can we use I2C_LAST_FRAME instead?
}
i2cs_rearm_counter = 0;
}
}
}*/
extern void HAL_I2C_ListenCpltCallback (I2C_HandleTypeDef *hi2c) {
if (hi2c == &hi2c1) {
if (i2cs_state == I2CS_STATE_REG_ANSWER)
@ -238,6 +221,7 @@ extern void HAL_I2C_ErrorCallback(I2C_HandleTypeDef *hi2c) {
if (hi2c == &hi2c1)
if (HAL_I2C_GetError(hi2c) != HAL_I2C_ERROR_AF)
Error_Handler(); //TODO: replace with dedicated, non-blocking, error handler
// Actually this will trigger the watchdog and restart the system... That can ruin the day of the user.
}
#ifdef DEBUG
@ -387,7 +371,7 @@ int main(void)
// Enable speaker Amp. power
LL_GPIO_SetOutputPin(SP_AMP_EN_GPIO_Port, SP_AMP_EN_Pin);
HAL_Delay(1000);
HAL_Delay(500);
lcd_backlight_on();
// It is necessary to disable the detection function of the TS pin on the
@ -446,13 +430,11 @@ int main(void)
/* USER CODE END WHILE */
/* USER CODE BEGIN 3 */
// Save user registers in EEPROM if unsynced every 2.5s
reg_sync();
// Re-arm I2CS in case of lost master signal
if (i2cs_state != I2CS_STATE_IDLE && i2cs_rearm_counter > I2CS_REARM_TIMEOUT)
i2cs_state = I2CS_STATE_IDLE;
reg_sync();
check_pmu_int();
keyboard_process();
hw_check_HP_presence();

1
Core/Src/regs.c
View File

@ -103,6 +103,7 @@ uint32_t reg_check_and_save_eeprom(void) {
}
void reg_sync(void) {
// Save user registers in EEPROM if unsynced every 1.5s
if (uptime_ms() > (eeprom_refresh_counter + 1500)) {
reg_check_and_save_eeprom();
eeprom_refresh_counter = uptime_ms();