Mirrors/OpenBK7231T_App
2
0
Fork 0
mirror of https://github.com/openshwprojects/OpenBK7231T_App.git synced 2026-02-19 16:22:07 +01:00
Code Issues Packages Projects Releases Wiki Activity

BK use easyflash for flash vars (#1969)

Browse Source 
* bk use easyflash for flash vars

* fix?

* Disable EF asserts and log

* test

* w600 fv

* no longer needed
This commit is contained in:
NonPIayerCharacter
2026-02-06 03:25:13 +03:00
committed by GitHub
parent c5ed14513a
commit ac925a6a12
18 changed files with 310 additions and 773 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
components.mk
View File

@@ -8,6 +8,7 @@ include $(OBK_DIR)/libraries/berry.mk
SRC_C += $(BERRY_SRC_C)
CPPDEFINES += -DOBK_VARIANT=$(OBK_VARIANT)
CPPDEFINES += -D__FILE__=\"\" -Wno-builtin-macro-redefined
ifeq ($(TARGET_PLATFORM),bk7231n)
@@ -78,3 +79,9 @@ SRC_C += ${MBEDTLS_DIR}/library/ssl_cli.c
endif #ifeq ($(CFG_USE_MQTT_TLS),1)
endif #ifeq ($(TARGET_PLATFORM),bk7231n)
SRC_C += $(OBK_DIR)/libraries/easyflash/ports/ef_port.c
SRC_C += $(OBK_DIR)/libraries/easyflash/src/easyflash.c
SRC_C += $(OBK_DIR)/libraries/easyflash/src/ef_env.c
SRC_C += $(OBK_DIR)/libraries/easyflash/src/ef_utils.c
INCLUDES += -I$(OBK_DIR)/libraries/easyflash/inc

10
libraries/easyflash/inc/ef_cfg.h
View File

@@ -117,6 +117,11 @@
// extend to 0x21000 if moving obk config to ef
#define ENV_AREA_SIZE 0x15000
#elif PLATFORM_W600
#define EF_START_ADDR 0xF1000
#define ENV_AREA_SIZE 0x8000
#elif PLATFORM_XR809
#define EF_START_ADDR 0x1E0000
@@ -142,6 +147,11 @@
#define EF_START_ADDR 0xF4000
#define ENV_AREA_SIZE 0xA000
#elif PLATFORM_BEKEN
#define EF_START_ADDR 0x1E5000
#define ENV_AREA_SIZE 0x8000
#elif WINDOWS
#define EF_START_ADDR 0

8
libraries/easyflash/inc/ef_def.h
View File

@@ -33,6 +33,9 @@
extern "C" {
#endif
// disable logging and asserts to make it more compact
#define EF_ENABLE_LOGGING 0
/* EasyFlash software version number */
#define EF_SW_VERSION "4.1.0"
#define EF_SW_VERSION_NUM 0x40100
@@ -56,6 +59,7 @@ extern "C" {
#else
#define EF_DEBUG(...)
#endif
#if EF_ENABLE_LOGGING
/* EasyFlash routine print function. Must be implement by user. */
#define EF_INFO(...) ef_log_info(__VA_ARGS__)
/* EasyFlash assert for developer. */
@@ -65,6 +69,10 @@ if (!(EXPR)) \
EF_DEBUG("(%s) has assert failed at %s.\n", #EXPR, __FUNCTION__); \
while (1); \
}
#else
#define EF_INFO(...)
#define EF_ASSERT(EXPR)
#endif
typedef struct _ef_env {
char *key;

94
libraries/easyflash/ports/ef_port.c
View File

@@ -30,7 +30,7 @@
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#if !WINDOWS && !PLATFORM_TXW81X && !PLATFORM_RDA5981 && !LINUX
#if !WINDOWS && !PLATFORM_TXW81X && !PLATFORM_RDA5981 && !LINUX && !defined(PLATFORM_W800) && !defined(PLATFORM_W600)
#include "FreeRTOS.h"
#include "semphr.h"
#include "queue.h"
@@ -45,6 +45,10 @@ flash_t flash;
#elif defined(PLATFORM_W800) || defined(PLATFORM_W600)
#include "FreeRTOS.h"
#include "rtoslist.h"
#include "semphr.h"
#include "rtosqueue.h"
#include "wm_internal_flash.h"
#include "wm_flash.h"
#define QueueHandle_t xQueueHandle
@@ -82,6 +86,17 @@ typedef void* QueueHandle_t;
#define xSemaphoreTake rda_mutex_wait
#define xSemaphoreGive rda_mutex_realease
#elif PLATFORM_BEKEN
#include "include.h"
#include "flash_pub.h"
#include "rtos_pub.h"
#include "uart_pub.h"
#include "drv_model_pub.h"
#include "flash.h"
extern int hal_flash_lock(void);
extern int hal_flash_unlock(void);
#elif WINDOWS
#include "framework.h"
@@ -187,9 +202,6 @@ EfErrCode ef_port_init(ef_env const** default_env, size_t* default_env_size)
*default_env_size = sizeof(default_env_set) / sizeof(default_env_set[0]);
ef_mutex = xSemaphoreCreateMutex();
#if defined(PLATFORM_W800) || defined(PLATFORM_W600)
tls_fls_init();
#endif
return result;
}
@@ -227,6 +239,11 @@ EfErrCode ef_port_read(uint32_t addr, uint32_t* buf, size_t size)
#elif PLATFORM_TXW81X || PLATFORM_RDA5981
HAL_FlashRead(buf, size, addr);
return EF_NO_ERR;
#elif PLATFORM_BEKEN
hal_flash_lock();
flash_read((char*)buf, (unsigned long)size, addr);
hal_flash_unlock();
return EF_NO_ERR;
#endif
}
@@ -266,6 +283,48 @@ EfErrCode ef_port_erase(uint32_t addr, size_t size)
#elif PLATFORM_TXW81X || PLATFORM_RDA5981
HAL_FlashEraseSector(addr);
return EF_NO_ERR;
#elif PLATFORM_BEKEN
int param;
UINT32 status;
int protect_type;
DD_HANDLE flash_handle;
unsigned int _size = size;
hal_flash_lock();
flash_handle = ddev_open(FLASH_DEV_NAME, &status, 0);
ddev_control(flash_handle, CMD_FLASH_GET_PROTECT, (void*)&protect_type);
if(FLASH_PROTECT_NONE != protect_type)
{
param = FLASH_PROTECT_NONE;
ddev_control(flash_handle, CMD_FLASH_SET_PROTECT, (void*)&param);
}
/* Calculate the start address of the flash sector(4kbytes) */
addr = addr & 0x00FFF000;
do
{
flash_ctrl(CMD_FLASH_ERASE_SECTOR, &addr);
addr += 4096;
if(_size < 4096)
_size = 0;
else
_size -= 4096;
} while(_size);
if(FLASH_PROTECT_NONE != protect_type)
{
param = protect_type;
ddev_control(flash_handle, CMD_FLASH_SET_PROTECT, (void*)&param);
}
hal_flash_unlock();
return EF_NO_ERR;
#endif
return result;
}
@@ -304,6 +363,33 @@ EfErrCode ef_port_write(uint32_t addr, const uint32_t* buf, size_t size)
return EF_NO_ERR;
#elif PLATFORM_TXW81X || PLATFORM_RDA5981
HAL_FlashWrite(buf, size, addr);
return EF_NO_ERR;
#elif PLATFORM_BEKEN
int param;
UINT32 status;
int protect_type;
DD_HANDLE flash_handle;
hal_flash_lock();
flash_handle = ddev_open(FLASH_DEV_NAME, &status, 0);
ddev_control(flash_handle, CMD_FLASH_GET_PROTECT, (void*)&protect_type);
if(FLASH_PROTECT_NONE != protect_type)
{
param = FLASH_PROTECT_NONE;
ddev_control(flash_handle, CMD_FLASH_SET_PROTECT, (void*)&param);
}
flash_write((char*)buf, (unsigned long)size, addr);
if(FLASH_PROTECT_NONE != protect_type)
{
param = protect_type;
ddev_control(flash_handle, CMD_FLASH_SET_PROTECT, (void*)&param);
}
hal_flash_unlock();
return EF_NO_ERR;
#endif
}

