diff --git a/Makefile b/Makefile
index 753d904baabd65d977832f321cc6ef1f80f9cbe2..f643b3f3d573650f3156b898249b8190008cce89 100755
--- a/Makefile
+++ b/Makefile
@@ -5,8 +5,10 @@ PROJECT_NAME=battery_charger
TARGET_FILES=$(wildcard src/*.c)
TARGET_PROCESSOR=STM32L051C8
-HAL_PATH=$(HOME)/humanoids/stm32_hal/l0
-STM32_LIB_PATH=$(HOME)/humanoids/stm32_libraries
+STM32_HAL_PATH=./stm32_hal
+STM32_LIB_PATH=./stm32_libraries
+
+HAL_PATH=$(STM32_HAL_PATH)/l0
include $(HAL_PATH)/select_processor.mk
@@ -16,14 +18,16 @@ BUILD_PATH=build
UTILS_PATH=$(STM32_LIB_PATH)/utils
COMM_PATH=$(STM32_LIB_PATH)/comm
USART_PATH=$(STM32_LIB_PATH)/l0/usart
+MEMORY_PATH=$(STM32_LIB_PATH)/memory
DYNAMIXEL_PATH=$(STM32_LIB_PATH)/dynamixel_base
+SCHEDULER_PATH=$(STM32_LIB_PATH)/scheduler
COMPILE_OPTS = -mlittle-endian -mcpu=cortex-m0plus -mthumb -mthumb-interwork
-COMPILE_OPTS += -Wall -O2 -fno-common
-#COMPILE_OPTS += -Wall -fno-common
-COMPILE_OPTS += -ffreestanding -nostdlib -D$(PROCESSOR_MACRO)
-INCLUDE_DIRS = -I$(HAL_PATH)/include -I$(HAL_PATH)/include/core -I$(HAL_PATH)/include/devices -I./include
-INCLUDE_DIRS += -I$(UTILS_PATH)/include -I$(COMM_PATH)/include -I$(DYNAMIXEL_PATH)/include -I$(USART_PATH)/include
+COMPILE_OPTS += -Wall -O2 -fno-common -DUSE_HAL_DRIVER
+#COMPILE_OPTS += -Wall -fno-common -DUSE_HAL_DRIVER
+COMPILE_OPTS += -ffreestanding -nostdlib -D$(PROCESSOR_MACRO) -DHSE_VALUE=8000000 -imacros ./include/battery_charger_conf.h
+INCLUDE_DIRS = -I$(HAL_PATH)/include -I$(HAL_PATH)/include/core -I$(HAL_PATH)/include/devices
+INCLUDE_DIRS += -I$(UTILS_PATH)/include -I$(COMM_PATH)/include -I$(MEMORY_PATH)/include -I$(DYNAMIXEL_PATH)/include -I$(USART_PATH)/include -I$(SCHEDULER_PATH)/include -I./include
TCHAIN_PREFIX=arm-none-eabi-
@@ -35,7 +39,6 @@ ASFLAGS = $(COMPILE_OPTS) -c
LD = $(TCHAIN_PREFIX)gcc
LDFLAGS = -mthumb -mcpu=cortex-m0plus -Wl,-Map=$@.map,-cref $(INCLUDE_DIRS) -T $(STM32_LINKER_SCRIPTS_PATH)/$(LINKER_SCRIPT_FILE) --specs=nosys.specs
-EXT_LIB = $(COMM_PATH)/lib/comm_m0plus.a $(UTILS_PATH)/lib/utils_m0plus.a
OBJCP = $(TCHAIN_PREFIX)objcopy
OBJCPFLAGS_HEX = -O ihex
@@ -67,10 +70,14 @@ TARGET_FILES+=$(HAL_PATH)/src/stm32l0xx_hal_cortex.c
TARGET_FILES+=$(USART_PATH)/src/usart1.c
-# dynamixel files
-TARGET_FILES+=$(DYNAMIXEL_PATH)/src/dynamixel.c
-TARGET_FILES+=$(DYNAMIXEL_PATH)/src/dynamixel2.c
-TARGET_FILES+=$(DYNAMIXEL_PATH)/src/dynamixel_slave.c
+TARGET_FILES+=$(wildcard $(UTILS_PATH)/src/*.c)
+TARGET_FILES+=$(wildcard $(COMM_PATH)/src/*.c)
+TARGET_FILES+=$(wildcard $(MEMORY_PATH)/src/*.c)
+TARGET_FILES+=$(DYNAMIXEL_PATH)/src/dynamixel2.c
+TARGET_FILES+=$(DYNAMIXEL_PATH)/src/dynamixel.c
+TARGET_FILES+=$(DYNAMIXEL_PATH)/src/dynamixel_slave.c
+TARGET_FILES+=$(DYNAMIXEL_PATH)/src/dynamixel_slave_device.c
+TARGET_FILES+=$(wildcard $(SCHEDULER_PATH)/src/*.c)
BATTERY_OBJS_TMP = $(notdir $(TARGET_FILES:.c=.o))
BATTERY_OBJS = $(patsubst %,$(BUILD_PATH)/%,$(BATTERY_OBJS_TMP))
@@ -88,11 +95,19 @@ $(BUILD_PATH)/%.o: $(HAL_PATH)/src/%.c
$(CC) -c $(CFLAGS) -o $@ $<
$(BUILD_PATH)/%.o: $(USART_PATH)/src/%.c
$(CC) -c $(CFLAGS) -o $@ $<
+$(BUILD_PATH)/%.o: $(UTILS_PATH)/src/%.c
+ $(CC) -c $(CFLAGS) -o $@ $<
+$(BUILD_PATH)/%.o: $(COMM_PATH)/src/%.c
+ $(CC) -c $(CFLAGS) -o $@ $<
+$(BUILD_PATH)/%.o: $(MEMORY_PATH)/src/%.c
+ $(CC) -c $(CFLAGS) -o $@ $<
$(BUILD_PATH)/%.o: $(DYNAMIXEL_PATH)/src/%.c
$(CC) -c $(CFLAGS) -o $@ $<
+$(BUILD_PATH)/%.o: $(SCHEDULER_PATH)/src/%.c
+ $(CC) -c $(CFLAGS) -o $@ $<
$(MAIN_OUT_ELF): mkdir_build $(BATTERY_OBJS) $(BUID_PATH)/$(STARTUP_FILE:.s=.o)
- $(LD) $(LDFLAGS) $(BATTERY_OBJS) $(BUILD_PATH)/$(STARTUP_FILE:.s=.o) $(EXT_LIB) --output $@
+ $(LD) $(LDFLAGS) $(BATTERY_OBJS) $(BUILD_PATH)/$(STARTUP_FILE:.s=.o) --output $@
$(MAIN_OUT_HEX): $(MAIN_OUT_ELF)
$(OBJCP) $(OBJCPFLAGS_HEX) $< $@
diff --git a/include/battery_charger_conf.h b/include/battery_charger_conf.h
new file mode 100644
index 0000000000000000000000000000000000000000..ea087add5651b7561447c8b673efe81b62a4446a
--- /dev/null
+++ b/include/battery_charger_conf.h
@@ -0,0 +1,54 @@
+#ifndef _BATTERY_CHARGER_CONF_H
+#define _BATTERY_CHARGER_CONF_H
+
+#define RAM_SIZE 128
+#define EEPROM_SIZE 32
+
+/* Dynamixel slave configuration */
+#define EEPROM_DYN_SLAVE_BASE_ADDRESS1 ((unsigned short int)0x0000)
+#define EEPROM_DYN_SLAVE_BASE_ADDRESS2 ((unsigned short int)0x0010)
+
+#define DEFAULT_DEVICE_MODEL 0x8000
+#define DEFAULT_FIRMWARE_VERSION 0x0001
+#define DEFAULT_DEVICE_ID 0x00C0
+#define DEFAULT_BAUDRATE 0x0001
+#define DEFAULT_RETURN_DELAY 0x0000
+#define DEFAULT_RETURN_LEVEL 0x0002
+
+#define MAX_DYN_SLAVE_TX_BUFFER_LEN 256
+#define MAX_DYN_SLAVE_RX_BUFFER_LEN 256
+#define MAX_DYN_SLAVE_REG_BUFFER_LEN 256
+#define MAX_NUM_SLAVE_DEVICES 4
+
+/* buzzer registers base address */
+#define RAM_BUZZER_BASE_ADDRESS ((unsigned short int)0x0020)
+#define EEPROM_BUZZER_BASE_ADDRESS1 ((unsigned short int)0x0006)
+
+#define DEFAULT_WARNING_TIME_OFFSET 0x01
+#define DEFAULT_WARNING_TIME_HIST_OFFSET 0x01
+#define DEFAULT_WARNING_FREQ_OFFSET 0x01B8
+#define DEFAULT_WARNING_TIME_ON_OFFSET 0x0001
+#define DEFAULT_WARNING_TIME_OFF_OFFSET 0x001E
+
+#define EEPROM_BUZZER_BASE_ADDRESS2 ((unsigned short int)0x0011)
+
+#define DEFAULT_ERROR_TIME_OFFSET 0x05
+#define DEFAULT_ERROR_TIME_HIST_OFFSET 0x01
+#define DEFAULT_ERROR_FREQ_OFFSET 0x01B8
+#define DEFAULT_ERROR_TIME_ON_OFFSET 0x0001
+#define DEFAULT_ERROR_TIME_OFF_OFFSET 0x0005
+
+/* buzzer registers base address */
+#define RAM_CHARGER_BASE_ADDRESS ((unsigned short int)0x004B)
+#define EEPROM_CHARGER_BASE_ADDRESS1 ((unsigned short int)0x000E)
+
+#define DEFAULT_CHARGER_ADDR 0x12
+#define DEFAULT_FUEL_GAUGE_ADDR 0x16
+
+#define EEPROM_CHARGER_BASE_ADDRESS2 ((unsigned short int)0x0019)
+
+#define DEFAULT_INPUT_MAX_CURRENT_OFFSET 0x1194
+#define DEFAULT_OUTPUT_CURRENT_OFFSET 0x03E8
+#define DEFAULT_OUTPUT_VOLTAGE_OFFSET 0x2EE0
+
+#endif
diff --git a/include/battery_dyn_slave.h b/include/battery_dyn_slave.h
index 3c6c46b51f5d7bdb3a718468daa2442e0b23c1c0..1f196f93f945dab4333eed411a71587cb6b4c702 100644
--- a/include/battery_dyn_slave.h
+++ b/include/battery_dyn_slave.h
@@ -2,17 +2,13 @@
#define _BATTERY_DYN_SLAVE_H
#include "stm32l0xx_hal.h"
-#include "stm32_time.h"
-#include "comm.h"
-
-#define MAX_DYN_SLAVE_TX_BUFFER_LEN 256
-#define MAX_DYN_SLAVE_RX_BUFFER_LEN 256
-#define MAX_DYN_SLAVE_REG_BUFFER_LEN 256
-
#include "dynamixel_slave.h"
+#include "dynamixel_slave_device.h"
+#include "scheduler.h"
+#include "memory.h"
-extern TDynamixelSlave battery_dyn_slave;
-
-void battery_dyn_slave_init(void);
+void battery_dyn_slave_init(TMemory **memory,TScheduler *scheduler);
+void battery_dyn_slave_start(void);
+void battery_dyn_slave_stop(void);
#endif
diff --git a/include/buzzer.h b/include/buzzer.h
index d9a2ec7bd1338534726a2f58ecb6554010690382..5cb76a8aa07bf30d1b3529fe3e02e04db50ea0a7 100644
--- a/include/buzzer.h
+++ b/include/buzzer.h
@@ -2,6 +2,7 @@
#define _BUZZER_H
#include "stm32l0xx_hal.h"
+#include "memory.h"
/* musical notes */
typedef enum {NO_NOTE=0,
@@ -13,7 +14,23 @@ typedef enum {NO_NOTE=0,
LA_NOTE=440, // 440 Hz
SI_NOTE=493} note_t; // 493 Hz
-void buzzer_init(void);
+typedef struct
+{
+ note_t current_note;
+ uint16_t current_time_on;
+ uint32_t time_on_count;
+ uint16_t current_time_off;
+ uint32_t time_off_count;
+ uint8_t active;
+ uint8_t alarm_enabled;
+ TMemModule mem_module;
+ TMemory *memory;
+ unsigned short int ram_base_address;
+ unsigned short int eeprom_base_address1;
+ unsigned short int eeprom_base_address2;
+}TBuzzer;
+
+unsigned char buzzer_init(TMemory *memory,unsigned short int ram_base_address, unsigned short int eeprom_base_address1, unsigned short int eeprom_base_address2);
void buzzer_start(void);
void buzzer_stop(void);
void buzzer_enable_alarm(void);
@@ -21,4 +38,20 @@ void buzzer_disable_alarm(void);
uint8_t buzzer_is_alarm_enabled(void);
uint8_t buzzer_is_active(void);
+uint8_t buzzer_get_warning_time(void);
+uint8_t buzzer_get_warning_time_hist(void);
+uint16_t buzzer_get_warning_freq(void);
+uint16_t buzzer_get_warning_time_on(void);
+uint16_t buzzer_get_warning_time_off(void);
+
+uint8_t buzzer_get_error_time(void);
+uint8_t buzzer_get_error_time_hist(void);
+uint16_t buzzer_get_error_freq(void);
+uint16_t buzzer_get_error_time_on(void);
+uint16_t buzzer_get_error_time_off(void);
+
+void buzzer_set_freq(uint16_t freq);
+void buzzer_set_time_on(uint16_t time);
+void buzzer_set_time_off(uint16_t time);
+
#endif
diff --git a/include/buzzer_registers.h b/include/buzzer_registers.h
new file mode 100644
index 0000000000000000000000000000000000000000..15dd150749e95e8d84aaa578bb11d58a9c0cede5
--- /dev/null
+++ b/include/buzzer_registers.h
@@ -0,0 +1,28 @@
+#ifndef _BUZZER_REGISTERS_H
+#define _BUZZER_REGISTERS_H
+
+#define EEPROM_BUZZER_LENGTH1 8
+
+#define BUZZER_WARNING_TIME_OFFSET 0
+#define BUZZER_WARNING_TIME_HIST_OFFSET 1
+#define BUZZER_WARNING_FREQ_OFFSET 2
+#define BUZZER_WARNING_TIME_ON_OFFSET 4
+#define BUZZER_WARNING_TIME_OFF_OFFSET 6
+
+#define EEPROM_BUZZER_LENGTH2 8
+
+#define BUZZER_ERROR_TIME_OFFSET 0
+#define BUZZER_ERROR_TIME_HIST_OFFSET 1
+#define BUZZER_ERROR_FREQ_OFFSET 2
+#define BUZZER_ERROR_TIME_ON_OFFSET 4
+#define BUZZER_ERROR_TIME_OFF_OFFSET 6
+
+#define RAM_BUZZER_LENGTH 8
+
+#define BUZZER_CONTROL_OFFSET 0
+#define BUZZER_STATUS_OFFSET 1
+#define BUZZER_FREQ_OFFSET 2
+#define BUZZER_TIME_ON_OFFSET 4
+#define BUZZER_TIME_OFF_OFFSET 6
+
+#endif
diff --git a/include/charger.h b/include/charger.h
index d09f853ad09da12260d2d9976aadb13f71c85406..5258c944ead2a1484668c2cea025ce16c5a91889 100644
--- a/include/charger.h
+++ b/include/charger.h
@@ -2,13 +2,25 @@
#define _CHARGER_H
#include "stm32l0xx_hal.h"
+#include "memory.h"
typedef enum{batt_not_present,
batt_okay,
batt_warning,
batt_error} batt_state_t;
-void charger_init(void);
+typedef struct
+{
+ uint32_t vicm;
+ batt_state_t battery_state;
+ TMemModule mem_module;
+ TMemory *memory;
+ unsigned short int ram_base_address;
+ unsigned short int eeprom_base_address1;
+ unsigned short int eeprom_base_address2;
+}TCharger;
+
+unsigned char charger_init(TMemory *memory,unsigned short int ram_base_address,unsigned short int eeprom_base_address1, unsigned short int eeprom_base_address2);
void charger_enable(void);
void charger_disable(void);
void charger_ckeck_alarm(void);
diff --git a/include/charger_registers.h b/include/charger_registers.h
new file mode 100644
index 0000000000000000000000000000000000000000..27813827cf89f6e8c4d8bd783dfd2fdcba64b952
--- /dev/null
+++ b/include/charger_registers.h
@@ -0,0 +1,41 @@
+#ifndef _CHARGER_REGISTERS_H
+#define _CHARGER_REGISTERS_H
+
+#define EEPROM_CHARGER_LENGTH1 2
+
+#define CHARGER_CHARGER_ADDR_OFFSET 0
+#define CHARGER_FUEL_GAUGE_ADDR_OFFSET 1
+
+#define EEPROM_CHARGER_LENGTH2 6
+
+#define CHARGER_INPUT_MAX_CURRENT_OFFSET 0
+#define CHARGER_OUTPUT_CURRENT_OFFSET 2
+#define CHARGER_OUTPUT_VOLTAGE_OFFSET 4
+
+#define RAM_CHARGER_LENGTH 43
+
+#define CHARGER_STATUS_OFFSET 0
+#define CHARGER_INPUT_CURRENT_OFFSET 1
+#define CHARGER_CHARGE_CURRENT_OFFSET 3
+#define CHARGER_CHARGE_VOLTAGE_OFFSET 5
+#define CHARGER_LIMIT_CURRENT_OFFSET 7
+#define CHARGER_TEMPERATURE_OFFSET 9
+#define CHARGER_VOLTAGE_OFFSET 11
+#define CHARGER_CURRENT_OFFSET 13
+#define CHARGER_AVG_CURRENT_OFFSET 15
+#define CHARGER_RELATIVE_SOC_OFFSET 17
+#define CHARGER_ABSOLUTE_SOC_OFFSET 18
+#define CHARGER_REMAINING_CAP_OFFSET 19
+#define CHARGER_FULL_CHARGE_CAP_OFFSET 21
+#define CHARGER_RUN_TIME_EMPTY_OFFSET 23
+#define CHARGER_AVG_TIME_EMPTY_OFFSET 25
+#define CHARGER_AVG_TIME_FULL_OFFSET 27
+#define CHARGER_BATTERY_STATUS_OFFSET 29
+#define CHARGER_DESIGN_CAP_OFFSET 31
+#define CHARGER_DESIGN_VOLTAGE_OFFSET 33
+#define CHARGER_CELL1_VOLTAGE_OFFSET 35
+#define CHARGER_CELL2_VOLTAGE_OFFSET 37
+#define CHARGER_CELL3_VOLTAGE_OFFSET 39
+#define CHARGER_CELL4_VOLTAGE_OFFSET 41
+
+#endif
diff --git a/include/dyn_battery.h b/include/dyn_battery.h
deleted file mode 100644
index 9387231ebe81e1e65b2a2f50d6df73ea62feb924..0000000000000000000000000000000000000000
--- a/include/dyn_battery.h
+++ /dev/null
@@ -1,98 +0,0 @@
-#ifndef _DYN_BATTERY_H
-#define _DYN_BATTERY_H
-
-#define RAM_SIZE 82
-#define EEPROM_SIZE 31
-
-#define DYN_BATTERY_MODEL 0x8000
-#define DYN_BATTERY_VERSION 0x01
-
-/* battery charger memory map */
-/* memory map */
-typedef enum {
- BATTERY_MODEL_NUMBER_L = 0x00,
- BATTERY_MODEL_NUMBER_H = 0x01,
- BATTERY_VERSION = 0x02,
- BATTERY_ID = 0x03,
- BATTERY_BAUD_RATE = 0x04,
- BATTERY_RETURN_DELAY_TIME = 0x05,
- BATTERY_WARNING_TIME = 0x06,
- BATTERY_WARNING_TIME_HIST = 0x07,
- BATTERY_WARNING_FREQ_L = 0x08,
- BATTERY_WARNING_FREQ_H = 0x09,
- BATTERY_WARNING_TIME_ON_L = 0x0A,
- BATTERY_WARNING_TIME_ON_H = 0x0B,
- BATTERY_WARNING_TIME_OFF_L = 0x0C,
- BATTERY_WARNING_TIME_OFF_H = 0x0D,
- BATTERY_CHARGER_ADDR = 0x0E,
- BATTERY_FUEL_GAUGE_ADDR = 0x0F,
- BATTERY_STATUS_RETURN_LEVEL = 0x10,
- BATTERY_ERROR_TIME = 0x11,
- BATTERY_ERROR_TIME_HIST = 0x12,
- BATTERY_ERROR_FREQ_L = 0x13,
- BATTERY_ERROR_FREQ_H = 0x14,
- BATTERY_ERROR_TIME_ON_L = 0x15,
- BATTERY_ERROR_TIME_ON_H = 0x16,
- BATTERY_ERROR_TIME_OFF_L = 0x17,
- BATTERY_ERROR_TIME_OFF_H = 0x18,
- BATTERY_INPUT_MAX_CURRENT_L = 0x19,
- BATTERY_INPUT_MAX_CURRENT_H = 0x1A,
- BATTERY_OUTPUT_CURRENT_L = 0x1B,
- BATTERY_OUTPUT_CURRENT_H = 0x1C,
- BATTERY_OUTPUT_VOLTAGE_L = 0x1D,
- BATTERY_OUTPUT_VOLTAGE_H = 0x1E,
- /* RAM */
- BATTERY_CHARGER_STATUS = 0x1F,
- BATTERY_INPUT_CURRENT_L = 0x20,
- BATTERY_INPUT_CURRENT_H = 0x21,
- BATTERY_CHARGE_CURRENT_L = 0x22,
- BATTERY_CHARGE_CURRENT_H = 0x23,
- BATTERY_CHARGE_VOLTAGE_L = 0x24,
- BATTERY_CHARGE_VOLTAGE_H = 0x25,
- BATTERY_LIMIT_CURRENT_L = 0x26,
- BATTERY_LIMIT_CURRENT_H = 0x27,
- BATTERY_TEMPERATURE_L = 0x28,
- BATTERY_TEMPERATURE_H = 0x29,
- BATTERY_VOLTAGE_L = 0x2A,
- BATTERY_VOLTAGE_H = 0x2B,
- BATTERY_CURRENT_L = 0x2C,
- BATTERY_CURRENT_H = 0x2D,
- BATTERY_AVG_CURRENT_L = 0x2E,
- BATTERY_AVG_CURRENT_H = 0x2F,
- BATTERY_RELATIVE_SOC = 0x30,
- BATTERY_ABSOLUTE_SOC = 0x31,
- BATTERY_REMAINING_CAP_L = 0x32,
- BATTERY_REMAINING_CAP_H = 0x33,
- BATTERY_FULL_CHARGE_CAP_L = 0x34,
- BATTERY_FULL_CHARGE_CAP_H = 0x35,
- BATTERY_RUN_TIME_EMPTY_L = 0x36,
- BATTERY_RUN_TIME_EMPTY_H = 0x37,
- BATTERY_AVG_TIME_EMPTY_L = 0x38,
- BATTERY_AVG_TIME_EMPTY_H = 0x39,
- BATTERY_AVG_TIME_FULL_L = 0x3A,
- BATTERY_AVG_TIME_FULL_H = 0x3B,
- BATTERY_STATUS_L = 0x3C,
- BATTERY_STATUS_H = 0x3D,
- BATTERY_DESIGN_CAP_L = 0x3E,
- BATTERY_DESIGN_CAP_H = 0x3F,
- BATTERY_DESIGN_VOLTAGE_L = 0x40,
- BATTERY_DESIGN_VOLTAGE_H = 0x41,
- BATTERY_CELL1_VOLTAGE_L = 0x42,
- BATTERY_CELL1_VOLTAGE_H = 0x43,
- BATTERY_CELL2_VOLTAGE_L = 0x44,
- BATTERY_CELL2_VOLTAGE_H = 0x45,
- BATTERY_CELL3_VOLTAGE_L = 0x46,
- BATTERY_CELL3_VOLTAGE_H = 0x47,
- BATTERY_CELL4_VOLTAGE_L = 0x48,
- BATTERY_CELL4_VOLTAGE_H = 0x49,
- BATTERY_BUZZER_CONTROL = 0x4A,
- BATTERY_BUZZER_STATUS = 0x4B,
- BATTERY_BUZZER_FREQ_L = 0x4C,
- BATTERY_BUZZER_FREQ_H = 0x4D,
- BATTERY_BUZZER_TIME_ON_L = 0x4E,
- BATTERY_BUZZER_TIME_ON_H = 0x4F,
- BATTERY_BUZZER_TIME_OFF_L = 0x50,
- BATTERY_BUZZER_TIME_OFF_H = 0x51
-} battery_registers_t;
-
-#endif
diff --git a/include/eeprom.h b/include/eeprom.h
new file mode 100644
index 0000000000000000000000000000000000000000..3d1fd83fe1ced50fd656f745790125f32e72e792
--- /dev/null
+++ b/include/eeprom.h
@@ -0,0 +1,10 @@
+#ifndef _EEPROM_H
+#define _EEPROM_H
+
+#include "stm32l0xx_hal.h"
+
+void eeprom_init(void);
+uint16_t eeprom_read(unsigned short int address, unsigned short int *data);
+uint16_t eeprom_write(unsigned short int address, unsigned short int data);
+
+#endif
diff --git a/include/mem.h b/include/mem.h
deleted file mode 100644
index 973794d991f4a857ce722abcec930d0201c60e68..0000000000000000000000000000000000000000
--- a/include/mem.h
+++ /dev/null
@@ -1,20 +0,0 @@
-#ifndef _MEM_H
-#define _MEM_H
-
-#include "stm32l0xx_hal.h"
-#include "dyn_battery.h"
-
-#define RAM_SUCCESS 0
-#define RAM_BAD_ADDRESS 1
-
-#define DEFAULT_CHARGER_ADDR 0x12
-#define DEFAULT_FUEL_GAUGE_ADDR 0x16
-
-
-extern uint8_t ram_data[RAM_SIZE];
-
-void mem_init(void);
-uint8_t mem_read(unsigned char address, unsigned char length, unsigned char *data);
-uint8_t mem_write(unsigned char address, unsigned char length, unsigned char *data);
-
-#endif
diff --git a/src/battery_charger.c b/src/battery_charger.c
index 493e6b794593401dc2c65704309cbad5daebf6d3..d785d50142541ca534b8ee10f694a4224d9c98ec 100644
--- a/src/battery_charger.c
+++ b/src/battery_charger.c
@@ -2,35 +2,39 @@
#include "gpio.h"
#include "buzzer.h"
#include "battery_time.h"
+#include "battery_sch.h"
#include "battery_dyn_slave.h"
#include "charger.h"
-#include "mem.h"
+#include "eeprom.h"
-void SysTick_Handler(void)
-{
- HAL_IncTick();
-}
+TMemory *memory;
+TScheduler *scheduler;
-int32_t main(void)
+int main(void)
{
/* initialize the HAL module */
HAL_Init();
+ /* initialize EEPROM */
+ eeprom_init();
+ // initialize time module
+ battery_time_init();
+ // initialze the scheduler
+ scheduler=battery_sch_init();
+ // initialize the dynamixel slave interface
+ battery_dyn_slave_init(&memory,scheduler);
// initialize the gpio module
gpio_init();
- // initialize memory
- mem_init();
// initialize the buzzer module
- buzzer_init();
- // initialize the timer module
- battery_time_init();
- // initialize the dynamixel interface
- battery_dyn_slave_init();
+ buzzer_init(memory,RAM_BUZZER_BASE_ADDRESS,EEPROM_BUZZER_BASE_ADDRESS1,EEPROM_BUZZER_BASE_ADDRESS2);
// initialize the smbus interface
- charger_init();
+ charger_init(memory,RAM_CHARGER_BASE_ADDRESS,EEPROM_CHARGER_BASE_ADDRESS1,EEPROM_CHARGER_BASE_ADDRESS2);
+ // initialize the Dynamixel RAM memory space
+ ram_init(memory);
+
+ battery_dyn_slave_start();
- while(1)
- {
- dyn_slave_loop(&battery_dyn_slave);
+ while(1)/* main function does not return */
+ {
charger_ckeck_alarm();
}
}
diff --git a/src/battery_dyn_slave.c b/src/battery_dyn_slave.c
index 95cc7b750b4203dadccb517ed43721243458d7bf..dd7c947bed696cfb31fadbb7caa48dfc890144dd 100644
--- a/src/battery_dyn_slave.c
+++ b/src/battery_dyn_slave.c
@@ -2,7 +2,7 @@
#include "battery_time.h"
#include "usart1.h"
#include "gpio.h"
-#include "mem.h"
+#include "eeprom.h"
#include "charger.h"
#include "buzzer.h"
@@ -14,111 +14,51 @@
#define TX_EN_PIN GPIO_PIN_8
#define TX_EN_GPIO_PORT GPIOA
+/* private variables */
/* private variables */
TDynamixelSlave battery_dyn_slave;
-TTime battery_timer;
-TComm battery_comm;
+TDynamixelSlaveDevice battery_dyn_slave_device;
+TTime battery_dyn_slave_timer;
+TComm battery_dyn_slave_comm;
+UART_InitTypeDef battery_comm_init;
+TScheduler *battery_dyn_slave_sch;
+
+/* memory module */
+TMemory *battery_dyn_slave_memory;
/* private functions */
-void battery_dyn_slave_set_rx_mode(void)
+unsigned char battery_on_read(unsigned short int address,unsigned short int length,unsigned char *data)
{
- HAL_GPIO_WritePin(TX_EN_GPIO_PORT,TX_EN_PIN,GPIO_PIN_SET);
- HAL_GPIO_WritePin(RX_EN_GPIO_PORT,RX_EN_PIN,GPIO_PIN_RESET);
-}
+ mem_do_read(battery_dyn_slave_memory,address,length,data);
-void battery_dyn_slave_set_tx_mode(void)
-{
- HAL_GPIO_WritePin(RX_EN_GPIO_PORT,RX_EN_PIN,GPIO_PIN_SET);
- HAL_GPIO_WritePin(TX_EN_GPIO_PORT,TX_EN_PIN,GPIO_PIN_RESET);
+ return 0x00;
}
-uint32_t battery_dyn_slave_get_baudrate(void)
+unsigned char battery_on_write(unsigned short int address,unsigned short int length,unsigned char *data)
{
- return 2000000/(ram_data[BATTERY_BAUD_RATE]+1);
+ mem_do_write(battery_dyn_slave_memory,address,length,data);
+
+ return 0x00;
}
-void battery_dyn_slave_config_uart(void)
+void battery_on_ping(void)
{
- UART_AdvFeatureInitTypeDef AdvInit;
- UART_InitTypeDef Init;
-
- Init.BaudRate = battery_dyn_slave_get_baudrate();
- Init.WordLength = UART_WORDLENGTH_8B;
- Init.StopBits = UART_STOPBITS_1;
- Init.Parity = UART_PARITY_NONE;
- Init.Mode = UART_MODE_TX_RX;
- Init.HwFlowCtl = UART_HWCONTROL_NONE;
- Init.OverSampling = UART_OVERSAMPLING_16;
- Init.OneBitSampling = UART_ONEBIT_SAMPLING_DISABLED;
- AdvInit.AdvFeatureInit = UART_ADVFEATURE_TXINVERT_INIT|UART_ADVFEATURE_RXINVERT_INIT;
- AdvInit.TxPinLevelInvert = UART_ADVFEATURE_TXINV_ENABLE;
- AdvInit.RxPinLevelInvert = UART_ADVFEATURE_RXINV_ENABLE;
-
- usart1_config(&battery_comm,&Init,&AdvInit);
}
-unsigned char battery_on_read(unsigned short int address,unsigned short int length,unsigned char *data)
+void battery_dyn_slave_set_rx_mode(void)
{
- if(mem_read(address,length,data)==RAM_SUCCESS)
- return DYN_NO_ERROR;
- else
- return DYN_INST_ERROR;
+ HAL_GPIO_WritePin(TX_EN_GPIO_PORT,TX_EN_PIN,GPIO_PIN_SET);
+ HAL_GPIO_WritePin(RX_EN_GPIO_PORT,RX_EN_PIN,GPIO_PIN_RESET);
}
-unsigned char battery_on_write(unsigned short int address,unsigned short int length,unsigned char *data)
+void battery_dyn_slave_set_tx_mode(void)
{
- batt_state_t state;
- uint16_t i,num=0;
-
- if(mem_write(address,length,data)==RAM_SUCCESS)
- {
- for(i=address;i<address+length;i++)
- {
- if(i==BATTERY_BAUD_RATE)
- battery_dyn_slave_config_uart();
- else if(i==BATTERY_ID)
- dyn_slave_set_address(&battery_dyn_slave,data[num]);
- else if(i==BATTERY_INPUT_MAX_CURRENT_H)
- charger_set_limit_curret();
- else if(i==BATTERY_OUTPUT_CURRENT_H)
- charger_set_charge_curret();
- else if(i==BATTERY_OUTPUT_VOLTAGE_H)
- charger_set_charge_voltage();
- else if(i==BATTERY_BUZZER_CONTROL)
- {
- if(data[num]&0x01)// enable buzzer alarm
- buzzer_enable_alarm();
- else// disable buzzer alarm
- buzzer_disable_alarm();
- if(buzzer_is_alarm_enabled()==0x00)
- {
- if(data[num]&0x02)// start buzzer
- buzzer_start();
- else
- buzzer_stop();
- }
- else
- {
- state=charger_get_battery_state();
- if(state==batt_not_present || state==batt_okay)
- {
- if(data[num]&0x02)// start buzzer
- buzzer_start();
- else
- buzzer_stop();
- }
- }
- }
- num++;
- }
- return DYN_NO_ERROR;
- }
- else
- return DYN_INST_ERROR;
+ HAL_GPIO_WritePin(RX_EN_GPIO_PORT,RX_EN_PIN,GPIO_PIN_SET);
+ HAL_GPIO_WritePin(TX_EN_GPIO_PORT,TX_EN_PIN,GPIO_PIN_RESET);
}
/* public functions */
-void battery_dyn_slave_init(void)
+void battery_dyn_slave_init(TMemory **memory,TScheduler *scheduler)
{
GPIO_InitTypeDef GPIO_InitStructure;
TUSART_IRQ_Priorities priorities;
@@ -126,7 +66,7 @@ void battery_dyn_slave_init(void)
UART_InitTypeDef Init;
// initialize timer structure
- time_init(&battery_timer,battery_time_get_counts_per_us(),battery_time_get_counts);
+ time_init(&battery_dyn_slave_timer,battery_time_get_counts_per_us(),battery_time_get_counts);
// initialize GPIO
ENABLE_RX_EN_GPIO_CLK;
ENABLE_TX_EN_GPIO_CLK;
@@ -140,10 +80,9 @@ void battery_dyn_slave_init(void)
GPIO_InitStructure.Pin = TX_EN_PIN;
HAL_GPIO_Init(TX_EN_GPIO_PORT, &GPIO_InitStructure);
- battery_dyn_slave_set_rx_mode();
/* initialize the comm object */
- comm_init(&battery_comm,0x01,&battery_timer);
- Init.BaudRate = battery_dyn_slave_get_baudrate();
+ comm_init(&battery_dyn_slave_comm,0x01,&battery_dyn_slave_timer);
+ Init.BaudRate = 2000000/(DEFAULT_BAUDRATE+1);
Init.WordLength = UART_WORDLENGTH_8B;
Init.StopBits = UART_STOPBITS_1;
Init.Parity = UART_PARITY_NONE;
@@ -154,16 +93,41 @@ void battery_dyn_slave_init(void)
AdvInit.AdvFeatureInit = UART_ADVFEATURE_TXINVERT_INIT|UART_ADVFEATURE_RXINVERT_INIT;
AdvInit.TxPinLevelInvert = UART_ADVFEATURE_TXINV_ENABLE;
AdvInit.RxPinLevelInvert = UART_ADVFEATURE_RXINV_ENABLE;
+
priorities.irq_priority=0;
priorities.irq_subpriority=0;
priorities.dma_priority=0;
priorities.dma_subpriority=1;
- usart1_init(&battery_comm,&Init,&AdvInit,&priorities);
- dyn_slave_init(&battery_dyn_slave,&battery_comm,ram_data[BATTERY_ID],DYN_VER2);
- battery_dyn_slave.set_rx_mode=battery_dyn_slave_set_rx_mode;
+
+ usart1_init(&battery_dyn_slave_comm,&Init,&AdvInit,&priorities);
+
+ // initialize slave device
+ dyn_slave_device_init(&battery_dyn_slave_device,DEFAULT_DEVICE_ID,EEPROM_DYN_SLAVE_BASE_ADDRESS1,EEPROM_DYN_SLAVE_BASE_ADDRESS2);
+ battery_dyn_slave_device.on_read=battery_on_read;
+ battery_dyn_slave_device.on_write=battery_on_write;
+ battery_dyn_slave_device.on_ping=battery_on_ping;
+ dyn_slave_device_set_return_delay(&battery_dyn_slave_device,DEFAULT_RETURN_DELAY);
+ dyn_slave_device_set_return_level(&battery_dyn_slave_device,DEFAULT_RETURN_LEVEL);
+ (*memory)=dyn_slave_device_get_memory(&battery_dyn_slave_device);
+ /* initialize memory structure */
+ battery_dyn_slave_memory=dyn_slave_device_get_memory(&battery_dyn_slave_device);
+ battery_dyn_slave_memory->eeprom_write_data=eeprom_write;
+ battery_dyn_slave_memory->eeprom_read_data=eeprom_read;
+ // initialize slave
+ dyn_slave_init(&battery_dyn_slave,&battery_dyn_slave_comm,scheduler,SCHED_CH1,DYN_VER1);
+ battery_dyn_slave.set_baudrate=usart1_set_baudrate;
battery_dyn_slave.set_tx_mode=battery_dyn_slave_set_tx_mode;
- battery_dyn_slave.on_read=battery_on_read;
- battery_dyn_slave.on_write=battery_on_write;
- dyn_slave_set_return_delay(&battery_dyn_slave,ram_data[BATTERY_RETURN_DELAY_TIME]);
- dyn_slave_set_return_level(&battery_dyn_slave,ram_data[BATTERY_STATUS_RETURN_LEVEL]);
+ battery_dyn_slave.set_rx_mode=battery_dyn_slave_set_rx_mode;
+ dyn_slave_add_device(&battery_dyn_slave,&battery_dyn_slave_device);
}
+
+void battery_dyn_slave_start(void)
+{
+ dyn_slave_start(&battery_dyn_slave);
+}
+
+void battery_dyn_slave_stop(void)
+{
+ dyn_slave_stop(&battery_dyn_slave);
+}
+
diff --git a/src/battery_time.c b/src/battery_time.c
index 08668954d440ca5befddb92870617f54419e6152..55fed6b2992f0ff5c352ee5c59c516e171d33bdd 100644
--- a/src/battery_time.c
+++ b/src/battery_time.c
@@ -1,7 +1,17 @@
#include "battery_time.h"
TIM_HandleTypeDef us_timer_Handle;
-unsigned long long int counts;
+unsigned long long int timer_counts;
+unsigned short int timer_counts_per_us;
+
+void SysTick_Handler(void)
+{
+ /* USER CODE BEGIN SysTick_IRQn 0 */
+ /* USER CODE END SysTick_IRQn 0 */
+ HAL_IncTick();
+ /* USER CODE BEGIN SysTick_IRQn 1 */
+ /* USER CODE END SysTick_IRQn 1 */
+}
void TIM6_IRQHandler(void)
{
@@ -10,13 +20,17 @@ void TIM6_IRQHandler(void)
if(__HAL_TIM_GET_ITSTATUS(&us_timer_Handle, TIM_IT_UPDATE) !=RESET)
{
__HAL_TIM_CLEAR_IT(&us_timer_Handle, TIM_IT_UPDATE);
- counts+=1;
+ timer_counts+=1;
}
}
}
void battery_time_init(void)
{
+ /* initialize internal variables */
+ timer_counts=0;
+ timer_counts_per_us=(SystemCoreClock/1000000)+1;
+
us_timer_Handle.Instance=TIM6;
us_timer_Handle.Init.Period=0xFFFF;
us_timer_Handle.Init.Prescaler=0;
@@ -30,16 +44,14 @@ void battery_time_init(void)
HAL_NVIC_SetPriority(TIM6_IRQn, 2, 0);
HAL_NVIC_EnableIRQ(TIM6_IRQn);
HAL_TIM_Base_Start_IT(&us_timer_Handle);
-
- counts=0;
}
unsigned long long int battery_time_get_counts(void)
{
- return (counts<<16)+__HAL_TIM_GetCounter(&us_timer_Handle);
+ return (timer_counts<<16)+__HAL_TIM_GetCounter(&us_timer_Handle);
}
unsigned int battery_time_get_counts_per_us(void)
{
- return (SystemCoreClock/1000000)+1;
+ return timer_counts_per_us;
}
diff --git a/src/buzzer.c b/src/buzzer.c
index 92630f5e00d51dc4c0adaee6f47e8a8ea1b95df5..d456cf73ccbc2ad9921cb1900c3bd8970e04680d 100644
--- a/src/buzzer.c
+++ b/src/buzzer.c
@@ -1,6 +1,9 @@
#include "buzzer.h"
+#include "buzzer_registers.h"
+#include "charger.h"
#include "gpio.h"
-#include "mem.h"
+#include "eeprom.h"
+#include "ram.h"
#define ENABLE_BUZZER_GPIO_CLK __GPIOA_CLK_ENABLE()
#define LED_BUZZER_PIN GPIO_PIN_1
@@ -13,39 +16,34 @@
/* private variables */
TIM_HandleTypeDef buzzer_TIMHandler;
-note_t buzzer_current_note;
-uint16_t buzzer_current_time_on;
-uint32_t buzzer_time_on_count;
-uint16_t buzzer_current_time_off;
-uint32_t buzzer_time_off_count;
-uint8_t buzzer_active;
-uint8_t buzzer_alarm_enabled;
+
+TBuzzer buzzer;
void BUZZER_TIMER_IRQHandler(void)
{
TIM_OC_InitTypeDef TIM_OCInitStructure;
uint16_t period;
- period = 1000000/buzzer_current_note;
+ period = 1000000/buzzer.current_note;
if(__HAL_TIM_GET_FLAG(&buzzer_TIMHandler, TIM_FLAG_CC1) != RESET)
{
if(__HAL_TIM_GET_ITSTATUS(&buzzer_TIMHandler, TIM_IT_CC1) !=RESET)
{
__HAL_TIM_CLEAR_IT(&buzzer_TIMHandler, TIM_IT_CC1);
- if(buzzer_time_on_count==0)
+ if(buzzer.time_on_count==0)
{
- if(buzzer_current_time_off>0)
+ if(buzzer.current_time_off>0)
{
/* stop PWM output*/
HAL_TIM_PWM_Stop(&buzzer_TIMHandler, TIM_CHANNEL_2);
/* stop time on timer */
HAL_TIM_OC_Stop_IT(&buzzer_TIMHandler,TIM_CHANNEL_1);
/* start time off timer */
- buzzer_time_off_count=(((uint32_t)buzzer_current_time_off)*1000000)/period;
+ buzzer.time_off_count=(((uint32_t)buzzer.current_time_off)*1000000)/period;
TIM_OCInitStructure.OCMode = TIM_OCMODE_TIMING;
TIM_OCInitStructure.OCPolarity = TIM_OCPOLARITY_HIGH;
- if(buzzer_time_off_count==0)
- TIM_OCInitStructure.Pulse = (((uint32_t)buzzer_current_time_off)*1000000)%period;
+ if(buzzer.time_off_count==0)
+ TIM_OCInitStructure.Pulse = (((uint32_t)buzzer.current_time_off)*1000000)%period;
else
TIM_OCInitStructure.Pulse = period;
HAL_TIM_OC_ConfigChannel(&buzzer_TIMHandler, &TIM_OCInitStructure,TIM_CHANNEL_3);
@@ -53,11 +51,11 @@ void BUZZER_TIMER_IRQHandler(void)
}
else
{
- buzzer_time_on_count=(((uint32_t)buzzer_current_time_on)*1000000)/period;
+ buzzer.time_on_count=(((uint32_t)buzzer.current_time_on)*1000000)/period;
TIM_OCInitStructure.OCMode = TIM_OCMODE_TIMING;
TIM_OCInitStructure.OCPolarity = TIM_OCPOLARITY_HIGH;
- if(buzzer_time_on_count==0)
- TIM_OCInitStructure.Pulse = (((uint32_t)buzzer_current_time_on)*1000000)%period;
+ if(buzzer.time_on_count==0)
+ TIM_OCInitStructure.Pulse = (((uint32_t)buzzer.current_time_on)*1000000)%period;
else
TIM_OCInitStructure.Pulse = period;
HAL_TIM_OC_ConfigChannel(&buzzer_TIMHandler, &TIM_OCInitStructure,TIM_CHANNEL_1);
@@ -66,9 +64,9 @@ void BUZZER_TIMER_IRQHandler(void)
}
else
{
- buzzer_time_on_count--;
- if(buzzer_time_on_count==0)
- __HAL_TIM_SetCompare(&buzzer_TIMHandler, TIM_CHANNEL_1, (((uint32_t)buzzer_current_time_on)*1000000)%period);
+ buzzer.time_on_count--;
+ if(buzzer.time_on_count==0)
+ __HAL_TIM_SetCompare(&buzzer_TIMHandler, TIM_CHANNEL_1, (((uint32_t)buzzer.current_time_on)*1000000)%period);
}
}
}
@@ -77,18 +75,18 @@ void BUZZER_TIMER_IRQHandler(void)
if(__HAL_TIM_GET_ITSTATUS(&buzzer_TIMHandler, TIM_IT_CC3) !=RESET)
{
__HAL_TIM_CLEAR_IT(&buzzer_TIMHandler, TIM_IT_CC3);
- if(buzzer_time_off_count==0)
+ if(buzzer.time_off_count==0)
{
/* start PWM output*/
HAL_TIM_PWM_Start(&buzzer_TIMHandler, TIM_CHANNEL_2);
/* stop time on timer */
HAL_TIM_OC_Stop_IT(&buzzer_TIMHandler,TIM_CHANNEL_3);
/* start time off timer */
- buzzer_time_on_count=(((uint32_t)buzzer_current_time_on)*1000000)/period;
+ buzzer.time_on_count=(((uint32_t)buzzer.current_time_on)*1000000)/period;
TIM_OCInitStructure.OCMode = TIM_OCMODE_TIMING;
TIM_OCInitStructure.OCPolarity = TIM_OCPOLARITY_HIGH;
- if(buzzer_time_on_count==0)
- TIM_OCInitStructure.Pulse = (((uint32_t)buzzer_current_time_on)*1000000)%period;
+ if(buzzer.time_on_count==0)
+ TIM_OCInitStructure.Pulse = (((uint32_t)buzzer.current_time_on)*1000000)%period;
else
TIM_OCInitStructure.Pulse = period;
HAL_TIM_OC_ConfigChannel(&buzzer_TIMHandler, &TIM_OCInitStructure,TIM_CHANNEL_1);
@@ -96,16 +94,59 @@ void BUZZER_TIMER_IRQHandler(void)
}
else
{
- buzzer_time_off_count--;
- if(buzzer_time_off_count==0)
- __HAL_TIM_SetCompare(&buzzer_TIMHandler, TIM_CHANNEL_3, (((uint32_t)buzzer_current_time_off)*1000000)%period);
+ buzzer.time_off_count--;
+ if(buzzer.time_off_count==0)
+ __HAL_TIM_SetCompare(&buzzer_TIMHandler, TIM_CHANNEL_3, (((uint32_t)buzzer.current_time_off)*1000000)%period);
}
}
}
}
+void buzzer_write_cmd(void *module,unsigned short int address,unsigned short int length,unsigned char *data)
+{
+ TBuzzer *buzzer=(TBuzzer *)module;
+ unsigned short int ram_offset;
+ batt_state_t state;
+
+ ram_offset=address-buzzer->ram_base_address;
+ if(ram_in_window(buzzer->ram_base_address+BUZZER_CONTROL_OFFSET,1,address,length))
+ {
+ if(data[BUZZER_CONTROL_OFFSET-ram_offset]&0x01)
+ buzzer_enable_alarm();
+ else
+ buzzer_disable_alarm();
+ if(buzzer_is_alarm_enabled()==0x00)
+ {
+ if(data[BUZZER_CONTROL_OFFSET-ram_offset]&0x02)// start buzzer
+ buzzer_start();
+ else
+ buzzer_stop();
+ }
+ else
+ {
+ state=charger_get_battery_state();
+ if(state==batt_not_present || state==batt_okay)
+ {
+ if(data[BUZZER_CONTROL_OFFSET-ram_offset]&0x02)// start buzzer
+ buzzer_start();
+ else
+ buzzer_stop();
+ }
+ }
+ }
+ ram_write_table(buzzer->memory,address,length,data);
+}
+
+void buzzer_read_cmd(void *module,unsigned short int address,unsigned short int length,unsigned char *data)
+{
+ TBuzzer *buzzer=(TBuzzer *)module;
+
+ ram_read_table(buzzer->memory,address,length,data);
+}
+
+
/* public functions */
-void buzzer_init(void)
+unsigned char buzzer_init(TMemory *memory,unsigned short int ram_base_address, unsigned short int eeprom_base_address1, unsigned short int eeprom_base_address2)
{
GPIO_InitTypeDef GPIO_InitStruct;
@@ -127,21 +168,33 @@ void buzzer_init(void)
HAL_NVIC_SetPriority(BUZZER_TIMER_IRQn, 3, 0);
HAL_NVIC_EnableIRQ(BUZZER_TIMER_IRQn);
- ram_data[BATTERY_BUZZER_CONTROL]=0x01;
- ram_data[BATTERY_BUZZER_STATUS]=0x00;
- buzzer_active=0x00;
- buzzer_alarm_enabled=0x01;
- ram_data[BATTERY_BUZZER_FREQ_L]=0xB8;
- ram_data[BATTERY_BUZZER_FREQ_H]=0x01;
- buzzer_current_note=LA_NOTE;
- ram_data[BATTERY_BUZZER_TIME_ON_L]=0x01;
- ram_data[BATTERY_BUZZER_TIME_ON_H]=0x00;
- buzzer_current_time_on=1;
- buzzer_time_on_count=0;
- ram_data[BATTERY_BUZZER_TIME_OFF_L]=0x01;
- ram_data[BATTERY_BUZZER_TIME_OFF_H]=0x00;
- buzzer_current_time_off=1;
- buzzer_time_off_count=0;
+ buzzer.active=0x00;
+ buzzer.alarm_enabled=0x01;
+ buzzer.current_note=LA_NOTE;
+ buzzer.current_time_on=1;
+ buzzer.time_on_count=0;
+ buzzer.current_time_off=1;
+ buzzer.time_off_count=0;
+
+ /* initialize memory module */
+ mem_module_init(&buzzer.mem_module);
+ buzzer.mem_module.write_cmd=buzzer_write_cmd;
+ buzzer.mem_module.read_cmd=buzzer_read_cmd;
+ if(!mem_module_add_ram_segment(&buzzer.mem_module,ram_base_address,RAM_BUZZER_LENGTH))
+ return 0x00;
+ buzzer.ram_base_address=ram_base_address;
+ if(!mem_module_add_eeprom_segment(&buzzer.mem_module,eeprom_base_address1,EEPROM_BUZZER_LENGTH1))
+ return 0x00;
+ buzzer.eeprom_base_address1=eeprom_base_address1;
+ if(!mem_module_add_eeprom_segment(&buzzer.mem_module,eeprom_base_address2,EEPROM_BUZZER_LENGTH2))
+ return 0x00;
+ buzzer.eeprom_base_address2=eeprom_base_address2;
+ if(!mem_add_module(memory,&buzzer.mem_module))
+ return 0x00;
+ buzzer.memory=memory;
+ buzzer.mem_module.data=&buzzer;
+
+ return 0x01;
}
void buzzer_start(void)
@@ -149,13 +202,13 @@ void buzzer_start(void)
TIM_OC_InitTypeDef TIM_OCInitStructure;
uint16_t period;
- buzzer_current_note=ram_data[BATTERY_BUZZER_FREQ_L]+(ram_data[BATTERY_BUZZER_FREQ_H]<<8);
- period = 1000000/buzzer_current_note;
- if(buzzer_current_note!=NO_NOTE && buzzer_active==0x00)
+ buzzer.current_note=buzzer.memory->data[buzzer.ram_base_address+BUZZER_FREQ_OFFSET]+(buzzer.memory->data[buzzer.ram_base_address+BUZZER_FREQ_OFFSET+1]<<8);
+ period = 1000000/buzzer.current_note;
+ if(buzzer.current_note!=NO_NOTE && buzzer.active==0x00)
{
- buzzer_current_time_on=ram_data[BATTERY_BUZZER_TIME_ON_L]+(ram_data[BATTERY_BUZZER_TIME_ON_H]<<8);
- buzzer_current_time_off=ram_data[BATTERY_BUZZER_TIME_OFF_L]+(ram_data[BATTERY_BUZZER_TIME_OFF_H]<<8);
- if(buzzer_current_time_on>0)
+ buzzer.current_time_on=buzzer.memory->data[buzzer.ram_base_address+BUZZER_TIME_ON_OFFSET]+(buzzer.memory->data[buzzer.ram_base_address+BUZZER_TIME_ON_OFFSET+1]<<8);
+ buzzer.current_time_off=buzzer.memory->data[buzzer.ram_base_address+BUZZER_TIME_OFF_OFFSET]+(buzzer.memory->data[buzzer.ram_base_address+BUZZER_TIME_OFF_OFFSET+1]<<8);
+ if(buzzer.current_time_on>0)
{
/* initialize the time base */
buzzer_TIMHandler.Init.Period = period;
@@ -170,23 +223,23 @@ void buzzer_start(void)
HAL_TIM_PWM_ConfigChannel(&buzzer_TIMHandler, &TIM_OCInitStructure, TIM_CHANNEL_2);
HAL_TIM_PWM_Start(&buzzer_TIMHandler, TIM_CHANNEL_2);
/* initialize the ouput compare channel for time on*/
- buzzer_time_on_count=(((uint32_t)buzzer_current_time_on)*1000000)/period;
+ buzzer.time_on_count=(((uint32_t)buzzer.current_time_on)*1000000)/period;
TIM_OCInitStructure.OCMode = TIM_OCMODE_TIMING;
TIM_OCInitStructure.OCPolarity = TIM_OCPOLARITY_HIGH;
- if(buzzer_time_on_count==0)
- TIM_OCInitStructure.Pulse = (((uint32_t)buzzer_current_time_on)*1000000)%period;
+ if(buzzer.time_on_count==0)
+ TIM_OCInitStructure.Pulse = (((uint32_t)buzzer.current_time_on)*1000000)%period;
else
TIM_OCInitStructure.Pulse = period;
HAL_TIM_OC_ConfigChannel(&buzzer_TIMHandler, &TIM_OCInitStructure,TIM_CHANNEL_1);
HAL_TIM_OC_Start_IT(&buzzer_TIMHandler, TIM_CHANNEL_1);
/* buzzer active */
- buzzer_active=0x01;
- ram_data[BATTERY_BUZZER_STATUS]=0x01;
+ buzzer.active=0x01;
+ buzzer.memory->data[buzzer.ram_base_address+BUZZER_STATUS_OFFSET]=0x01;
}
else
{
- ram_data[BATTERY_BUZZER_STATUS]=0x00;
- ram_data[BATTERY_BUZZER_CONTROL]&=0xFD;
+ buzzer.memory->data[buzzer.ram_base_address+BUZZER_STATUS_OFFSET]=0x00;
+ buzzer.memory->data[buzzer.ram_base_address+BUZZER_CONTROL_OFFSET]&=0xFD;
}
}
// else do nothing
@@ -194,7 +247,7 @@ void buzzer_start(void)
void buzzer_stop(void)
{
- if(buzzer_active)
+ if(buzzer.active)
{
HAL_TIM_PWM_Stop(&buzzer_TIMHandler,TIM_CHANNEL_2);
HAL_TIM_PWM_DeInit(&buzzer_TIMHandler);
@@ -202,27 +255,96 @@ void buzzer_stop(void)
HAL_TIM_OC_Stop_IT(&buzzer_TIMHandler,TIM_CHANNEL_3);
HAL_TIM_OC_DeInit(&buzzer_TIMHandler);
HAL_TIM_Base_DeInit(&buzzer_TIMHandler);
- buzzer_active=0x00;
- ram_data[BATTERY_BUZZER_STATUS]=0x00;
+ buzzer.active=0x00;
+ buzzer.memory->data[buzzer.ram_base_address+BUZZER_STATUS_OFFSET]=0x00;
}
}
void buzzer_enable_alarm(void)
{
- buzzer_alarm_enabled=0x01;
+ buzzer.alarm_enabled=0x01;
}
void buzzer_disable_alarm(void)
{
- buzzer_alarm_enabled=0x00;
+ buzzer.alarm_enabled=0x00;
}
uint8_t buzzer_is_alarm_enabled(void)
{
- return buzzer_alarm_enabled;
+ return buzzer.alarm_enabled;
}
uint8_t buzzer_is_active(void)
{
- return buzzer_active;
+ return buzzer.active;
+}
+
+uint8_t buzzer_get_warning_time(void)
+{
+ return buzzer.memory->data[buzzer.eeprom_base_address1+BUZZER_WARNING_TIME_OFFSET];
+}
+
+uint8_t buzzer_get_warning_time_hist(void)
+{
+ return buzzer.memory->data[buzzer.eeprom_base_address1+BUZZER_WARNING_TIME_HIST_OFFSET];
+}
+
+uint16_t buzzer_get_warning_freq(void)
+{
+ return buzzer.memory->data[buzzer.eeprom_base_address1+BUZZER_WARNING_FREQ_OFFSET]+buzzer.memory->data[buzzer.eeprom_base_address1+BUZZER_WARNING_FREQ_OFFSET+1]*256;
+}
+
+uint16_t buzzer_get_warning_time_on(void)
+{
+ return buzzer.memory->data[buzzer.eeprom_base_address1+BUZZER_WARNING_TIME_ON_OFFSET]+buzzer.memory->data[buzzer.eeprom_base_address1+BUZZER_WARNING_TIME_ON_OFFSET+1]*256;
+}
+
+uint16_t buzzer_get_warning_time_off(void)
+{
+ return buzzer.memory->data[buzzer.eeprom_base_address1+BUZZER_WARNING_TIME_OFF_OFFSET]+buzzer.memory->data[buzzer.eeprom_base_address1+BUZZER_WARNING_TIME_OFF_OFFSET+1]*256;
+}
+
+uint8_t buzzer_get_error_time(void)
+{
+ return buzzer.memory->data[buzzer.eeprom_base_address1+BUZZER_ERROR_TIME_OFFSET];
+}
+
+uint8_t buzzer_get_error_time_hist(void)
+{
+ return buzzer.memory->data[buzzer.eeprom_base_address1+BUZZER_ERROR_TIME_HIST_OFFSET];
+}
+
+uint16_t buzzer_get_error_freq(void)
+{
+ return buzzer.memory->data[buzzer.eeprom_base_address1+BUZZER_ERROR_FREQ_OFFSET]+buzzer.memory->data[buzzer.eeprom_base_address1+BUZZER_WARNING_FREQ_OFFSET+1]*256;
}
+
+uint16_t buzzer_get_error_time_on(void)
+{
+ return buzzer.memory->data[buzzer.eeprom_base_address1+BUZZER_ERROR_TIME_ON_OFFSET]+buzzer.memory->data[buzzer.eeprom_base_address1+BUZZER_ERROR_TIME_ON_OFFSET+1]*256;
+}
+
+uint16_t buzzer_get_error_time_off(void)
+{
+ return buzzer.memory->data[buzzer.eeprom_base_address1+BUZZER_ERROR_TIME_OFF_OFFSET]+buzzer.memory->data[buzzer.eeprom_base_address1+BUZZER_ERROR_TIME_OFF_OFFSET+1]*256;
+}
+
+void buzzer_set_freq(uint16_t freq)
+{
+ buzzer.memory->data[buzzer.ram_base_address+BUZZER_FREQ_OFFSET]=freq&0x00FF;
+ buzzer.memory->data[buzzer.ram_base_address+BUZZER_FREQ_OFFSET+1]=(freq>>8)&0x00FF;
+}
+
+void buzzer_set_time_on(uint16_t time)
+{
+ buzzer.memory->data[buzzer.ram_base_address+BUZZER_TIME_ON_OFFSET]=time&0x00FF;
+ buzzer.memory->data[buzzer.ram_base_address+BUZZER_TIME_ON_OFFSET+1]=(time>>8)&0x00FF;
+}
+
+void buzzer_set_time_off(uint16_t time)
+{
+ buzzer.memory->data[buzzer.ram_base_address+BUZZER_TIME_OFF_OFFSET]=time&0x00FF;
+ buzzer.memory->data[buzzer.ram_base_address+BUZZER_TIME_OFF_OFFSET+1]=(time>>8)&0x00FF;
+}
+
diff --git a/src/charger.c b/src/charger.c
index 9c44d16683625a7e22ff91f9fa14f3187e787483..09adc2d0ab9256969beaf7ca1220c1819539db6e 100644
--- a/src/charger.c
+++ b/src/charger.c
@@ -1,7 +1,9 @@
#include "charger.h"
+#include "charger_registers.h"
#include "gpio.h"
-#include "mem.h"
+#include "eeprom.h"
#include "buzzer.h"
+#include "ram.h"
/* private variables */
SMBUS_HandleTypeDef SMBusHandle;
@@ -9,9 +11,7 @@ ADC_HandleTypeDef ADCHandle;
DMA_HandleTypeDef ADC_DMAHandle;
TIM_HandleTypeDef Charger_TIMHandle;
-uint32_t charger_vicm;
-
-batt_state_t battery_state;
+TCharger charger;
#define MAX_NUM_CMD 24
#define CHARGER_CMDS 6
@@ -31,30 +31,30 @@ typedef struct
uint8_t mem_address;
}TSMBusCmd;
-TSMBusCmd commands[MAX_NUM_CMD]={{0x00,DEFAULT_CHARGER_ADDR,CMD_RD,2,0x14,{0x00,0x00},BATTERY_CHARGE_CURRENT_L},// get charge current
+TSMBusCmd commands[MAX_NUM_CMD]={{0x00,DEFAULT_CHARGER_ADDR,CMD_RD,2,0x14,{0x00,0x00},CHARGER_CHARGE_CURRENT_OFFSET},// get charge current
{0x00,DEFAULT_CHARGER_ADDR,CMD_WR,2,0x14,{0x00,0x00},0x00},// set charge current
- {0x00,DEFAULT_CHARGER_ADDR,CMD_RD,2,0x15,{0x00,0x00},BATTERY_CHARGE_VOLTAGE_L},// get charge voltage
+ {0x00,DEFAULT_CHARGER_ADDR,CMD_RD,2,0x15,{0x00,0x00},CHARGER_CHARGE_VOLTAGE_OFFSET},// get charge voltage
{0x00,DEFAULT_CHARGER_ADDR,CMD_WR,2,0x15,{0x00,0x00},0x00},// set charge voltage
- {0x00,DEFAULT_CHARGER_ADDR,CMD_RD,2,0x3F,{0x00,0x00},BATTERY_LIMIT_CURRENT_L},// get max input current
+ {0x00,DEFAULT_CHARGER_ADDR,CMD_RD,2,0x3F,{0x00,0x00},CHARGER_LIMIT_CURRENT_OFFSET},// get max input current
{0x00,DEFAULT_CHARGER_ADDR,CMD_WR,2,0x3F,{0x00,0x00},0x00},// set max input current
- {0x00,DEFAULT_FUEL_GAUGE_ADDR,CMD_RD,2,0x08,{0x00,0x00},BATTERY_TEMPERATURE_L},// get temperature
- {0x00,DEFAULT_FUEL_GAUGE_ADDR,CMD_RD,2,0x09,{0x00,0x00},BATTERY_VOLTAGE_L},// get battery voltage
- {0x00,DEFAULT_FUEL_GAUGE_ADDR,CMD_RD,2,0x0A,{0x00,0x00},BATTERY_CURRENT_L},// get battery current
- {0x00,DEFAULT_FUEL_GAUGE_ADDR,CMD_RD,2,0x0B,{0x00,0x00},BATTERY_AVG_CURRENT_L},// get battery average current
- {0x00,DEFAULT_FUEL_GAUGE_ADDR,CMD_RD,1,0x0D,{0x00,0x00},BATTERY_RELATIVE_SOC},// get relative state of charge
- {0x00,DEFAULT_FUEL_GAUGE_ADDR,CMD_RD,1,0x0E,{0x00,0x00},BATTERY_ABSOLUTE_SOC},// get absolute state of charge
- {0x00,DEFAULT_FUEL_GAUGE_ADDR,CMD_RD,2,0x0F,{0x00,0x00},BATTERY_REMAINING_CAP_L},// get remaining capacity
- {0x00,DEFAULT_FUEL_GAUGE_ADDR,CMD_RD,2,0x10,{0x00,0x00},BATTERY_FULL_CHARGE_CAP_L},// get full charge capacity
- {0x00,DEFAULT_FUEL_GAUGE_ADDR,CMD_RD,2,0x11,{0x00,0x00},BATTERY_RUN_TIME_EMPTY_L},// get run time to empty
- {0x00,DEFAULT_FUEL_GAUGE_ADDR,CMD_RD,2,0x12,{0x00,0x00},BATTERY_AVG_TIME_EMPTY_L},// get average time to empty
- {0x00,DEFAULT_FUEL_GAUGE_ADDR,CMD_RD,2,0x13,{0x00,0x00},BATTERY_AVG_TIME_FULL_L},// get average time to full
- {0x00,DEFAULT_FUEL_GAUGE_ADDR,CMD_RD,2,0x16,{0x00,0x00},BATTERY_STATUS_L},// get battery status
- {0x00,DEFAULT_FUEL_GAUGE_ADDR,CMD_RD,2,0x18,{0x00,0x00},BATTERY_DESIGN_CAP_L},// get design capacity
- {0x00,DEFAULT_FUEL_GAUGE_ADDR,CMD_RD,2,0x19,{0x00,0x00},BATTERY_DESIGN_VOLTAGE_L},// get design voltage
- {0x00,DEFAULT_FUEL_GAUGE_ADDR,CMD_RD,2,0x3C,{0x00,0x00},BATTERY_CELL1_VOLTAGE_L},// get cell1 voltage
- {0x00,DEFAULT_FUEL_GAUGE_ADDR,CMD_RD,2,0x3D,{0x00,0x00},BATTERY_CELL2_VOLTAGE_L},// get cell2 voltage
- {0x00,DEFAULT_FUEL_GAUGE_ADDR,CMD_RD,2,0x3E,{0x00,0x00},BATTERY_CELL3_VOLTAGE_L},// get cell3 voltage
- {0x00,DEFAULT_FUEL_GAUGE_ADDR,CMD_RD,2,0x3F,{0x00,0x00},BATTERY_CELL4_VOLTAGE_L}};// get cell4 voltage
+ {0x00,DEFAULT_FUEL_GAUGE_ADDR,CMD_RD,2,0x08,{0x00,0x00},CHARGER_TEMPERATURE_OFFSET},// get temperature
+ {0x00,DEFAULT_FUEL_GAUGE_ADDR,CMD_RD,2,0x09,{0x00,0x00},CHARGER_VOLTAGE_OFFSET},// get battery voltage
+ {0x00,DEFAULT_FUEL_GAUGE_ADDR,CMD_RD,2,0x0A,{0x00,0x00},CHARGER_CURRENT_OFFSET},// get battery current
+ {0x00,DEFAULT_FUEL_GAUGE_ADDR,CMD_RD,2,0x0B,{0x00,0x00},CHARGER_AVG_CURRENT_OFFSET},// get battery average current
+ {0x00,DEFAULT_FUEL_GAUGE_ADDR,CMD_RD,1,0x0D,{0x00,0x00},CHARGER_RELATIVE_SOC_OFFSET},// get relative state of charge
+ {0x00,DEFAULT_FUEL_GAUGE_ADDR,CMD_RD,1,0x0E,{0x00,0x00},CHARGER_ABSOLUTE_SOC_OFFSET},// get absolute state of charge
+ {0x00,DEFAULT_FUEL_GAUGE_ADDR,CMD_RD,2,0x0F,{0x00,0x00},CHARGER_REMAINING_CAP_OFFSET},// get remaining capacity
+ {0x00,DEFAULT_FUEL_GAUGE_ADDR,CMD_RD,2,0x10,{0x00,0x00},CHARGER_FULL_CHARGE_CAP_OFFSET},// get full charge capacity
+ {0x00,DEFAULT_FUEL_GAUGE_ADDR,CMD_RD,2,0x11,{0x00,0x00},CHARGER_RUN_TIME_EMPTY_OFFSET},// get run time to empty
+ {0x00,DEFAULT_FUEL_GAUGE_ADDR,CMD_RD,2,0x12,{0x00,0x00},CHARGER_AVG_TIME_EMPTY_OFFSET},// get average time to empty
+ {0x00,DEFAULT_FUEL_GAUGE_ADDR,CMD_RD,2,0x13,{0x00,0x00},CHARGER_AVG_TIME_FULL_OFFSET},// get average time to full
+ {0x00,DEFAULT_FUEL_GAUGE_ADDR,CMD_RD,2,0x16,{0x00,0x00},CHARGER_BATTERY_STATUS_OFFSET},// get battery status
+ {0x00,DEFAULT_FUEL_GAUGE_ADDR,CMD_RD,2,0x18,{0x00,0x00},CHARGER_DESIGN_CAP_OFFSET},// get design capacity
+ {0x00,DEFAULT_FUEL_GAUGE_ADDR,CMD_RD,2,0x19,{0x00,0x00},CHARGER_DESIGN_VOLTAGE_OFFSET},// get design voltage
+ {0x00,DEFAULT_FUEL_GAUGE_ADDR,CMD_RD,2,0x3C,{0x00,0x00},CHARGER_CELL1_VOLTAGE_OFFSET},// get cell1 voltage
+ {0x00,DEFAULT_FUEL_GAUGE_ADDR,CMD_RD,2,0x3D,{0x00,0x00},CHARGER_CELL2_VOLTAGE_OFFSET},// get cell2 voltage
+ {0x00,DEFAULT_FUEL_GAUGE_ADDR,CMD_RD,2,0x3E,{0x00,0x00},CHARGER_CELL3_VOLTAGE_OFFSET},// get cell3 voltage
+ {0x00,DEFAULT_FUEL_GAUGE_ADDR,CMD_RD,2,0x3F,{0x00,0x00},CHARGER_CELL4_VOLTAGE_OFFSET}};// get cell4 voltage
uint8_t current_cmd;
uint8_t smbus_error;
@@ -194,7 +194,7 @@ void charger_set_commands(void)
charger_get_charge_voltage();
charger_get_limit_curret();
/* check wether the battery is present */
- if(ram_data[BATTERY_CHARGER_STATUS]&0x04)// battery present
+ if(charger.memory->data[charger.ram_base_address+CHARGER_STATUS_OFFSET]&0x04)// battery present
{
charger_get_temperature();
charger_get_voltage();
@@ -225,8 +225,8 @@ void charger_cancel_fuel_gauge_commands(void)
for(i=CHARGER_CMDS;i<MAX_NUM_CMD;i++)
commands[i].send=0x00;
- for(i=BATTERY_TEMPERATURE_L;i<=BATTERY_CELL4_VOLTAGE_H;i++)
- ram_data[i]=0x00;
+ for(i=CHARGER_TEMPERATURE_OFFSET;i<=CHARGER_CELL4_VOLTAGE_OFFSET+1;i++)
+ charger.memory->data[charger.ram_base_address+i]=0x00;
}
void charger_send_next_command(void)
@@ -248,11 +248,11 @@ void charger_send_next_command(void)
current_cmd++;
if(current_cmd==MAX_NUM_CMD)
{
- if(HAL_SMBUS_IsDeviceReady(&SMBusHandle,ram_data[BATTERY_FUEL_GAUGE_ADDR],1,10)==HAL_OK)
+ if(HAL_SMBUS_IsDeviceReady(&SMBusHandle,charger.memory->data[charger.eeprom_base_address1+CHARGER_FUEL_GAUGE_ADDR_OFFSET],1,10)==HAL_OK)
{
- ram_data[BATTERY_CHARGER_STATUS]|=0x04;
- if(battery_state==batt_not_present)
- battery_state=batt_okay;
+ charger.memory->data[charger.ram_base_address+CHARGER_STATUS_OFFSET]|=0x04;
+ if(charger.battery_state==batt_not_present)
+ charger.battery_state=batt_okay;
smbus_attempts=0;
}
else
@@ -260,8 +260,8 @@ void charger_send_next_command(void)
smbus_attempts++;
if(smbus_attempts>=5)
{
- ram_data[BATTERY_CHARGER_STATUS]&=0xFB;
- battery_state=batt_not_present;
+ charger.memory->data[charger.ram_base_address+CHARGER_STATUS_OFFSET]&=0xFB;
+ charger.battery_state=batt_not_present;
charger_cancel_fuel_gauge_commands();
smbus_attempts=0;
}
@@ -300,7 +300,7 @@ void HAL_SMBUS_MasterTxCpltCallback(SMBUS_HandleTypeDef *hsmbus)
{
/* reception done */
if(commands[current_cmd].operation==CMD_RD)// Read
- HAL_SMBUS_Master_Receive_IT(hsmbus,commands[current_cmd].slave_address,&ram_data[commands[current_cmd].mem_address],commands[current_cmd].length,SMBUS_LAST_FRAME_NO_PEC);
+ HAL_SMBUS_Master_Receive_IT(hsmbus,commands[current_cmd].slave_address,&charger.memory->data[charger.ram_base_address+commands[current_cmd].mem_address],commands[current_cmd].length,SMBUS_LAST_FRAME_NO_PEC);
else
commands[current_cmd].send=0x00;
}
@@ -382,9 +382,9 @@ void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* hadc)
uint16_t value;
/* transform data to mA input current */
- value=((charger_vicm*4125)>>10);
- ram_data[BATTERY_INPUT_CURRENT_L]=(value&0x00FF);
- ram_data[BATTERY_INPUT_CURRENT_H]=((value>>8)&0x00FF);
+ value=((charger.vicm*4125)>>10);
+ charger.memory->data[charger.ram_base_address+CHARGER_INPUT_CURRENT_OFFSET]=(value&0x00FF);
+ charger.memory->data[charger.ram_base_address+CHARGER_INPUT_CURRENT_OFFSET+1]=((value>>8)&0x00FF);
}
void charger_adc_config(void)
@@ -447,7 +447,7 @@ void charger_adc_config(void)
HAL_NVIC_EnableIRQ(CHARGER_ADC_DMA_IRQn);
/* start ADC conversion */
- HAL_ADC_Start_DMA(&ADCHandle, &charger_vicm, 1);
+ HAL_ADC_Start_DMA(&ADCHandle, &charger.vicm, 1);
}
/* GPIO functions */
@@ -472,9 +472,9 @@ void CHARGER_GPIO_IRQHandle(void)
{
__HAL_GPIO_EXTI_CLEAR_IT(AC_OK_PIN);
if(HAL_GPIO_ReadPin(AC_OK_GPIO_PORT,AC_OK_PIN)==GPIO_PIN_SET)
- ram_data[BATTERY_CHARGER_STATUS]|=0x02;
+ charger.memory->data[charger.ram_base_address+CHARGER_STATUS_OFFSET]|=0x02;
else
- ram_data[BATTERY_CHARGER_STATUS]&=0xFD;
+ charger.memory->data[charger.ram_base_address+CHARGER_STATUS_OFFSET]&=0xFD;
}
if(__HAL_GPIO_EXTI_GET_IT(ICOUT_PIN) != RESET)
{
@@ -538,7 +538,7 @@ void CHARGER_TIMER_IRQHandler(void)
__HAL_TIM_CLEAR_IT(&Charger_TIMHandle, TIM_IT_CC2);
capture = HAL_TIM_ReadCapturedValue(&Charger_TIMHandle, TIM_CHANNEL_2);
__HAL_TIM_SetCompare(&Charger_TIMHandle, TIM_CHANNEL_2, (capture + 60000));
- if((ram_data[BATTERY_CHARGER_STATUS]&0x04)==0)// battery not present
+ if((charger.memory->data[charger.ram_base_address+CHARGER_STATUS_OFFSET]&0x04)==0)// battery not present
{
// add commands to the command queue
charger_set_charge_curret();
@@ -579,8 +579,28 @@ void charger_timer_config(void)
HAL_TIM_OC_Start_IT(&Charger_TIMHandle, TIM_CHANNEL_2);
}
+void charger_write_cmd(void *module,unsigned short int address,unsigned short int length,unsigned char *data)
+{
+ TCharger *charger=(TCharger *)module;
+
+ ram_write_table(charger->memory,address,length,data);
+ if(ram_in_window(charger->eeprom_base_address2+CHARGER_INPUT_MAX_CURRENT_OFFSET,2,address,length))
+ charger_set_limit_curret();
+ else if(ram_in_window(charger->eeprom_base_address2+CHARGER_OUTPUT_CURRENT_OFFSET,2,address,length))
+ charger_set_charge_curret();
+ else if(ram_in_window(charger->eeprom_base_address2+CHARGER_OUTPUT_VOLTAGE_OFFSET,2,address,length))
+ charger_set_charge_voltage();
+}
+
+void charger_read_cmd(void *module,unsigned short int address,unsigned short int length,unsigned char *data)
+{
+ TCharger *charger=(TCharger *)module;
+
+ ram_read_table(charger->memory,address,length,data);
+}
+
/* public functions */
-void charger_init(void)
+unsigned char charger_init(TMemory *memory,unsigned short int ram_base_address,unsigned short int eeprom_base_address1, unsigned short int eeprom_base_address2)
{
/* configure smbus */
charger_smbus_config();
@@ -595,15 +615,7 @@ void charger_init(void)
charger_enable();
/* initialize internal variables */
- battery_state=batt_not_present;
- if(HAL_SMBUS_IsDeviceReady(&SMBusHandle,ram_data[BATTERY_FUEL_GAUGE_ADDR],1,10)!=HAL_OK)
- {
- ram_data[BATTERY_CHARGER_STATUS]&=0xFB;
- charger_set_charge_curret();
- charger_set_charge_voltage();
- }
- else
- ram_data[BATTERY_CHARGER_STATUS]|=0x04;
+ charger.battery_state=batt_not_present;
charger_set_limit_curret();
charger_set_commands();
smbus_error=0x00;
@@ -611,18 +623,38 @@ void charger_init(void)
/* configure timer */
charger_timer_config();
+
+ /* initialize memory module */
+ mem_module_init(&charger.mem_module);
+ charger.mem_module.write_cmd=charger_write_cmd;
+ charger.mem_module.read_cmd=charger_read_cmd;
+ if(!mem_module_add_ram_segment(&charger.mem_module,ram_base_address,RAM_CHARGER_LENGTH))
+ return 0x00;
+ charger.ram_base_address=ram_base_address;
+ if(!mem_module_add_eeprom_segment(&charger.mem_module,eeprom_base_address1,EEPROM_CHARGER_LENGTH1))
+ return 0x00;
+ charger.eeprom_base_address1=eeprom_base_address1;
+ if(!mem_module_add_eeprom_segment(&charger.mem_module,eeprom_base_address2,EEPROM_CHARGER_LENGTH2))
+ return 0x00;
+ charger.eeprom_base_address2=eeprom_base_address2;
+ if(!mem_add_module(memory,&charger.mem_module))
+ return 0x00;
+ charger.memory=memory;
+ charger.mem_module.data=&charger;
+
+ return 0x01;
}
void charger_enable(void)
{
HAL_GPIO_WritePin(CHARGER_EN_GPIO_PORT,CHARGER_EN_PIN,GPIO_PIN_SET);
- ram_data[BATTERY_CHARGER_STATUS]|=0x01;
+ charger.memory->data[charger.ram_base_address+CHARGER_STATUS_OFFSET]|=0x01;
}
void charger_disable(void)
{
HAL_GPIO_WritePin(CHARGER_EN_GPIO_PORT,CHARGER_EN_PIN,GPIO_PIN_RESET);
- ram_data[BATTERY_CHARGER_STATUS]&=0xFE;
+ charger.memory->data[charger.ram_base_address+CHARGER_STATUS_OFFSET]&=0xFE;
}
void charger_update_charger_address(void)
@@ -630,7 +662,7 @@ void charger_update_charger_address(void)
uint8_t i;
for(i=0;i<CHARGER_CMDS;i++)
- commands[i].slave_address=ram_data[BATTERY_CHARGER_ADDR];
+ commands[i].slave_address=charger.memory->data[charger.eeprom_base_address1+CHARGER_CHARGER_ADDR_OFFSET];
}
void charger_update_fuel_gauge_address(void)
@@ -638,32 +670,32 @@ void charger_update_fuel_gauge_address(void)
uint8_t i;
for(i=CHARGER_CMDS;i<MAX_NUM_CMD;i++)
- commands[i].slave_address=ram_data[BATTERY_FUEL_GAUGE_ADDR];
+ commands[i].slave_address=charger.memory->data[charger.eeprom_base_address1+CHARGER_FUEL_GAUGE_ADDR_OFFSET];
}
batt_state_t charger_get_battery_state(void)
{
- return battery_state;
+ return charger.battery_state;
}
void charger_set_charge_curret(void)
{
- commands[1].data[0]=ram_data[BATTERY_OUTPUT_CURRENT_L];
- commands[1].data[1]=ram_data[BATTERY_OUTPUT_CURRENT_H];
+ commands[1].data[0]=charger.memory->data[charger.eeprom_base_address2+CHARGER_OUTPUT_CURRENT_OFFSET];
+ commands[1].data[1]=charger.memory->data[charger.eeprom_base_address2+CHARGER_OUTPUT_CURRENT_OFFSET+1];
commands[1].send=0x01;
}
void charger_set_charge_voltage(void)
{
- commands[3].data[0]=ram_data[BATTERY_OUTPUT_VOLTAGE_L];
- commands[3].data[1]=ram_data[BATTERY_OUTPUT_VOLTAGE_H];
+ commands[3].data[0]=charger.memory->data[charger.eeprom_base_address2+CHARGER_OUTPUT_VOLTAGE_OFFSET];
+ commands[3].data[1]=charger.memory->data[charger.eeprom_base_address2+CHARGER_OUTPUT_VOLTAGE_OFFSET+1];
commands[3].send=0x01;
}
void charger_set_limit_curret(void)
{
- commands[5].data[0]=ram_data[BATTERY_INPUT_MAX_CURRENT_L];
- commands[5].data[1]=ram_data[BATTERY_INPUT_MAX_CURRENT_H];
+ commands[5].data[0]=charger.memory->data[charger.eeprom_base_address2+CHARGER_INPUT_MAX_CURRENT_OFFSET];
+ commands[5].data[1]=charger.memory->data[charger.eeprom_base_address2+CHARGER_INPUT_MAX_CURRENT_OFFSET+1];
commands[5].send=0x01;
}
@@ -673,76 +705,64 @@ void charger_ckeck_alarm(void)
if(buzzer_is_alarm_enabled())
{
- time=ram_data[BATTERY_AVG_TIME_EMPTY_L]+(ram_data[BATTERY_AVG_TIME_EMPTY_H]<<8);
- switch(battery_state)
+ time=charger.memory->data[charger.ram_base_address+CHARGER_AVG_TIME_EMPTY_OFFSET]+(charger.memory->data[charger.ram_base_address+CHARGER_AVG_TIME_EMPTY_OFFSET+1]<<8);
+ switch(charger.battery_state)
{
case batt_not_present: if(buzzer_is_active())
buzzer_stop();
break;
- case batt_okay: if(time<(ram_data[BATTERY_WARNING_TIME]-ram_data[BATTERY_WARNING_TIME_HIST]))
+ case batt_okay: if(time<(buzzer_get_warning_time()-buzzer_get_warning_time_hist()))
{
- if(time<(ram_data[BATTERY_ERROR_TIME]-ram_data[BATTERY_ERROR_TIME_HIST]))
+ if(time<(buzzer_get_error_time()-buzzer_get_error_time_hist()))
{
- battery_state=batt_error;
- ram_data[BATTERY_BUZZER_FREQ_L]=ram_data[BATTERY_ERROR_FREQ_L];
- ram_data[BATTERY_BUZZER_FREQ_H]=ram_data[BATTERY_ERROR_FREQ_H];
- ram_data[BATTERY_BUZZER_TIME_ON_L]=ram_data[BATTERY_ERROR_TIME_ON_L];
- ram_data[BATTERY_BUZZER_TIME_ON_H]=ram_data[BATTERY_ERROR_TIME_ON_H];
- ram_data[BATTERY_BUZZER_TIME_OFF_L]=ram_data[BATTERY_ERROR_TIME_OFF_L];
- ram_data[BATTERY_BUZZER_TIME_OFF_H]=ram_data[BATTERY_ERROR_TIME_OFF_H];
+ charger.battery_state=batt_error;
+ buzzer_set_freq(buzzer_get_error_freq());
+ buzzer_set_time_on(buzzer_get_error_time_on());
+ buzzer_set_time_off(buzzer_get_error_time_off());
if(buzzer_is_active())
buzzer_stop();
buzzer_start();
}
else
{
- battery_state=batt_warning;
- ram_data[BATTERY_BUZZER_FREQ_L]=ram_data[BATTERY_WARNING_FREQ_L];
- ram_data[BATTERY_BUZZER_FREQ_H]=ram_data[BATTERY_WARNING_FREQ_H];
- ram_data[BATTERY_BUZZER_TIME_ON_L]=ram_data[BATTERY_WARNING_TIME_ON_L];
- ram_data[BATTERY_BUZZER_TIME_ON_H]=ram_data[BATTERY_WARNING_TIME_ON_H];
- ram_data[BATTERY_BUZZER_TIME_OFF_L]=ram_data[BATTERY_WARNING_TIME_OFF_L];
- ram_data[BATTERY_BUZZER_TIME_OFF_H]=ram_data[BATTERY_WARNING_TIME_OFF_H];
+ charger.battery_state=batt_warning;
+ buzzer_set_freq(buzzer_get_warning_freq());
+ buzzer_set_time_on(buzzer_get_warning_time_on());
+ buzzer_set_time_off(buzzer_get_warning_time_off());
if(buzzer_is_active())
buzzer_stop();
buzzer_start();
}
}
break;
- case batt_warning: if(time<(ram_data[BATTERY_ERROR_TIME]-ram_data[BATTERY_ERROR_TIME_HIST]))
+ case batt_warning: if(time<(buzzer_get_error_time()-buzzer_get_error_time_hist()))
{
- battery_state=batt_error;
- ram_data[BATTERY_BUZZER_FREQ_L]=ram_data[BATTERY_ERROR_FREQ_L];
- ram_data[BATTERY_BUZZER_FREQ_H]=ram_data[BATTERY_ERROR_FREQ_H];
- ram_data[BATTERY_BUZZER_TIME_ON_L]=ram_data[BATTERY_ERROR_TIME_ON_L];
- ram_data[BATTERY_BUZZER_TIME_ON_H]=ram_data[BATTERY_ERROR_TIME_ON_H];
- ram_data[BATTERY_BUZZER_TIME_OFF_L]=ram_data[BATTERY_ERROR_TIME_OFF_L];
- ram_data[BATTERY_BUZZER_TIME_OFF_H]=ram_data[BATTERY_ERROR_TIME_OFF_H];
+ charger.battery_state=batt_error;
+ buzzer_set_freq(buzzer_get_error_freq());
+ buzzer_set_time_on(buzzer_get_error_time_on());
+ buzzer_set_time_off(buzzer_get_error_time_off());
buzzer_stop();
buzzer_start();
}
- else if(time>(ram_data[BATTERY_WARNING_TIME]+ram_data[BATTERY_WARNING_TIME_HIST]))
+ else if(time>(buzzer_get_warning_time()-buzzer_get_warning_time_hist()))
{
buzzer_stop();
- battery_state=batt_okay;
+ charger.battery_state=batt_okay;
}
break;
- case batt_error: if(time>(ram_data[BATTERY_ERROR_TIME]+ram_data[BATTERY_ERROR_TIME_HIST]))
+ case batt_error: if(time>(buzzer_get_error_time()-buzzer_get_error_time_hist()))
{
- if(time>(ram_data[BATTERY_WARNING_TIME]+ram_data[BATTERY_WARNING_TIME_HIST]))
+ if(time>(buzzer_get_warning_time()-buzzer_get_warning_time_hist()))
{
buzzer_stop();
- battery_state=batt_okay;
+ charger.battery_state=batt_okay;
}
else
{
- battery_state=batt_warning;
- ram_data[BATTERY_BUZZER_FREQ_L]=ram_data[BATTERY_WARNING_FREQ_L];
- ram_data[BATTERY_BUZZER_FREQ_H]=ram_data[BATTERY_WARNING_FREQ_H];
- ram_data[BATTERY_BUZZER_TIME_ON_L]=ram_data[BATTERY_WARNING_TIME_ON_L];
- ram_data[BATTERY_BUZZER_TIME_ON_H]=ram_data[BATTERY_WARNING_TIME_ON_H];
- ram_data[BATTERY_BUZZER_TIME_OFF_L]=ram_data[BATTERY_WARNING_TIME_OFF_L];
- ram_data[BATTERY_BUZZER_TIME_OFF_H]=ram_data[BATTERY_WARNING_TIME_OFF_H];
+ charger.battery_state=batt_warning;
+ buzzer_set_freq(buzzer_get_warning_freq());
+ buzzer_set_time_on(buzzer_get_warning_time_on());
+ buzzer_set_time_off(buzzer_get_warning_time_off());
buzzer_stop();
buzzer_start();
}
diff --git a/src/eeprom.c b/src/eeprom.c
new file mode 100644
index 0000000000000000000000000000000000000000..0281093220af8f95df93f1b88dd202303f3423c3
--- /dev/null
+++ b/src/eeprom.c
@@ -0,0 +1,56 @@
+#include "eeprom.h"
+
+uint8_t eeprom_data[EEPROM_SIZE] __attribute__ ((section (".eeprom")))={
+ DEFAULT_DEVICE_MODEL&0x00FF,
+ (DEFAULT_DEVICE_MODEL>>8)&0x00FF,
+ DEFAULT_FIRMWARE_VERSION,
+ DEFAULT_DEVICE_ID,
+ DEFAULT_BAUDRATE,
+ DEFAULT_RETURN_DELAY,
+ DEFAULT_WARNING_TIME_OFFSET,
+ DEFAULT_WARNING_TIME_HIST_OFFSET,
+ DEFAULT_WARNING_FREQ_OFFSET&0x00FF,
+ (DEFAULT_WARNING_FREQ_OFFSET>>8)&0x00FF,
+ DEFAULT_WARNING_TIME_ON_OFFSET&0x00FF,
+ (DEFAULT_WARNING_TIME_ON_OFFSET>>8)&0x00FF,
+ DEFAULT_WARNING_TIME_OFF_OFFSET&0x00FF,
+ (DEFAULT_WARNING_TIME_OFF_OFFSET>>8)&0x00FF,
+ DEFAULT_CHARGER_ADDR,
+ DEFAULT_FUEL_GAUGE_ADDR,
+ DEFAULT_RETURN_LEVEL,
+ DEFAULT_ERROR_TIME_OFFSET,
+ DEFAULT_ERROR_TIME_HIST_OFFSET,
+ DEFAULT_ERROR_FREQ_OFFSET&0x00FF,
+ (DEFAULT_ERROR_FREQ_OFFSET>>8)&0x00FF,
+ DEFAULT_ERROR_TIME_ON_OFFSET&0x00FF,
+ (DEFAULT_ERROR_TIME_ON_OFFSET>>8)&0x00FF,
+ DEFAULT_ERROR_TIME_OFF_OFFSET&0x00FF,
+ (DEFAULT_ERROR_TIME_OFF_OFFSET>>8)&0x00FF,
+ DEFAULT_INPUT_MAX_CURRENT_OFFSET&0x00FF,
+ (DEFAULT_INPUT_MAX_CURRENT_OFFSET>>8)&0x00FF,
+ DEFAULT_OUTPUT_CURRENT_OFFSET&0x00FF,
+ (DEFAULT_OUTPUT_CURRENT_OFFSET>>8)&0x00FF,
+ DEFAULT_OUTPUT_VOLTAGE_OFFSET&0x00FF,
+ (DEFAULT_OUTPUT_VOLTAGE_OFFSET>>8)&0x00FF};
+
+void eeprom_init(void)
+{
+ /* unblock EEPROM write access */
+ HAL_FLASHEx_DATAEEPROM_Unlock();
+}
+
+uint16_t eeprom_read(unsigned short int address, unsigned short int *data)
+{
+ if(address<EEPROM_SIZE)
+ (*data)=eeprom_data[address];
+
+ return 0;
+}
+
+uint16_t eeprom_write(unsigned short int address, unsigned short int data)
+{
+ if(address<EEPROM_SIZE)
+ HAL_FLASHEx_DATAEEPROM_Program(TYPEPROGRAM_FASTBYTE,(uint32_t)(0x08080000+address),(unsigned char)data);
+
+ return 0;
+}
diff --git a/src/mem.c b/src/mem.c
deleted file mode 100644
index 43e5c452dfa66f7c85aeecd3dffdb609be2abf81..0000000000000000000000000000000000000000
--- a/src/mem.c
+++ /dev/null
@@ -1,82 +0,0 @@
-#include "mem.h"
-
-uint8_t ram_data[RAM_SIZE];
-uint8_t eeprom_data[EEPROM_SIZE] __attribute__ ((section (".eeprom")))={
- DYN_BATTERY_MODEL&0x00FF,
- (DYN_BATTERY_MODEL>>8)&0x00FF,
- DYN_BATTERY_VERSION,
- 0xC0,
- 0x01,
- 0x00,
- 0x0A,
- 0x01,
- 0xB8,
- 0x01,
- 0x01,
- 0x00,
- 0x1E,
- 0x00,
- DEFAULT_CHARGER_ADDR,
- DEFAULT_FUEL_GAUGE_ADDR,
- 0x02,
- 0x05,
- 0x01,
- 0xB8,
- 0x01,
- 0x01,
- 0x00,
- 0x05,
- 0x00,
- 0x94,
- 0x11,
- 0xE8,
- 0x03,
- 0xE0,
- 0x2E};
-
-void mem_init(void)
-{
- uint8_t i;
-
- /* unblock EEPROM write access */
- HAL_FLASHEx_DATAEEPROM_Unlock();
-
- /* read contents from EEPROM */
- for(i=0;i<EEPROM_SIZE;i++)
- ram_data[i]=eeprom_data[i];
- /* initialize rest of RAM */
- for(;i<RAM_SIZE;i++)
- ram_data[i]=0x00;
-}
-
-uint8_t mem_read(unsigned char address, unsigned char length, unsigned char *data)
-{
- uint8_t i;
-
- if((address+length)>RAM_SIZE)
- return RAM_BAD_ADDRESS;
- else
- {
- for(i=0;i<length;i++)
- data[i]=ram_data[address+i];
- return RAM_SUCCESS;
- }
-}
-
-uint8_t mem_write(unsigned char address, unsigned char length, unsigned char *data)
-{
- uint8_t i,num;
-
- if((address+length)>RAM_SIZE)
- return RAM_BAD_ADDRESS;
- else
- {
- for(i=address,num=0;i<(address+length);i++,num++)
- {
- if(i<EEPROM_SIZE)
- HAL_FLASHEx_DATAEEPROM_Program(TYPEPROGRAM_FASTBYTE,(uint32_t)(i+0x08080000),data[num]);
- ram_data[i]=data[num];
- }
- return RAM_SUCCESS;
- }
-}
diff --git a/stm32_libraries b/stm32_libraries
index 0a4a91c0033ac79c8fd345eab1f9b1bdce10b2dd..c078fa113292454a1005f947cc957e864645c14a 160000
--- a/stm32_libraries
+++ b/stm32_libraries
@@ -1 +1 @@
-Subproject commit 0a4a91c0033ac79c8fd345eab1f9b1bdce10b2dd
+Subproject commit c078fa113292454a1005f947cc957e864645c14a