From 1b288f72cc221619b9fdbde923de643a7bcf9264 Mon Sep 17 00:00:00 2001 From: JackCarterSmith Date: Mon, 5 May 2025 21:23:48 +0200 Subject: [PATCH] Some fix - Missalign PMIC IRQ flag - Incorrect batt led --- Core/Inc/axp2101.h | 63 +++++++++++++++++++++------------------------ Core/Inc/keyboard.h | 24 ++++++++--------- Core/Src/axp2101.c | 56 +++++++++++++++++++++------------------- Core/Src/batt.c | 15 ++++++----- Core/Src/eeprom.c | 39 ++++++++++++++-------------- Core/Src/main.c | 30 +++++---------------- Core/Src/regs.c | 1 + 7 files changed, 105 insertions(+), 123 deletions(-) diff --git a/Core/Inc/axp2101.h b/Core/Inc/axp2101.h index 8d17034..aa18577 100644 --- a/Core/Inc/axp2101.h +++ b/Core/Inc/axp2101.h @@ -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 +//! IRQ1 REG 40H +#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 +#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 +#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 - //! 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_ALL_IRQ (0xFFFFFFFFUL) - //! 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 - - XPOWERS_AXP2101_ALL_IRQ = (0xFFFFFFFFUL) -} xpowers_axp2101_irq_t; uint32_t AXP2101_shutdown(void); diff --git a/Core/Inc/keyboard.h b/Core/Inc/keyboard.h index 11b871d..8acd0e2 100644 --- a/Core/Inc/keyboard.h +++ b/Core/Inc/keyboard.h @@ -46,19 +46,19 @@ enum key_state { #define KEY_MOD_SYM 0xA4 #define KEY_MOD_CTRL 0xA5 -#define KEY_ESC 0xB1 -#define KEY_UP 0xb5 -#define KEY_DOWN 0xb6 -#define KEY_LEFT 0xb4 -#define KEY_RIGHT 0xb7 +#define KEY_ESC 0xB1 +#define KEY_UP 0xb5 +#define KEY_DOWN 0xb6 +#define KEY_LEFT 0xb4 +#define KEY_RIGHT 0xb7 -#define KEY_BREAK 0xd0 // == KEY_PAUSE -#define KEY_INSERT 0xD1 -#define KEY_HOME 0xD2 -#define KEY_DEL 0xD4 -#define KEY_END 0xD5 -#define KEY_PAGE_UP 0xd6 -#define KEY_PAGE_DOWN 0xd7 +#define KEY_BREAK 0xd0 // == KEY_PAUSE +#define KEY_INSERT 0xD1 +#define KEY_HOME 0xD2 +#define KEY_DEL 0xD4 +#define KEY_END 0xD5 +#define KEY_PAGE_UP 0xd6 +#define KEY_PAGE_DOWN 0xd7 #define KEY_CAPS_LOCK 0xC1 diff --git a/Core/Src/axp2101.c b/Core/Src/axp2101.c index bcbb370..a7bc8a4 100644 --- a/Core/Src/axp2101.c +++ b/Core/Src/axp2101.c @@ -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, ®_value, 1, 60); + status = HAL_I2C_Mem_Read(&hi2c2, AXP2101_DEV_I2C_ID, registers, 1, ®_value, 1, 60); if (status != HAL_OK) return 1; reg_value &= (uint8_t)(~_BV(bit)); - return HAL_I2C_Mem_Write(&hi2c2, 0x68, registers, 1, ®_value, 1, 60); + return HAL_I2C_Mem_Write(&hi2c2, AXP2101_DEV_I2C_ID, registers, 1, ®_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, ®_value, 1, 60); + status = HAL_I2C_Mem_Read(&hi2c2, AXP2101_DEV_I2C_ID, registers, 1, ®_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, ®_value, 1, 60); + status = HAL_I2C_Mem_Read(&hi2c2, AXP2101_DEV_I2C_ID, registers, 1, ®_value, 1, 60); if (status != HAL_OK) return 1; reg_value |= (uint8_t)(_BV(bit)); - return HAL_I2C_Mem_Write(&hi2c2, 0x68, registers, 1, ®_value, 1, 60); + return HAL_I2C_Mem_Write(&hi2c2, AXP2101_DEV_I2C_ID, registers, 1, ®_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, ®_value, 1, 60); + HAL_I2C_Mem_Read(&hi2c2, AXP2101_DEV_I2C_ID, XPOWERS_AXP2101_INTEN1, 1, ®_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, ®_value, 1, 60); + HAL_I2C_Mem_Read(&hi2c2, AXP2101_DEV_I2C_ID, XPOWERS_AXP2101_INTEN2, 1, ®_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, ®_value, 1, 60); + HAL_I2C_Mem_Read(&hi2c2, AXP2101_DEV_I2C_ID, XPOWERS_AXP2101_INTEN3, 1, ®_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, ®_value, 1, 60); + status = HAL_I2C_Mem_Read(&hi2c2, AXP2101_DEV_I2C_ID, XPOWERS_AXP2101_VOFF_SET, 1, ®_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, ®_value, 1, 60); + return (uint32_t)HAL_I2C_Mem_Write(&hi2c2, AXP2101_DEV_I2C_ID, XPOWERS_AXP2101_VOFF_SET, 1, ®_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, ®_value, 1, 60); + status = HAL_I2C_Mem_Read(&hi2c2, AXP2101_DEV_I2C_ID, XPOWERS_AXP2101_CHGLED_SET_CTRL, 1, ®_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, ®_value, 1, 60); + status = HAL_I2C_Mem_Write(&hi2c2, AXP2101_DEV_I2C_ID, XPOWERS_AXP2101_CHGLED_SET_CTRL, 1, ®_value, 1, 60); break; case XPOWERS_CHG_LED_CTRL_CHG: - status = HAL_I2C_Mem_Read(&hi2c2, 0x68, XPOWERS_AXP2101_CHGLED_SET_CTRL, 1, ®_value, 1, 60); + status = HAL_I2C_Mem_Read(&hi2c2, AXP2101_DEV_I2C_ID, XPOWERS_AXP2101_CHGLED_SET_CTRL, 1, ®_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, ®_value, 1, 60); + status = HAL_I2C_Mem_Write(&hi2c2, AXP2101_DEV_I2C_ID, XPOWERS_AXP2101_CHGLED_SET_CTRL, 1, ®_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, ®_value, 1, 60); + status = HAL_I2C_Mem_Read(&hi2c2, AXP2101_DEV_I2C_ID, XPOWERS_AXP2101_LOW_BAT_WARN_SET, 1, ®_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, ®_value, 1, 60); + return HAL_I2C_Mem_Write(&hi2c2, AXP2101_DEV_I2C_ID, XPOWERS_AXP2101_LOW_BAT_WARN_SET, 1, ®_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, ®_value, 1, 60); + status = HAL_I2C_Mem_Read(&hi2c2, AXP2101_DEV_I2C_ID, XPOWERS_AXP2101_LOW_BAT_WARN_SET, 1, ®_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, ®_value, 1, 60); + return HAL_I2C_Mem_Write(&hi2c2, AXP2101_DEV_I2C_ID, XPOWERS_AXP2101_LOW_BAT_WARN_SET, 1, ®_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, ®_value, 1, 60); + HAL_I2C_Mem_Read(&hi2c2, AXP2101_DEV_I2C_ID, XPOWERS_AXP2101_STATUS2, 1, ®_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); } diff --git a/Core/Src/batt.c b/Core/Src/batt.c index fb5d5a5..2b9d631 100644 --- a/Core/Src/batt.c +++ b/Core/Src/batt.c @@ -13,14 +13,15 @@ void show_bat_segs(void) { if (AXP2101_getBatteryPercent(&pcnt) != HAL_OK) return; uint8_t prev_state = (LL_GPIO_IsOutputPinSet(SYS_LED_GPIO_Port, SYS_LED_Pin) == 0); - uint8_t blink_cnt; + uint8_t blink_cnt = 1; - if(pcnt > 0 && pcnt < 33) - blink_cnt = 1; - else if(pcnt >= 33 && pcnt < 66) - blink_cnt = 1; + //if(pcnt > 0 && pcnt < 33) + // blink_cnt = 1; + //else + if(pcnt >= 33 && pcnt < 66) + blink_cnt = 2; else if(pcnt >= 66 && pcnt <= 100) - blink_cnt = 1; + blink_cnt = 3; flash_one_time(blink_cnt, prev_state); @@ -34,7 +35,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); diff --git a/Core/Src/eeprom.c b/Core/Src/eeprom.c index 5d7023a..4ee977b 100644 --- a/Core/Src/eeprom.c +++ b/Core/Src/eeprom.c @@ -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; } diff --git a/Core/Src/main.c b/Core/Src/main.c index 34e73ac..2a4e6e4 100644 --- a/Core/Src/main.c +++ b/Core/Src/main.c @@ -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(); diff --git a/Core/Src/regs.c b/Core/Src/regs.c index 78d97c4..b433d46 100644 --- a/Core/Src/regs.c +++ b/Core/Src/regs.c @@ -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();