8
platforms/BK723x/OpenBeken.mk
View File

@@ -3,7 +3,7 @@ OBK_DIR = ./app
INCLUDES += -I$(OBK_DIR)/../include
INCLUDES += -I./fixes
CCFLAGS += -DPLATFORM_BEKEN -DPLATFORM_BEKEN_NEW
CCFLAGS += -DPLATFORM_BEKEN -DPLATFORM_BEKEN_NEW -D__FILE__=\"\" -Wno-builtin-macro-redefined
ifeq ($(CFG_SOC_NAME), 1)
CCFLAGS += -DPLATFORM_BK7231T
@@ -43,6 +43,12 @@ APP_CXX += $(OBKM_SRC_CXX)
CCFLAGS += $(OBK_CFLAGS)
APP_C += $(OBK_DIR)/../libraries/easyflash/ports/ef_port.c
APP_C += $(OBK_DIR)/../libraries/easyflash/src/easyflash.c
APP_C += $(OBK_DIR)/../libraries/easyflash/src/ef_env.c
APP_C += $(OBK_DIR)/../libraries/easyflash/src/ef_utils.c
INCLUDES += -I$(OBK_DIR)/../libraries/easyflash/inc
BERRY_MODULEPATH = $(OBK_DIR)/berry/modules
BERRY_SRCPATH = $(OBK_DIR)/../libraries/berry/src
include $(OBK_DIR)/../libraries/berry.mk

2
platforms/RTL87X0C/OpenBeken.mk
View File

@@ -21,7 +21,7 @@ OBK_SRCS = $(OBK_DIR)/src/
include $(OBK_DIR)/platforms/obk_main.mk
SRC_C += $(OBKM_SRC)
SRC_CPP += $(OBKM_SRC_CXX)
CFLAGS += $(OBK_CFLAGS)
CFLAGS += $(OBK_CFLAGS) -D__FILE__=\"\" -Wno-builtin-macro-redefined
CPPFLAGS += $(INCLUDES) -fpermissive
SRC_C += $(OBK_DIR)/libraries/easyflash/ports/ef_port.c

10
platforms/W600/Makefile
View File

@@ -32,14 +32,19 @@ CSRCS += $(_SHARED_APP)/hal/w800/hal_ota_w800.c
CSRCS += $(_SHARED_APP)/hal/w800/hal_uart_w800.c
CSRCS += main.c
CSRCS += $(_SHARED_APP)/../libraries/easyflash/ports/ef_port.c
CSRCS += $(_SHARED_APP)/../libraries/easyflash/src/easyflash.c
CSRCS += $(_SHARED_APP)/../libraries/easyflash/src/ef_env.c
CSRCS += $(_SHARED_APP)/../libraries/easyflash/src/ef_utils.c
OBK_SRCS = $(_SHARED_APP)/
include $(_SHARED_APP)/../platforms/obk_main.mk
CSRCS += $(OBKM_SRC)
EXTRA_CCFLAGS += $(OBK_CFLAGS)
EXTRA_CCFLAGS += -D__FILE__=\"\" -Wno-builtin-macro-redefined
CSRCS += $(TOP_DIR)/src/network/lwip2.0.3/apps/mqtt/mqtt.c
#############################################################
# Configuration i.e. compile options etc.
# Target specific stuff (defines etc.) goes in here!
@@ -63,9 +68,8 @@ CSRCS += $(TOP_DIR)/src/network/lwip2.0.3/apps/mqtt/mqtt.c
sinclude $(TOP_DIR)/tools/rules.mk
INCLUDES := $(INCLUDES) -I $(PDIR)include
INCLUDES := $(INCLUDES) -I $(PDIR)include -I$(_SHARED_APP)/../libraries/easyflash/inc
PDIR := ../$(PDIR)
sinclude $(PDIR)Makefile

2
sdk/beken_freertos_sdk

Submodule sdk/beken_freertos_sdk updated: b099007110...54c56bbfa3

1
src/cmnds/cmd_main.c
View File

@@ -338,6 +338,7 @@ static commandResult_t CMD_DeepSleep(const void* context, const char* cmd, const
}
timeMS = Tokenizer_GetArgInteger(0);
HAL_DisconnectFromWifi();
#if defined(PLATFORM_BEKEN) && !defined(PLATFORM_BEKEN_NEW)
// It requires a define in SDK file:
// OpenBK7231T\platforms\bk7231t\bk7231t_os\beken378\func\include\manual_ps_pub.h

21
src/driver/drv_aht2x.c
View File

@@ -13,7 +13,6 @@ static bool isWorking = false;
void AHT2X_SoftReset()
{
ADDLOG_DEBUG(LOG_FEATURE_SENSOR, "AHT2X_SoftReset: Resetting sensor");
Soft_I2C_Start(&g_softI2C, AHT2X_I2C_ADDR);
Soft_I2C_WriteByte(&g_softI2C, AHT2X_CMD_RST);
Soft_I2C_Stop(&g_softI2C);
@@ -42,19 +41,19 @@ void AHT2X_Initialization()
attempts++;
if(attempts > max_retries)
{
ADDLOG_INFO(LOG_FEATURE_SENSOR, "AHT2X_Initialization: Sensor timed out.");
ADDLOG_INFO(LOG_FEATURE_SENSOR, "%s: Sensor timed out.", __func__);
isWorking = false;
break;
}
}
if((data & 0x68) != 0x08)
{
ADDLOG_INFO(LOG_FEATURE_SENSOR, "AHT2X_Initialization: Initialization failed.");
ADDLOG_INFO(LOG_FEATURE_SENSOR, "%s: Initialization failed.", __func__);
isWorking = false;
}
else
{
ADDLOG_INFO(LOG_FEATURE_SENSOR, "AHT2X_Initialization: Initialization successful.");
ADDLOG_INFO(LOG_FEATURE_SENSOR, "%s: Initialization successful.", __func__);
isWorking = true;
}
}
@@ -90,20 +89,20 @@ void AHT2X_Measure()
}
else
{
ADDLOG_DEBUG(LOG_FEATURE_SENSOR, "AHT2X_Measure: Sensor is busy, waiting... (%ims)", i * 20);
ADDLOG_DEBUG(LOG_FEATURE_SENSOR, "%s: Sensor is busy, waiting... (%ims)", __func__, i * 20);
rtos_delay_milliseconds(20);
}
}
if(!ready)
{
ADDLOG_INFO(LOG_FEATURE_SENSOR, "AHT2X_Measure: Measurements reading timed out.");
ADDLOG_INFO(LOG_FEATURE_SENSOR, "%s: Measurements reading timed out.", __func__);
return;
}
if(data[1] == 0x0 && data[2] == 0x0 && (data[3] >> 4) == 0x0)
{
ADDLOG_INFO(LOG_FEATURE_SENSOR, "AHT2X_Measure: Unrealistic humidity, will not update values.");
ADDLOG_INFO(LOG_FEATURE_SENSOR, "%s: Unrealistic humidity, will not update values.", __func__);
return;
}
@@ -122,7 +121,7 @@ void AHT2X_Measure()
CHANNEL_Set(channel_humid, (int)(g_humid), 0);
}
ADDLOG_INFO(LOG_FEATURE_SENSOR, "AHT2X_Measure: Temperature:%fC Humidity:%f%%", g_temp, g_humid);
ADDLOG_INFO(LOG_FEATURE_SENSOR, "%s: Temperature:%fC Humidity:%f%%", __func__, g_temp, g_humid);
}
commandResult_t AHT2X_Calibrate(const void* context, const char* cmd, const char* args, int cmdFlags)
@@ -136,8 +135,6 @@ commandResult_t AHT2X_Calibrate(const void* context, const char* cmd, const char
g_calTemp = Tokenizer_GetArgFloat(0);
g_calHum = Tokenizer_GetArgFloatDefault(1, 0.0f);
ADDLOG_INFO(LOG_FEATURE_SENSOR, "AHT2X_Calibrate: Calibration done temp %f and humidity %f", g_calTemp, g_calHum);
return CMD_RES_OK;
}
@@ -152,7 +149,7 @@ commandResult_t AHT2X_Cycle(const void* context, const char* cmd, const char* ar
int seconds = Tokenizer_GetArgInteger(0);
if(seconds < 1)
{
ADDLOG_INFO(LOG_FEATURE_CMD, "AHT2X_Cycle: You must have at least 1 second cycle.");
ADDLOG_INFO(LOG_FEATURE_CMD, "%s: You must have at least 1 second cycle.", __func__);
return CMD_RES_BAD_ARGUMENT;
}
else
@@ -160,7 +157,7 @@ commandResult_t AHT2X_Cycle(const void* context, const char* cmd, const char* ar
g_aht_secondsBetweenMeasurements = seconds;
}
ADDLOG_INFO(LOG_FEATURE_CMD, "AHT2X_Cycle: Measurement will run every %i seconds.", g_aht_secondsBetweenMeasurements);
ADDLOG_INFO(LOG_FEATURE_CMD, "%s: Measurement will run every %i seconds.", __func__, g_aht_secondsBetweenMeasurements);
return CMD_RES_OK;
}

792
src/hal/bk7231/hal_flashVars_bk7231.c
View File

@@ -1,569 +1,112 @@
/*
This module saves variable data to a flash region in an erase effient way.
#if PLATFORM_BEKEN
Design:
variables to be small - we want as many writes between erases as possible.
sector will be all FF (erased), and data added into it.
reading consists of searching the first non FF byte from the end, then
reading the preceding bytes as the variables.
last byte of data is len (!== 0xFF!)
*/
#ifndef PLATFORM_XR809
#ifdef PLATFORM_BEKEN_NEW
#endif
#include "include.h"
#include "mem_pub.h"
#include "drv_model_pub.h"
#include "net_param_pub.h"
#include "flash_pub.h"
#include "../../new_common.h"
#include "../hal_flashVars.h"
#include "BkDriverFlash.h"
#include "BkDriverUart.h"
#include "../../logging/logging.h"
#include <easyflash.h>
extern FLASH_VARS_STRUCTURE flash_vars;
int flash_vars_init();
int flash_vars_write();
// for testing only... only done once at startup...
extern int flash_vars_offset;
int flash_vars_read(FLASH_VARS_STRUCTURE* data);
//#define TEST_MODE
//#define debug_delay(x) rtos_delay_milliseconds(x)
#define debug_delay(x)
#define FLASH_VARS_MAGIC 0xfefefefe
// NOTE: Changed below according to partitions in SDK!!!!
static unsigned int flash_vars_start = 0x1e3000; //0x1e1000 + 0x1000 + 0x1000; // after netconfig and mystery SSID
static unsigned int flash_vars_len = 0x2000; // two blocks in BK7231
static unsigned int flash_vars_sector_len = 0x1000; // erase size in BK7231
static int g_easyFlash_Ready = 0;
void InitEasyFlashIfNeeded()
{
if(g_easyFlash_Ready == 0)
{
easyflash_init();
g_easyFlash_Ready = 1;
}
}
FLASH_VARS_STRUCTURE flash_vars;
int flash_vars_offset = 0; // offset to first FF in our area
static int flash_vars_initialised = 0; // offset to first FF in our area
static int g_loaded = 0;
static int flash_vars_valid();
static int flash_vars_write_magic();
static int _flash_vars_write(void* data, unsigned int off_set, unsigned int size);
static int flash_vars_erase(unsigned int off_set, unsigned int size);
int flash_vars_read(FLASH_VARS_STRUCTURE* data);
#if WINDOWS
#define TEST_MODE
#elif PLATFORM_XR809
#define TEST_MODE
#else
#endif
#ifdef TEST_MODE
static char test_flash_area[0x2000];
#endif
static void alignOffset(int* offs) {
// do nothing - should work with any offsets
/*
if ((*offs) % 32){
(*offs) += (32- ((*offs)%32));
}*/
}
// initialise and read variables from flash
int flash_vars_init() {
#if WINDOWS
#elif PLATFORM_XR809
#else
bk_logic_partition_t* pt;
#endif
//direct_serial_log = 1;
if (!flash_vars_initialised) {
ADDLOG_DEBUG(LOG_FEATURE_CFG, "flash vars not initialised - reading");
debug_delay(200);
#if WINDOWS
#elif PLATFORM_XR809
#else
pt = bk_flash_get_info(BK_PARTITION_NET_PARAM);
// there is an EXTRA sctor used for some form of wifi?
// on T variety, this is 0x1e3000
flash_vars_start = pt->partition_start_addr + pt->partition_length + 0x1000;
flash_vars_len = 0x2000; // two blocks in BK7231
flash_vars_sector_len = 0x1000; // erase size in BK7231
#endif
//ADDLOG_DEBUG(LOG_FEATURE_CFG, "got part info");
debug_delay(200);
memset(&flash_vars, 0, sizeof(flash_vars));
flash_vars.len = sizeof(flash_vars);
//ADDLOG_DEBUG(LOG_FEATURE_CFG, "cleared structure");
debug_delay(200);
// read any existing
flash_vars_read(&flash_vars);
flash_vars_initialised = 1;
//ADDLOG_DEBUG(LOG_FEATURE_CFG, "read structure");
debug_delay(200);
}
else {
//ADDLOG_DEBUG(LOG_FEATURE_CFG, "flash vars already initialised");
}
return 0;
}
static int flash_vars_valid() {
//uint32_t i;
//uint32_t param;
UINT32 status;
#ifndef TEST_MODE
DD_HANDLE flash_hdl;
#endif
uint32_t start_addr;
unsigned int tmp = 0xffffffff;
GLOBAL_INT_DECLARATION();
//ADDLOG_DEBUG(LOG_FEATURE_CFG, "flash_vars_valid()");
debug_delay(200);
#ifndef TEST_MODE
flash_hdl = ddev_open(FLASH_DEV_NAME, &status, 0);
ASSERT(DD_HANDLE_UNVALID != flash_hdl);
bk_flash_enable_security(FLASH_PROTECT_NONE);
#endif
start_addr = flash_vars_start;
//ADDLOG_DEBUG(LOG_FEATURE_CFG, "flash_vars_valid() flash open");
debug_delay(200);
#ifdef TEST_MODE
memcpy(&tmp, &test_flash_area[start_addr - flash_vars_start], sizeof(tmp));
#else
GLOBAL_INT_DISABLE();
ddev_read(flash_hdl, (char*)&tmp, sizeof(tmp), start_addr);
GLOBAL_INT_RESTORE();
ddev_close(flash_hdl);
bk_flash_enable_security(FLASH_PROTECT_ALL);
#endif
//ADDLOG_DEBUG(LOG_FEATURE_CFG, "flash_vars_valid() copied header 0x%x", tmp);
debug_delay(200);
// if not our magic, then erase and write magic
if (tmp != FLASH_VARS_MAGIC) {
ADDLOG_ERROR(LOG_FEATURE_CFG, "flash_vars_valid - not our magic, erase");
debug_delay(200);
if (flash_vars_write_magic() >= 0) {
ADDLOG_DEBUG(LOG_FEATURE_CFG, "flash initialised");
}
else {
ADDLOG_ERROR(LOG_FEATURE_CFG, "flash initialise failed");
return -1;
}
return 0;
}
return 1;
}
static int flash_vars_write_magic() {
//uint32_t i;
//uint32_t param;
UINT32 status;
#ifndef TEST_MODE
DD_HANDLE flash_hdl;
#endif
uint32_t start_addr;
unsigned int tmp = FLASH_VARS_MAGIC;
GLOBAL_INT_DECLARATION();
//ADDLOG_DEBUG(LOG_FEATURE_CFG, "flash_vars_magic write");
debug_delay(200);
start_addr = flash_vars_start;
//ADDLOG_DEBUG(LOG_FEATURE_CFG, "flash open");
debug_delay(200);
if (flash_vars_erase(0, flash_vars_len) >= 0) {
ADDLOG_DEBUG(LOG_FEATURE_CFG, "flash erased");
debug_delay(200);
}
else {
ADDLOG_ERROR(LOG_FEATURE_CFG, "flash erase failed");
debug_delay(200);
return -1;
}
#ifdef TEST_MODE
memcpy(&test_flash_area[start_addr - flash_vars_start], &tmp, sizeof(tmp));
#else
bk_flash_enable_security(FLASH_PROTECT_NONE);
flash_hdl = ddev_open(FLASH_DEV_NAME, &status, 0);
ASSERT(DD_HANDLE_UNVALID != flash_hdl);
GLOBAL_INT_DISABLE();
ddev_write(flash_hdl, (char*)&tmp, sizeof(tmp), start_addr);
GLOBAL_INT_RESTORE();
ddev_close(flash_hdl);
bk_flash_enable_security(FLASH_PROTECT_ALL);
#endif
ADDLOG_DEBUG(LOG_FEATURE_CFG, "header written");
// next write point
flash_vars_offset = sizeof(tmp);
alignOffset(&flash_vars_offset);
ADDLOG_DEBUG(LOG_FEATURE_CFG, "header written %d", flash_vars_offset);
debug_delay(200);
// write a new structure
flash_vars_write();
return 0;
}
// read data from flash vars area.
// design:
// search from end of flash until we find a non-zero byte.
// this is length of existing data.
// clear structure to 00
// read existing data (excluding len) into structure.
// set len to current structure defn len.
// remember first FF byte offset
int flash_vars_read(FLASH_VARS_STRUCTURE* data) {
//uint32_t i;
//uint32_t param;
UINT32 status;
#ifndef TEST_MODE
DD_HANDLE flash_hdl;
#endif
uint32_t start_addr;
int loops = 0x2100 / 4;
unsigned int tmp = 0xffffffff;
GLOBAL_INT_DECLARATION();
//ADDLOG_DEBUG(LOG_FEATURE_CFG, "flash_vars_read len %d", sizeof(*data));
// check for magic, and reset sector(s) if not.
if (flash_vars_valid() >= 0) {
//ADDLOG_DEBUG(LOG_FEATURE_CFG, "flash vars valid or initialised");
}
else {
ADDLOG_ERROR(LOG_FEATURE_CFG, "flash_vars_validity error");
memset(data, 0, sizeof(*data));
data->len = sizeof(*data);
debug_delay(200);
return -1;
}
debug_delay(200);
#ifndef TEST_MODE
flash_hdl = ddev_open(FLASH_DEV_NAME, &status, 0);
ASSERT(DD_HANDLE_UNVALID != flash_hdl);
bk_flash_enable_security(FLASH_PROTECT_NONE);
#endif
start_addr = flash_vars_start + flash_vars_len;
do {
start_addr -= sizeof(tmp);
#ifdef TEST_MODE
memcpy(&tmp, &test_flash_area[start_addr - flash_vars_start], sizeof(tmp));
#else
GLOBAL_INT_DISABLE();
ddev_read(flash_hdl, (char*)&tmp, sizeof(tmp), start_addr);
GLOBAL_INT_RESTORE();
#endif
} while ((tmp == 0xFFFFFFFF) && (start_addr > flash_vars_start + 4) && (loops--));
if (!loops) {
ADDLOG_ERROR(LOG_FEATURE_CFG, "loops over addr 0x%X", start_addr);
}
//ADDLOG_DEBUG(LOG_FEATURE_CFG, "found at %u 0x%X", start_addr, tmp);
start_addr += sizeof(tmp);
debug_delay(200);
if (tmp == 0xffffffff) {
// no data found, all erased
// clear result.
memset(data, 0, sizeof(*data));
// set the len to the latest revision's len
data->len = sizeof(*data);
#ifndef TEST_MODE
ddev_close(flash_hdl);
bk_flash_enable_security(FLASH_PROTECT_ALL);
#endif
ADDLOG_INFO(LOG_FEATURE_CFG, "new flash vars");
return 0;
}
else {
int shifts = 0;
int len = 0;
while ((tmp & 0xFF000000) == 0xFF000000) {
tmp <<= 8;
shifts++;
}
len = (tmp >> 24) & 0xff;
start_addr -= shifts;
start_addr -= len;
if (len > sizeof(*data)) {
ADDLOG_ERROR(LOG_FEATURE_CFG, "len (%d) in flash_var greater than current structure len (%d)", len, sizeof(*data));
#ifndef TEST_MODE
ddev_close(flash_hdl);
bk_flash_enable_security(FLASH_PROTECT_ALL);
#endif
// erase it all and write a new one
flash_vars_write_magic();
}
else {
// clear result.
memset(data, 0, sizeof(*data));
// read the DATA portion into the structure
#ifdef TEST_MODE
memcpy(data, &test_flash_area[start_addr - flash_vars_start], len - 1);
#else
GLOBAL_INT_DISABLE();
ddev_read(flash_hdl, (char*)data, len - 1, start_addr);
GLOBAL_INT_RESTORE();
ddev_close(flash_hdl);
bk_flash_enable_security(FLASH_PROTECT_ALL);
#endif
// set the len to the latest revision's len
data->len = sizeof(*data);
flash_vars_offset = (start_addr - flash_vars_start) + len;
alignOffset(&flash_vars_offset);
ADDLOG_DEBUG(LOG_FEATURE_CFG, "new offset after read %d, boot_count %d, success count %d",
flash_vars_offset,
data->boot_count,
data->boot_success_count
);
}
return 1;
}
}
int flash_vars_write() {
//ADDLOG_DEBUG(LOG_FEATURE_CFG, "flash vars write");
flash_vars_init();
alignOffset(&flash_vars_offset);
FLASH_VARS_STRUCTURE* data = &flash_vars;
if (flash_vars_offset + data->len > flash_vars_len) {
if (flash_vars_write_magic() >= 0) {
ADDLOG_ERROR(LOG_FEATURE_CFG, "flash reinitialised");
}
else {
ADDLOG_ERROR(LOG_FEATURE_CFG, "flash reinitialise failed");
return -1;
}
}
//ADDLOG_DEBUG(LOG_FEATURE_CFG, "flash vars write at offset %d len %d", flash_vars_offset, data->len);
_flash_vars_write(data, flash_vars_offset, data->len);
flash_vars_offset += data->len;
alignOffset(&flash_vars_offset);
ADDLOG_DEBUG(LOG_FEATURE_CFG, "new offset %d, boot_count %d, success count %d",
flash_vars_offset,
data->boot_count,
data->boot_success_count
);
return 1;
}
// write updated data to flash vars area.
// off_set is zero based. size in bytes
// TODO - test we CAN write at a byte boundary?
// answer - the flash driver in theroy deals with than... writes are always in chunks of 32 bytes
// on 32 byte boundaries.
int _flash_vars_write(void* data, unsigned int off_set, unsigned int size) {
//uint32_t i;
//uint32_t param;
UINT32 status;
#ifndef TEST_MODE
DD_HANDLE flash_hdl;
#endif
uint32_t start_addr;
GLOBAL_INT_DECLARATION();
//ADDLOG_DEBUG(LOG_FEATURE_CFG, "_flash vars write offset %d, size %d", off_set, size);
#ifndef TEST_MODE
flash_hdl = ddev_open(FLASH_DEV_NAME, &status, 0);
ASSERT(DD_HANDLE_UNVALID != flash_hdl);
bk_flash_enable_security(FLASH_PROTECT_NONE);
#endif
start_addr = flash_vars_start + off_set;
if (start_addr <= flash_vars_start) {
ADDLOG_ERROR(LOG_FEATURE_CFG, "_flash vars write invalid addr 0x%X", start_addr);
ddev_close(flash_hdl);
bk_flash_enable_security(FLASH_PROTECT_ALL);
return -1;
}
if (start_addr + size > flash_vars_start + flash_vars_len) {
ADDLOG_ERROR(LOG_FEATURE_CFG, "_flash vars write invalid addr 0x%X len 0x%X", start_addr, size);
ddev_close(flash_hdl);
bk_flash_enable_security(FLASH_PROTECT_ALL);
return -1;
}
#ifdef TEST_MODE
memcpy(&test_flash_area[start_addr - flash_vars_start], data, size);
#else
GLOBAL_INT_DISABLE();
ddev_write(flash_hdl, data, size, start_addr);
GLOBAL_INT_RESTORE();
ddev_close(flash_hdl);
bk_flash_enable_security(FLASH_PROTECT_ALL);
#endif
//ADDLOG_DEBUG(LOG_FEATURE_CFG, "_flash vars write wrote offset %d, size %d", off_set, size);
return 0;
}
// erase one or more of the sectors we are using.
// off_set is zero based. size in bytes
// in theory, can't erase outside of OUR area.
int flash_vars_erase(unsigned int off_set, unsigned int size) {
uint32_t i;
uint32_t param;
UINT32 status;
#ifndef TEST_MODE
DD_HANDLE flash_hdl;
#endif
uint32_t start_sector, end_sector;
GLOBAL_INT_DECLARATION();
ADDLOG_DEBUG(LOG_FEATURE_CFG, "flash vars erase at offset %d len %d", off_set, size);
#ifndef TEST_MODE
flash_hdl = ddev_open(FLASH_DEV_NAME, &status, 0);
ASSERT(DD_HANDLE_UNVALID != flash_hdl);
bk_flash_enable_security(FLASH_PROTECT_NONE);
#endif
start_sector = off_set >> 12;
end_sector = (off_set + size - 1) >> 12;
for (i = start_sector; i <= end_sector; i++)
{
param = flash_vars_start + (i << 12);
if (param < flash_vars_start) {
ADDLOG_ERROR(LOG_FEATURE_CFG, "flash vars erase invalid addr 0x%X < 0x%X", param, flash_vars_start);
#ifndef TEST_MODE
ddev_close(flash_hdl);
bk_flash_enable_security(FLASH_PROTECT_ALL);
#endif
return -1;
}
if (param + flash_vars_sector_len > flash_vars_start + flash_vars_len) {
ADDLOG_ERROR(LOG_FEATURE_CFG, "flash vars erase invalid addr 0x%X+0x%X > 0x%X", param, flash_vars_sector_len, flash_vars_start + flash_vars_len);
#ifndef TEST_MODE
ddev_close(flash_hdl);
bk_flash_enable_security(FLASH_PROTECT_ALL);
#endif
return -1;
}
ADDLOG_DEBUG(LOG_FEATURE_CFG, "flash vars erase block at addr 0x%X", param);
#ifdef TEST_MODE
memset(&test_flash_area[param - flash_vars_start], 0xff, 0x1000);
#else
GLOBAL_INT_DISABLE();
ddev_control(flash_hdl, CMD_FLASH_ERASE_SECTOR, (void*)&param);
GLOBAL_INT_RESTORE();
#endif
}
#ifndef TEST_MODE
ddev_close(flash_hdl);
bk_flash_enable_security(FLASH_PROTECT_ALL);
#endif
//ADDLOG_DEBUG(LOG_FEATURE_CFG, "flash vars erase end");
return 0;
}
//#define DISABLE_FLASH_VARS_VARS
// call at startup
void HAL_FlashVars_IncreaseBootCount() {
#ifndef DISABLE_FLASH_VARS_VARS
FLASH_VARS_STRUCTURE data;
flash_vars_init();
flash_vars.boot_count++;
ADDLOG_INFO(LOG_FEATURE_CFG, "####### Boot Count %d #######", flash_vars.boot_count);
flash_vars_write();
flash_vars_read(&data);
ADDLOG_DEBUG(LOG_FEATURE_CFG, "re-read - offset %d, boot count %d, boot success %d, bootfailures %d",
flash_vars_offset,
data.boot_count,
data.boot_success_count,
data.boot_count - data.boot_success_count);
#endif
}
void HAL_FlashVars_SaveChannel(int index, int value) {
#ifndef DISABLE_FLASH_VARS_VARS
FLASH_VARS_STRUCTURE data;
if (index < 0 || index >= MAX_RETAIN_CHANNELS) {
ADDLOG_INFO(LOG_FEATURE_CFG, "####### Flash Save Can't Save Channel %d as %d (not enough space in array) #######", index, value);
return;
}
flash_vars_init();
flash_vars.savedValues[index] = value;
ADDLOG_INFO(LOG_FEATURE_CFG, "####### Flash Save Channel %d as %d #######", index, value);
flash_vars_write();
flash_vars_read(&data);
ADDLOG_DEBUG(LOG_FEATURE_CFG, "re-read - offset %d, boot count %d, boot success %d, bootfailures %d",
flash_vars_offset,
data.boot_count,
data.boot_success_count,
data.boot_count - data.boot_success_count);
#endif
}
void HAL_FlashVars_ReadLED(byte* mode, short* brightness, short* temperature, byte* rgb, byte* bEnableAll) {
#ifndef DISABLE_FLASH_VARS_VARS
* bEnableAll = flash_vars.savedValues[MAX_RETAIN_CHANNELS - 4];
*mode = flash_vars.savedValues[MAX_RETAIN_CHANNELS - 3];
*temperature = flash_vars.savedValues[MAX_RETAIN_CHANNELS - 2];
*brightness = flash_vars.savedValues[MAX_RETAIN_CHANNELS - 1];
rgb[0] = flash_vars.rgb[0];
rgb[1] = flash_vars.rgb[1];
rgb[2] = flash_vars.rgb[2];
#endif
}
#define KV_KEY_FLASH_VARS "OBK_FV"
#define SAVE_CHANGE_IF_REQUIRED_AND_COUNT(target, source, counter) \
if((target) != (source)) { \
(target) = (source); \
counter++; \
}
void HAL_FlashVars_SaveLED(byte mode, short brightness, short temperature, byte r, byte g, byte b, byte bEnableAll) {
#ifndef DISABLE_FLASH_VARS_VARS
FLASH_VARS_STRUCTURE data;
extern void InitEasyFlashIfNeeded();
static int ReadFlashVars(void* target, int dataLen)
{
InitEasyFlashIfNeeded();
int readLen;
ADDLOG_DEBUG(LOG_FEATURE_CFG, "%s: to read %d b", __func__, dataLen);
readLen = ef_get_env_blob(KV_KEY_FLASH_VARS, target, dataLen, NULL);
ADDLOG_DEBUG(LOG_FEATURE_CFG, "%s: read %d b", __func__, readLen);
g_loaded = 1;
return dataLen;
}
static int SaveFlashVars(void* src, int dataLen)
{
InitEasyFlashIfNeeded();
EfErrCode res;
res = ef_set_env_blob(KV_KEY_FLASH_VARS, src, dataLen);
if(res == EF_ENV_INIT_FAILED)
{
ADDLOG_DEBUG(LOG_FEATURE_CFG, "%s: init failed for %d b", __func__, dataLen);
return 0;
}
if(res == EF_ENV_NAME_ERR)
{
ADDLOG_DEBUG(LOG_FEATURE_CFG, "%s: name err for %d b", __func__, dataLen);
return 0;
}
ADDLOG_DEBUG(LOG_FEATURE_CFG, "%s: saved %d b", __func__, dataLen);
return dataLen;
}
// call at startup
void HAL_FlashVars_IncreaseBootCount()
{
memset(&flash_vars, 0, sizeof(flash_vars));
if(g_loaded == 0)
{
ReadFlashVars(&flash_vars, sizeof(flash_vars));
}
flash_vars.boot_count++;
SaveFlashVars(&flash_vars, sizeof(flash_vars));
}
void HAL_FlashVars_SaveChannel(int index, int value)
{
if(index < 0 || index >= MAX_RETAIN_CHANNELS)
return;
if(g_loaded == 0)
{
ReadFlashVars(&flash_vars, sizeof(flash_vars));
}
flash_vars.savedValues[index] = value;
// save after increase
SaveFlashVars(&flash_vars, sizeof(flash_vars));
}
void HAL_FlashVars_ReadLED(byte* mode, short* brightness, short* temperature, byte* rgb, byte* bEnableAll)
{
if(g_loaded == 0)
{
ReadFlashVars(&flash_vars, sizeof(flash_vars));
}
*bEnableAll = flash_vars.savedValues[MAX_RETAIN_CHANNELS - 4];
*mode = flash_vars.savedValues[MAX_RETAIN_CHANNELS - 3];
*temperature = flash_vars.savedValues[MAX_RETAIN_CHANNELS - 2];
*brightness = flash_vars.savedValues[MAX_RETAIN_CHANNELS - 1];
rgb[0] = flash_vars.rgb[0];
rgb[1] = flash_vars.rgb[1];
rgb[2] = flash_vars.rgb[2];
}
void HAL_FlashVars_SaveLED(byte mode, short brightness, short temperature, byte r, byte g, byte b, byte bEnableAll)
{
int iChangesCount = 0;
if(g_loaded == 0)
{
ReadFlashVars(&flash_vars, sizeof(flash_vars));
}
flash_vars_init();
SAVE_CHANGE_IF_REQUIRED_AND_COUNT(flash_vars.savedValues[MAX_RETAIN_CHANNELS - 1], brightness, iChangesCount);
SAVE_CHANGE_IF_REQUIRED_AND_COUNT(flash_vars.savedValues[MAX_RETAIN_CHANNELS - 2], temperature, iChangesCount);
SAVE_CHANGE_IF_REQUIRED_AND_COUNT(flash_vars.savedValues[MAX_RETAIN_CHANNELS - 3], mode, iChangesCount);
@@ -572,166 +115,103 @@ void HAL_FlashVars_SaveLED(byte mode, short brightness, short temperature, byte
SAVE_CHANGE_IF_REQUIRED_AND_COUNT(flash_vars.rgb[1], g, iChangesCount);
SAVE_CHANGE_IF_REQUIRED_AND_COUNT(flash_vars.rgb[2], b, iChangesCount);
if (iChangesCount > 0) {
ADDLOG_INFO(LOG_FEATURE_CFG, "####### Flash Save LED #######");
flash_vars_write();
flash_vars_read(&data);
ADDLOG_DEBUG(LOG_FEATURE_CFG, "re-read - offset %d, boot count %d, boot success %d, bootfailures %d",
flash_vars_offset,
data.boot_count,
data.boot_success_count,
data.boot_count - data.boot_success_count);
if(iChangesCount > 0)
{
SaveFlashVars(&flash_vars, sizeof(flash_vars));
}
#endif
}
short HAL_FlashVars_ReadUsage() {
#ifndef DISABLE_FLASH_VARS_VARS
return flash_vars.savedValues[MAX_RETAIN_CHANNELS - 1];
#endif
short HAL_FlashVars_ReadUsage()
{
return flash_vars.savedValues[MAX_RETAIN_CHANNELS - 1];
}
void HAL_FlashVars_SaveTotalUsage(short usage) {
#ifndef DISABLE_FLASH_VARS_VARS
FLASH_VARS_STRUCTURE data;
flash_vars_init();
void HAL_FlashVars_SaveTotalUsage(short usage)
{
flash_vars.savedValues[MAX_RETAIN_CHANNELS - 1] = usage;
ADDLOG_INFO(LOG_FEATURE_CFG, "####### Flash Save Usage #######");
flash_vars_write();
flash_vars_read(&data);
ADDLOG_DEBUG(LOG_FEATURE_CFG, "re-read - offset %d, boot count %d, boot success %d, bootfailures %d",
flash_vars_offset,
data.boot_count,
data.boot_success_count,
data.boot_count - data.boot_success_count);
#endif
}
// call once started (>30s?)
void HAL_FlashVars_SaveBootComplete() {
#ifndef DISABLE_FLASH_VARS_VARS
FLASH_VARS_STRUCTURE data;
// mark that we have completed a boot.
ADDLOG_INFO(LOG_FEATURE_CFG, "####### Set Boot Complete #######");
void HAL_FlashVars_SaveBootComplete()
{
flash_vars.boot_success_count = flash_vars.boot_count;
flash_vars_write();
flash_vars_read(&data);
ADDLOG_DEBUG(LOG_FEATURE_CFG, "re-read - offset %d, boot count %d, boot success %d, bootfailures %d",
flash_vars_offset,
data.boot_count,
data.boot_success_count,
data.boot_count - data.boot_success_count);
#endif
SaveFlashVars(&flash_vars, sizeof(flash_vars));
}
// call to return the number of boots since a HAL_FlashVars_SaveBootComplete
int HAL_FlashVars_GetBootFailures() {
int HAL_FlashVars_GetBootFailures()
{
int diff = 0;
#ifndef DISABLE_FLASH_VARS_VARS
diff = flash_vars.boot_count - flash_vars.boot_success_count;
#endif
return diff;
}
int HAL_FlashVars_GetBootCount() {
int HAL_FlashVars_GetBootCount()
{
return flash_vars.boot_count;
}
int HAL_FlashVars_GetChannelValue(int ch) {
if (ch < 0 || ch >= MAX_RETAIN_CHANNELS) {
ADDLOG_INFO(LOG_FEATURE_CFG, "####### Flash Save Can't Get Channel %d (not enough space in array) #######", ch);
int HAL_FlashVars_GetChannelValue(int ch)
{
if(ch < 0 || ch >= MAX_RETAIN_CHANNELS)
return 0;
if(g_loaded == 0)
{
ReadFlashVars(&flash_vars, sizeof(flash_vars));
}
return flash_vars.savedValues[ch];
}
int HAL_GetEnergyMeterStatus(ENERGY_METERING_DATA* data)
{
#ifndef DISABLE_FLASH_VARS_VARS
if (!flash_vars_initialised)
{
flash_vars_init();
}
if (data != NULL)
if(data != NULL)
{
if(g_loaded == 0)
{
ReadFlashVars(&flash_vars, sizeof(flash_vars));
}
memcpy(data, &flash_vars.emetering, sizeof(ENERGY_METERING_DATA));
}
#endif
return 0;
}
int HAL_SetEnergyMeterStatus(ENERGY_METERING_DATA* data)
{
#ifndef DISABLE_FLASH_VARS_VARS
FLASH_VARS_STRUCTURE tmp;
// mark that we have completed a boot.
if (data != NULL)
if(data != NULL)
{
memcpy(&flash_vars.emetering, data, sizeof(ENERGY_METERING_DATA));
flash_vars_write();
flash_vars_read(&tmp);
SaveFlashVars(&flash_vars, sizeof(flash_vars));
}
#endif
return 0;
}
void HAL_FlashVars_SaveTotalConsumption(float total_consumption)
{
#ifndef DISABLE_FLASH_VARS_VARS
flash_vars.emetering.TotalConsumption = total_consumption;
#endif
}
void HAL_FlashVars_SaveEnergyExport(float f)
{
// use two last retain channels as float,
// I don't think it will cause a clash, power metering devices dont use that many channels anyway
memcpy(&flash_vars.savedValues[MAX_RETAIN_CHANNELS - 2], &f, sizeof(float));
}
float HAL_FlashVars_GetEnergyExport()
{
float f;
memcpy(&f, &flash_vars.savedValues[MAX_RETAIN_CHANNELS - 2], sizeof(float));
return f;
}
#ifdef ENABLE_DRIVER_HLW8112SPI
//#ifdef ENABLE_DRIVER_HLW8112SPI
void HAL_FlashVars_SaveEnergy(ENERGY_DATA** data, int channel_count)
{
#ifndef DISABLE_FLASH_VARS_VARS
FLASH_VARS_STRUCTURE tmp;
if (data != NULL)
if(data != NULL)
{
uintptr_t base = (uintptr_t) &flash_vars.emetering;
for(int i =0 ; i < channel_count; i++){
int offset =( i * sizeof(ENERGY_DATA));
uintptr_t flash_addr = base + offset ;
memcpy((void *)flash_addr, data[i], sizeof(ENERGY_DATA));
for(int i = 0; i < channel_count; i++)
{
char buffer[20];
sprintf(buffer, "HLW_CH%i", i);
ef_set_env_blob(buffer, data[i], sizeof(ENERGY_DATA));
}
flash_vars_write();
flash_vars_read(&tmp);
}
#endif
}
void HAL_FlashVars_GetEnergy(ENERGY_DATA* data, ENERGY_CHANNEL channel)
void HAL_FlashVars_GetEnergy(ENERGY_DATA* data, ENERGY_CHANNEL channel)
{
#ifndef DISABLE_FLASH_VARS_VARS
if (!flash_vars_initialised)
if(data != NULL)
{
flash_vars_init();
char buffer[20];
sprintf(buffer, "HLW_CH%i", channel);
ef_get_env_blob(buffer, data, sizeof(ENERGY_DATA), NULL);
}
if (data != NULL)
{
int offset =((channel) * sizeof(ENERGY_DATA));
uintptr_t base = (uintptr_t) &flash_vars.emetering;
uintptr_t flash_addr = base + offset;
memcpy(data ,(void *)flash_addr, sizeof(ENERGY_DATA));
}
#endif
}
#endif
//#endif
#endif

47
src/hal/bk7231/hal_wifi_bk7231.c
View File

@@ -38,7 +38,7 @@ static char g_IP[32] = "unknown";
static int g_bOpenAccessPointMode = 0;
char *get_security_type(int type);
bool g_bStaticIP = false, g_needFastConnectSave = false;
static obkFastConnectData_t fcdata = { 0 };
IPStatusTypedef ipStatus;
// This must return correct IP for both SOFT_AP and STATION modes,
// because, for example, javascript control panel requires it
@@ -194,10 +194,10 @@ void HAL_PrintNetworkInfo()
// If we use password instead of psk, then first attempt to connect will almost always fail.
// And even if it succeeds, first connect is not faster.
ADDLOG_WARN(LOG_FEATURE_GENERAL, "Fast connect is not supported with current AP encryption.");
if(g_cfg.fcdata.channel != 0)
if(fcdata.channel != 0)
{
g_cfg.fcdata.channel = 0;
g_cfg_pendingChanges++;
fcdata.channel = 0;
HAL_DisableEnhancedFastConnect();
}
}
else
@@ -212,17 +212,17 @@ void HAL_PrintNetworkInfo()
for(int i = 0; i < 32 && sprintf(psks + i * 2, "%02x", psk[i]) == 2; i++);
if(memcmp((char*)psks, g_cfg.fcdata.psk, 64) != 0 ||
memcmp(g_cfg.fcdata.bssid, linkStatus.bssid, 6) != 0 ||
linkStatus.channel != g_cfg.fcdata.channel ||
linkStatus.security != g_cfg.fcdata.security_type)
if(memcmp((char*)psks, fcdata.psk, 64) != 0 ||
memcmp(fcdata.bssid, linkStatus.bssid, 6) != 0 ||
linkStatus.channel != fcdata.channel ||
linkStatus.security != fcdata.security_type)
{
ADDLOG_INFO(LOG_FEATURE_GENERAL, "Saved fast connect data differ to current one, saving...");
memcpy(g_cfg.fcdata.bssid, linkStatus.bssid, 6);
g_cfg.fcdata.channel = linkStatus.channel;
g_cfg.fcdata.security_type = linkStatus.security;
memcpy(g_cfg.fcdata.psk, psks, sizeof(g_cfg.fcdata.psk));
g_cfg_pendingChanges++;
memcpy(fcdata.bssid, linkStatus.bssid, 6);
fcdata.channel = linkStatus.channel;
fcdata.security_type = linkStatus.security;
memcpy(fcdata.psk, psks, sizeof(fcdata.psk));
ef_set_env_blob("fcdata", &fcdata, sizeof(obkFastConnectData_t));
}
}
g_needFastConnectSave = false;
@@ -402,19 +402,16 @@ void HAL_ConnectToWiFi(const char* oob_ssid, const char* connect_key, obkStaticI
void HAL_FastConnectToWiFi(const char* oob_ssid, const char* connect_key, obkStaticIP_t* ip)
{
if(strnlen(g_cfg.fcdata.psk, 64) == 64 &&
g_cfg.fcdata.channel != 0 &&
g_cfg.fcdata.security_type != 0 &&
!(g_cfg.fcdata.bssid[0] == 0 && g_cfg.fcdata.bssid[1] == 0 && g_cfg.fcdata.bssid[2] == 0 &&
g_cfg.fcdata.bssid[3] == 0 && g_cfg.fcdata.bssid[4] == 0 && g_cfg.fcdata.bssid[5] == 0))
int len = ef_get_env_blob("fcdata", &fcdata, sizeof(obkFastConnectData_t), NULL);
if(len == sizeof(obkFastConnectData_t) && fcdata.channel != 0)
{
ADDLOG_INFO(LOG_FEATURE_GENERAL, "We have fast connection data, connecting...");
network_InitTypeDef_adv_st network_cfg;
memset(&network_cfg, 0, sizeof(network_InitTypeDef_adv_st));
strcpy(network_cfg.ap_info.ssid, oob_ssid);
memcpy(network_cfg.key, g_cfg.fcdata.psk, 64);
memcpy(network_cfg.key, fcdata.psk, 64);
network_cfg.key_len = 64;
memcpy(network_cfg.ap_info.bssid, g_cfg.fcdata.bssid, sizeof(g_cfg.fcdata.bssid));
memcpy(network_cfg.ap_info.bssid, fcdata.bssid, sizeof(fcdata.bssid));
if(ip->localIPAddr[0] == 0)
{
@@ -430,8 +427,8 @@ void HAL_FastConnectToWiFi(const char* oob_ssid, const char* connect_key, obkSta
convert_IP_to_string(network_cfg.dns_server_ip_addr, ip->dnsServerIpAddr);
g_bStaticIP = true;
}
network_cfg.ap_info.channel = g_cfg.fcdata.channel;
network_cfg.ap_info.security = g_cfg.fcdata.security_type;
network_cfg.ap_info.channel = fcdata.channel;
network_cfg.ap_info.security = fcdata.security_type;
network_cfg.wifi_retry_interval = 100;
bk_wlan_start_sta_adv(&network_cfg);
@@ -445,11 +442,7 @@ void HAL_FastConnectToWiFi(const char* oob_ssid, const char* connect_key, obkSta
void HAL_DisableEnhancedFastConnect()
{
if(g_cfg.fcdata.channel != 0)
{
g_cfg.fcdata.channel = 0;
g_cfg_pendingChanges++;
}
ef_del_env("fcdata");
}
void HAL_DisconnectFromWifi()

4
src/hal/hal_flashVars.h
View File

@@ -19,11 +19,7 @@ typedef struct ENERGY_METERING_DATA {
#else
float ConsumptionHistory[2];
#endif
#ifdef PLATFORM_BEKEN_NEW
unsigned int ConsumptionResetTime;
#else
time_t ConsumptionResetTime;
#endif
unsigned char reseved[3];
char actual_mday;
} ENERGY_METERING_DATA;

2
src/hal/w800/hal_flashConfig_w800.c
View File

@@ -16,7 +16,7 @@ void initFlashIfNeeded() {
tls_fls_init(); //initialize flash driver
#if defined(PLATFORM_W800)
#if defined(PLATFORM_W800) || defined(PLATFORM_W600)
easyflash_init();
#endif
bFlashReady = 1;

62
src/hal/w800/hal_flashVars_w800.c
View File

@@ -6,55 +6,17 @@
FLASH_VARS_STRUCTURE flash_vars;
static int FLASH_VARS_STRUCTURE_SIZE = sizeof(FLASH_VARS_STRUCTURE);
//W800 - 0x1F0303 is based on sdk\OpenW600\demo\wm_flash_demo.c
//W600 - 0xF0000 is based on sdk\OpenW600\demo\wm_flash_demo.c
//2528 was picked based on current sizeof(mainConfig_t) which is 2016 with 512 buffer bytes.
#if defined(PLATFORM_W600)
#define FLASH_VARS_STRUCTURE_ADDR (0xF0000 + 2528)
#else
#include "easyflash.h"
#endif
#define SAVE_CHANGE_IF_REQUIRED_AND_COUNT(target, source, counter) \
if((target) != (source)) { \
(target) = (source); \
counter++; \
}
static const char extrahdr[] = "#######";
void initFlashIfNeeded();
#if PLATFORM_W600
/// @brief This prints the current boot count as a way to visually verify the flash write operation.
void print_flash_boot_count() {
FLASH_VARS_STRUCTURE data;
tls_fls_read(FLASH_VARS_STRUCTURE_ADDR, &data, FLASH_VARS_STRUCTURE_SIZE);
ADDLOG_DEBUG(LOG_FEATURE_CFG, "boot count %d, boot success %d, bootfailures %d",
data.boot_count,
data.boot_success_count,
data.boot_count - data.boot_success_count
);
}
void write_flash_boot_content() {
tls_fls_write(FLASH_VARS_STRUCTURE_ADDR, &flash_vars, FLASH_VARS_STRUCTURE_SIZE);
print_flash_boot_count();
}
/// @brief Update the boot count in flash. This is called called at startup. This is what initializes flash_vars.
void HAL_FlashVars_IncreaseBootCount() {
initFlashIfNeeded();
tls_fls_read(FLASH_VARS_STRUCTURE_ADDR, &flash_vars, FLASH_VARS_STRUCTURE_SIZE);
flash_vars.boot_count++;
ADDLOG_INFO(LOG_FEATURE_CFG, "####### Boot Count %d #######", flash_vars.boot_count);
write_flash_boot_content();
}
#else
#define KV_KEY_FLASH_VARS "OBK_FV"
/// @brief This prints the current boot count as a way to visually verify the flash write operation.
@@ -83,15 +45,13 @@ void HAL_FlashVars_IncreaseBootCount()
ef_get_env_blob(KV_KEY_FLASH_VARS, &flash_vars, FLASH_VARS_STRUCTURE_SIZE, NULL);
flash_vars.boot_count++;
ADDLOG_INFO(LOG_FEATURE_CFG, "####### Boot Count %d #######", flash_vars.boot_count);
ADDLOG_INFO(LOG_FEATURE_CFG, "%s Boot Count %d %s", extrahdr, flash_vars.boot_count, extrahdr);
write_flash_boot_content();
}
#endif
void HAL_FlashVars_SaveChannel(int index, int value) {
if (index < 0 || index >= MAX_RETAIN_CHANNELS) {
ADDLOG_INFO(LOG_FEATURE_CFG, "####### Flash Save Can't Save Channel %d as %d (not enough space in array) #######", index, value);
ADDLOG_INFO(LOG_FEATURE_CFG, "%s Flash Save Can't Save Channel %d as %d (not enough space in array) %s", extrahdr, index, value, extrahdr);
return;
}
@@ -101,7 +61,7 @@ void HAL_FlashVars_SaveChannel(int index, int value) {
// call once started (>30s?)
void HAL_FlashVars_SaveBootComplete() {
ADDLOG_INFO(LOG_FEATURE_CFG, "####### Set Boot Complete #######");
ADDLOG_INFO(LOG_FEATURE_CFG, "%s Set Boot Complete %s", extrahdr, extrahdr);
flash_vars.boot_success_count = flash_vars.boot_count;
write_flash_boot_content();
}
@@ -109,7 +69,7 @@ void HAL_FlashVars_SaveBootComplete() {
// call to return the number of boots since a HAL_FlashVars_SaveBootComplete
int HAL_FlashVars_GetBootFailures() {
int diff = flash_vars.boot_count - flash_vars.boot_success_count;
ADDLOG_INFO(LOG_FEATURE_CFG, "####### HAL_FlashVars_GetBootFailures= %d", diff);
ADDLOG_INFO(LOG_FEATURE_CFG, "%s HAL_FlashVars_GetBootFailures= %d", extrahdr, diff);
return diff;
}
@@ -118,7 +78,7 @@ int HAL_FlashVars_GetBootCount() {
}
int HAL_FlashVars_GetChannelValue(int ch) {
if (ch < 0 || ch >= MAX_RETAIN_CHANNELS) {
ADDLOG_INFO(LOG_FEATURE_CFG, "####### Flash Save Can't Get Channel %d (not enough space in array) #######", ch);
ADDLOG_INFO(LOG_FEATURE_CFG, "%s Flash Save Can't Get Channel %d (not enough space in array) %s", extrahdr, ch, extrahdr);
return 0;
}
@@ -129,11 +89,7 @@ int HAL_FlashVars_GetChannelValue(int ch) {
void HAL_FlashVars_SaveLED(byte mode, short brightness, short temperature, byte r, byte g, byte b, byte bEnableAll) {
#ifndef DISABLE_FLASH_VARS_VARS
int iChangesCount = 0;
#if PLATFORM_W600
tls_fls_read(FLASH_VARS_STRUCTURE_ADDR, &flash_vars, FLASH_VARS_STRUCTURE_SIZE);
#else
ef_get_env_blob(KV_KEY_FLASH_VARS, &flash_vars, FLASH_VARS_STRUCTURE_SIZE, NULL);
#endif
SAVE_CHANGE_IF_REQUIRED_AND_COUNT(flash_vars.savedValues[MAX_RETAIN_CHANNELS - 1], brightness, iChangesCount);
SAVE_CHANGE_IF_REQUIRED_AND_COUNT(flash_vars.savedValues[MAX_RETAIN_CHANNELS - 2], temperature, iChangesCount);
@@ -144,12 +100,8 @@ void HAL_FlashVars_SaveLED(byte mode, short brightness, short temperature, byte
SAVE_CHANGE_IF_REQUIRED_AND_COUNT(flash_vars.rgb[2], b, iChangesCount);
if (iChangesCount > 0) {
ADDLOG_INFO(LOG_FEATURE_CFG, "####### Flash Save LED #######");
#if PLATFORM_W600
tls_fls_write(FLASH_VARS_STRUCTURE_ADDR, &flash_vars, FLASH_VARS_STRUCTURE_SIZE);
#else
ADDLOG_INFO(LOG_FEATURE_CFG, "%s Flash Save LED %s", extrahdr, extrahdr);
ef_set_env_blob(KV_KEY_FLASH_VARS, &flash_vars, FLASH_VARS_STRUCTURE_SIZE);
#endif
}
#endif
}

6
src/new_pins.h
View File

@@ -1576,14 +1576,8 @@ typedef struct mainConfig_s {
// offset 0x00000CBB (3259 decimal)
byte disable_web_server;
// offset 0x00000CBC (3260 decimal)
#if PLATFORM_BEKEN
obkFastConnectData_t fcdata;
// offset 0x00000D0C (3340 decimal)
char unused[244];
#else
char unused[324];
#endif
#endif
} mainConfig_t;
// one sector is 4096 so it we still have some expand possibility

2
src/obk_config.h
View File

@@ -313,7 +313,7 @@
#if PLATFORM_BEKEN_NEW
#define NEW_TCP_SERVER 1
#endif
#define ENABLE_DRIVER_NEO6M 1
//#define ENABLE_DRIVER_NEO6M 1
// ENABLE_I2C_ is a syntax for
// our I2C system defines for drv_i2c_main.c

5
src/user_main.c
View File

@@ -1069,7 +1069,9 @@ void Main_OnEverySecond()
#if ENABLE_DRIVER_HLW8112SPI
HLW8112_Save_Statistics();
#endif
ADDLOGF_INFO("Going to call HAL_RebootModule\r\n");
ADDLOGF_INFO("Rebooting...\r\n");
// call disconnect so that fast connect wouldn't fail
HAL_DisconnectFromWifi();
HAL_RebootModule();
}
else {
@@ -1116,6 +1118,7 @@ void QuickTick(void* param)
{
if (g_bWantPinDeepSleep) {
g_bWantPinDeepSleep = 0;
HAL_DisconnectFromWifi();
PINS_BeginDeepSleepWithPinWakeUp(g_pinDeepSleepWakeUp);
return;
}