TXW817 support (#1779)

* txw81x base no makefile * txw81x * gpio fix? * non-working ota * mic
2026-02-20 00:32:37 +01:00 · 2025-09-03 12:46:06 +03:00
parent 948237869f
commit 0d007112b1
40 changed files with 1619 additions and 23 deletions
--- a/.github/workflows/workflow.yaml
+++ b/.github/workflows/workflow.yaml
@@ -500,10 +500,42 @@ jobs:
            output/${{ needs.refs.outputs.version }}${{ matrix.variant != 'default' && '_' || '' }}${{ matrix.variant != 'default' && matrix.variant || '' }}/${{ matrix.platform }}_${{ needs.refs.outputs.version }}${{ matrix.variant != 'default' && '_' || '' }}${{ matrix.variant != 'default' && matrix.variant || '' }}_ota.img
          if-no-files-found: warn

+  build_txw81x:
+    name: Build TXW81X
+    needs: refs
+    runs-on: windows-latest
+    defaults:
+      run:
+        shell: wsl-bash {0}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - platform: OpenTXW81X
+            variant: default
+    steps:
+      - name: Source checkout
+        uses: actions/checkout@v4
+      - uses: Vampire/setup-wsl@v6
+        with:
+          wsl-version: 1
+          distribution: Ubuntu-22.04
+          additional-packages: make
+      - name: Run make
+        run: |
+          make APP_VERSION=${{ needs.refs.outputs.version }}${{ matrix.variant != 'default' && '_' || '' }}${{ matrix.variant != 'default' && matrix.variant || '' }} APP_NAME=${{ matrix.platform }} VARIANT="${{ matrix.variant }}" ${{ matrix.platform }}
+      - name: Save build assets
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{ env.APP_NAME }}_${{ needs.refs.outputs.version }}_${{ matrix.platform }}${{ matrix.variant != 'default' && '_' || '' }}${{ matrix.variant != 'default' && matrix.variant || '' }}
+          path: |
+            output/${{ needs.refs.outputs.version }}${{ matrix.variant != 'default' && '_' || '' }}${{ matrix.variant != 'default' && matrix.variant || '' }}/${{ matrix.platform }}_${{ needs.refs.outputs.version }}${{ matrix.variant != 'default' && '_' || '' }}${{ matrix.variant != 'default' && matrix.variant || '' }}.bin
+          if-no-files-found: warn
+
  merge:
    name: Merge Artifacts
    runs-on: ubuntu-22.04
-    needs: [refs, build, build2, build_idf, build_beken, build_8266]
+    needs: [refs, build, build2, build_idf, build_beken, build_8266, build_txw81x]
    #if: always() && needs.refs.outputs.new_release == 'true' && (github.ref == 'refs/heads/main' || github.ref_name == 'alpha')
    steps:
      - name: Merge Artifacts
--- a/.gitmodules
+++ b/.gitmodules
@@ -73,3 +73,7 @@
 	path = sdk/ameba-rtos
 	url = https://github.com/Ameba-AIoT/ameba-rtos
 	branch = release/v1.1
+[submodule "sdk/OpenTXW81X"]
+	path = sdk/OpenTXW81X
+	url = https://github.com/NonPIayerCharacter/OpenTXW81X
+	branch = main
--- a/.releaserc.yaml
+++ b/.releaserc.yaml
@@ -191,6 +191,7 @@ generateNotes:
        | ESP8266 2MB    | UART Flash | [OpenESP8266_2MB_{{version}}.factory.bin]({{host}}/{{owner}}/{{repository}}/releases/download/{{version}}/OpenESP8266_2MB_{{version}}.factory.bin) |
        | ESP8266 2MB    | OTA Update | [OpenESP8266_{{version}}.img]({{host}}/{{owner}}/{{repository}}/releases/download/{{version}}/OpenESP8266_{{version}}.img)                         |
        | Win32          |            | [obkSimulator_{{version}}.zip]({{host}}/{{owner}}/{{repository}}/releases/download/{{version}}/obkSimulator_{{version}}.zip)                       |
+        | TXW81X         |            | [OpenTXW81X_{{version}}.bin]({{host}}/{{owner}}/{{repository}}/releases/download/{{version}}/OpenTXW81X_{{version}}.bin)                           |


        CCtr Flash = Tuya cloud Cutter flash
--- a/18
+++ b/18
@@ -356,6 +356,15 @@ prebuild_OpenRTL8720E: berry
 	else echo "prebuild for OpenRTL8720E not found ... "; \
 	fi

+prebuild_OpenTXW81X: berry
+	git submodule update --init --recursive --depth=1 sdk/OpenTXW81X
+	if [ ! -e sdk/OpenTXW81X/tools/gcc/csky-elfabiv2 ]; then cd sdk/OpenTXW81X/tools/gcc && tar -xf *.tar.gz; fi
+	@if [ -e platforms/TXW81X/pre_build.sh ]; then \
+		echo "prebuild found for OpenTXW81X"; \
+		sh platforms/TXW81X/pre_build.sh; \
+	else echo "prebuild for OpenTXW81X not found ... "; \
+	fi
+
 # Build main binaries
 OpenBK7231T: prebuild_OpenBK7231T
 	mkdir -p output
@@ -656,6 +665,14 @@ OpenECR6600: prebuild_OpenECR6600
 	cp $(ECRDIR)/build/OpenBeken/ECR6600F_standalone_OpenBeken_allinone.bin output/$(APP_VERSION)/OpenECR6600_$(APP_VERSION).bin
 	cp $(ECRDIR)/build/OpenBeken/ECR6600F_OpenBeken_Compress_ota_packeg.bin output/$(APP_VERSION)/OpenECR6600_$(APP_VERSION)_ota.img
 	
+.PHONY: OpenTXW81X
+OpenTXW81X: prebuild_OpenTXW81X
+	cd sdk/OpenTXW81X/project && make APP_VERSION=$(APP_VERSION) OBK_VARIANT=$(OBK_VARIANT) -j $(shell nproc) && \
+	./BinScript.exe BinScript.BinScript > /dev/null && ./makecode.exe > /dev/null
+	mkdir -p output/$(APP_VERSION)
+	cp sdk/OpenTXW81X/project/APP.bin output/$(APP_VERSION)/OpenTXW81X_$(APP_VERSION).bin
+	#cp sdk/OpenTXW81X/project/APP_compress.bin output/$(APP_VERSION)/OpenTXW81X_$(APP_VERSION)_ota.img
+
 # Add custom Makefile if required
 -include custom.mk

@@ -681,6 +698,7 @@ clean:
 	-test -d ./sdk/ameba-rtos && cd sdk/ameba-rtos/amebadplus_gcc_project && ./build.py -a ../../../platforms/RTL8721DA -c
 	-test -d ./sdk/ameba-rtos && cd sdk/ameba-rtos/amebalite_gcc_project && ./build.py -a ../../../platforms/RTL8720E -c
 	-test -d ./sdk/beken_freertos_sdk && $(MAKE) -C sdk/beken_freertos_sdk clean
+	-test -d ./sdk/OpenTXW81X && $(MAKE) -C sdk/OpenTXW81X/project clean
 	-test -d ./sdk/OpenLN882H/build && cmake --build ./sdk/OpenLN882H/build --target clean
 	-test -d ./platforms/ESP-IDF/build-32 && cmake --build ./platforms/ESP-IDF/build-32 --target clean
 	-test -d ./platforms/ESP-IDF/build-c3 && cmake --build ./platforms/ESP-IDF/build-c3 --target clean
--- a/README.md
+++ b/README.md
@@ -30,6 +30,7 @@ Although this repository is named "OpenBK7231T_App", it has evolved into a multi
 -   RTL87x0E (AmebaLite family) (eg [PKM8710ECF](https://fccid.io/2BASB-PKM8710ECF))
 -   TR6260 (eg [HLK-M20](https://fccid.io/2AD56HLK-M20), XY-WE2S-A V1.1) (see [guide](https://www.elektroda.com/rtvforum/topic4093752.html))
 -   ECR6600 (eg [AXYU](https://developer.tuya.com/en/docs/iot/AXYU?id=Kb0rwbv5b7aiy), [AXY2S](https://developer.tuya.com/en/docs/iot/AXY2S?id=Kb1aztk507fxf), [WG236](https://www.skylabmodule.com/product/wifi6-802-11axbluetooth-ble-5-1-combo-module-wg236), [DSM-036](https://www.dusuniot.com/product-specification/dsm-036-wi-fi6-and-ble-dual-cloud-module]), CDI-WX56600A-00, [BL-M6600XT1](https://jkrorwxhkqmllp5m-static.micyjz.com/BL-M6600XT1_datasheet_V1.0.1.0_230817-aidllBpoKqpljSRnkmnkjlnjp.pdf?dp=GvUApKfKKUAU), [HF-LPT6200](http://www.hi-flying.com/hf-lpt6200) (see [guide](https://www.elektroda.com/rtvforum/topic4111822.html))
+-   TXW81X (eg TXW817-810, see [development thread](https://www.elektroda.com/rtvforum/topic4033757.html))

 Please use automatically compiled binaries from the Releases tab. To build OpenBeken yourself for any supported platform, fork our version of the submodule SDK first, and then check out this app repository alongside it. Details further down. Alternatively consider using the easier [override method.](https://www.elektroda.com/rtvforum/topic4082682.html)

@@ -120,6 +121,8 @@ For BK7231N, BK7231T, BK7231M, BK7238, BL2028N, T34 see our [GUI easy flash tool

 Repository of flash tools for [all other supported platforms](https://github.com/openshwprojects/FlashTools/tree/main)

+TXW81X requires either CK-Link or STM32F103 (64kb flash or more). See [flashing guide](https://www.elektroda.com/rtvforum/topic4123724.html)
+
 # [Docs - MQTT topics, Console Commands, Flags, Constants, Pin Roles, Channel Types, FAQ, autoexec.bat examples](https://github.com/openshwprojects/OpenBK7231T_App/blob/main/docs)

 # Further reading
--- a/docs/platforms.md
+++ b/docs/platforms.md
@@ -24,6 +24,7 @@
 | RTL8721DA<br>RTL8711DAF (AmebaDplus)                    | Realtek         | ✅         | ✅   | ✅⁶   | ✅   | ✅      | ✅   | ✅  | ❌  | ❌         | ✅  | ✅     | ⚠️ |
 | RTL8720E<br>RTL8710ECF (AmebaLite)                      | Realtek         | ✅         | ✅   | ✅⁶   | ✅   | ✅      | ✅   | ✅  | ❌  | ❌         | ✅  | ✅     | ⚠️ |
 | ECR6600                                                 | ESWIN           | ❌         | ✅   | ✅    | ✅   | ✅      | ✅   | ✅⁸ | ⚠️  | ⚠️¹¹       | ✅  | ❌     | ❌ |
+| TXW81X                                                  | Taixin          | ❌         | ❌   | ❌    | ✅   | ❓      | ❌   | ❌  | ❌  | ❌         | ❓  | ❌     | ❌ |

 ✅ - Works
 ❓ - Not tested
--- a/libraries/easyflash/inc/ef_cfg.h
+++ b/libraries/easyflash/inc/ef_cfg.h
@@ -132,6 +132,11 @@
 #define EF_START_ADDR             0xEF000
 #define ENV_AREA_SIZE             0x8000

+#elif PLATFORM_TXW81X
+
+#define EF_START_ADDR             0xEF000
+#define ENV_AREA_SIZE             0x6000
+
 #elif WINDOWS

 #define EF_START_ADDR             0
--- a/libraries/easyflash/ports/ef_port.c
+++ b/libraries/easyflash/ports/ef_port.c
@@ -30,7 +30,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdarg.h>
-#if !WINDOWS
+#if !WINDOWS && !PLATFORM_TXW81X
 #include "FreeRTOS.h"
 #include "semphr.h"
 #include "queue.h"
@@ -55,6 +55,23 @@ flash_t flash;
 #include <image/flash.h>
 #define QueueHandle_t xQueueHandle

+#elif PLATFORM_TXW81X
+
+#include "sys_config.h"
+#include "typesdef.h"
+#include "csi_kernel.h"
+#include "osal/csky/defs.h"
+#include "dev.h"
+#include "hal/spi_nor.h"
+#include "lib/syscfg/syscfg.h"
+#include "osal/csky/string.h"
+
+typedef k_mutex_handle_t QueueHandle_t;
+#define xSemaphoreCreateMutex csi_kernel_mutex_new
+#define xSemaphoreTake(a, b) csi_kernel_mutex_lock(a, b, 0)
+#define xSemaphoreGive(a) csi_kernel_mutex_unlock(a)
+extern struct spi_nor_flash* obk_flash;
+
 #elif WINDOWS

 #include "framework.h"
@@ -155,6 +172,9 @@ EfErrCode ef_port_read(uint32_t addr, uint32_t* buf, size_t size)
 #elif WINDOWS
 	memcpy(buf, env_area + addr, size);
 	return EF_NO_ERR;
+#elif PLATFORM_TXW81X
+	HAL_FlashRead(buf, size, addr);
+	return EF_NO_ERR;
 #endif
 }

@@ -191,6 +211,9 @@ EfErrCode ef_port_erase(uint32_t addr, size_t size)
 	return res;
 #elif WINDOWS
 	memset(env_area + addr, 0xFF, size);
+#elif PLATFORM_TXW81X
+	HAL_FlashEraseSector(addr);
+	return EF_NO_ERR;
 #endif
 	return result;
 }
@@ -227,6 +250,9 @@ EfErrCode ef_port_write(uint32_t addr, const uint32_t* buf, size_t size)
 #elif WINDOWS
 	memcpy(env_area + addr, buf, size);
 	return EF_NO_ERR;
+#elif PLATFORM_TXW81X
+	HAL_FlashWrite(buf, size, addr);
+	return EF_NO_ERR;
 #endif
 }

--- a/platforms/TXW81X/OpenBeken.mk
+++ b/platforms/TXW81X/OpenBeken.mk
@@ -0,0 +1,38 @@
+OBK_DIR = ../../..
+
+CFLAGS +=  -DPLATFORM_TXW81X
+
+INCLUDES += -I$(OBK_DIR)/libraries/easyflash/inc
+
+SRC_C  += $(OBK_DIR)/src/hal/txw81x/hal_flashVars_txw81x.c
+SRC_C  += $(OBK_DIR)/src/hal/txw81x/hal_flashConfig_txw81x.c
+SRC_C  += $(OBK_DIR)/src/hal/txw81x/hal_generic_txw81x.c
+SRC_C  += $(OBK_DIR)/src/hal/txw81x/hal_main_txw81x.c
+SRC_C  += $(OBK_DIR)/src/hal/txw81x/hal_ota_txw81x.c
+SRC_C  += $(OBK_DIR)/src/hal/txw81x/hal_pins_txw81x.c
+SRC_C  += $(OBK_DIR)/src/hal/txw81x/hal_wifi_txw81x.c
+SRC_C  += $(OBK_DIR)/src/driver/drv_txw81x_camera.c
+
+OBK_SRCS = $(OBK_DIR)/src/
+include $(OBK_DIR)/platforms/obk_main.mk
+SRC_C += $(OBKM_SRC)
+CFLAGS += $(OBK_CFLAGS)
+
+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_cmd.c
+SRC_C += $(OBK_DIR)/libraries/easyflash/src/ef_env.c
+SRC_C += $(OBK_DIR)/libraries/easyflash/src/ef_env_legacy.c
+SRC_C += $(OBK_DIR)/libraries/easyflash/src/ef_env_legacy_wl.c
+SRC_C += $(OBK_DIR)/libraries/easyflash/src/ef_iap.c
+SRC_C += $(OBK_DIR)/libraries/easyflash/src/ef_log.c
+SRC_C += $(OBK_DIR)/libraries/easyflash/src/ef_utils.c
+
+INCLUDES += -I$(OBK_DIR)/include
+BERRY_MODULEPATH = $(OBK_DIR)/src/berry/modules
+BERRY_SRCPATH = $(OBK_DIR)/libraries/berry/src
+
+include $(OBK_DIR)/libraries/berry.mk
+
+#SRC_C += $(BERRY_SRC_C)
+SRC_C += $(OBK_DIR)/libraries/mqtt_patched.c
--- a/platforms/obk_main.mk
+++ b/platforms/obk_main.mk
@@ -42,6 +42,7 @@ OBKM_SRC  += $(OBK_SRCS)hal/generic/hal_flashConfig_generic.c
 OBKM_SRC  += $(OBK_SRCS)hal/generic/hal_flashVars_generic.c
 OBKM_SRC  += $(OBK_SRCS)hal/generic/hal_generic.c
 OBKM_SRC  += $(OBK_SRCS)hal/generic/hal_main_generic.c
+OBKM_SRC  += $(OBK_SRCS)hal/generic/hal_ota_generic.c
 OBKM_SRC  += $(OBK_SRCS)hal/generic/hal_pins_generic.c
 OBKM_SRC  += $(OBK_SRCS)hal/generic/hal_wifi_generic.c
 OBKM_SRC  += $(OBK_SRCS)hal/generic/hal_uart_generic.c
--- a/sdk/OpenTXW81X
+++ b/sdk/OpenTXW81X
--- a/src/cmnds/cmd_tokenizer.c
+++ b/src/cmnds/cmd_tokenizer.c
@@ -22,7 +22,7 @@ static int tok_flags = 0;
 #define g_bAllowExpand (!(tok_flags&TOKENIZER_DONT_EXPAND))

 int str_to_ip(const char *s, byte *ip) {
-#if PLATFORM_W600 || PLATFORM_LN882H || PLATFORM_REALTEK || PLATFORM_ECR6600 || PLATFORM_TR6260 || PLATFORM_XRADIO
+#if PLATFORM_W600 || PLATFORM_LN882H || PLATFORM_REALTEK || PLATFORM_ECR6600 || PLATFORM_TR6260 || PLATFORM_XRADIO || PLATFORM_TXW81X
 	//seems like sscanf in W600 does not support %hhu and uses it as %u, thus overwriting more memory, use temp array for it
 	// same for LN882h: %hhu isn't recognised, so we have to use %u for IP_STRING_FORMAT, which will lead to problems in sscanf, too
 	int tmp_ip[4];
--- a/src/driver/drv_local.h
+++ b/src/driver/drv_local.h
@@ -229,6 +229,8 @@ void DRV_DDPSend_Shutdown();
 void DRV_DDPSend_RunFrame();
 void DRV_DDPSend_AppendInformationToHTTPIndexPage(http_request_t* request);

+void TXW_Cam_Init(void);
+void TXW_Cam_RunEverySecond(void);

 #define SM2135_DELAY 4

--- a/src/driver/drv_main.c
+++ b/src/driver/drv_main.c
@@ -549,6 +549,13 @@ static driver_t g_drivers[] = {
 	//drvdetail:"requires":""}
 	{ "UartTCP",		UART_TCP_Init,		NULL,	NULL, NULL, UART_TCP_Deinit, NULL, NULL, false }
 #endif
+#if PLATFORM_TXW81X
+	//drvdetail:{"name":"TXW81X Camera",
+	//drvdetail:"title":"TODO",
+	//drvdetail:"descr":"TXW81X Camera.",
+	//drvdetail:"requires":""}
+	{ "TXWCAM", TXW_Cam_Init, TXW_Cam_RunEverySecond, NULL, NULL, NULL, NULL, NULL, false }
+#endif
 };


--- a/src/driver/drv_openWeatherMap.c
+++ b/src/driver/drv_openWeatherMap.c
@@ -14,6 +14,8 @@
 #include "lwip/inet.h"
 #include "../cJSON/cJSON.h"

+#if ENABLE_DRIVER_OPENWEATHERMAP
+
 #ifndef WINDOWS
 #include <lwip/err.h>
 #include <lwip/dns.h>
@@ -296,3 +298,4 @@ void DRV_OpenWeatherMap_Init() {

 }

+#endif
--- a/src/driver/drv_soft_i2c.c
+++ b/src/driver/drv_soft_i2c.c
@@ -10,7 +10,7 @@
 #include "../httpserver/new_http.h"
 #include "../hal/hal_pins.h"

-#if !PLATFORM_ESPIDF && !PLATFORM_XR806 && !PLATFORM_XR872 && !PLATFORM_ESP8266 && !PLATFORM_REALTEK_NEW
+#if !PLATFORM_ESPIDF && !PLATFORM_XR806 && !PLATFORM_XR872 && !PLATFORM_ESP8266 && !PLATFORM_REALTEK_NEW && !PLATFORM_TXW81X
 void usleep(int r) //delay function do 10*r nops, because rtos_delay_milliseconds is too much
 {
 #ifdef WIN32
--- a/src/driver/drv_txw81x_camera.c
+++ b/src/driver/drv_txw81x_camera.c
@@ -0,0 +1,110 @@
+#include "../new_common.h"
+#include "../new_pins.h"
+#include "../new_cfg.h"
+// Commands register, execution API and cmd tokenizer
+#include "../cmnds/cmd_public.h"
+#include "../cmnds/cmd_local.h"
+#include "../logging/logging.h"
+
+#if PLATFORM_TXW81X
+
+#include "sys_config.h"
+#include "typesdef.h"
+#include "osal/work.h"
+#include "lib/skb/skbpool.h"
+#include "lib/syscfg/syscfg.h"
+#include "syscfg.h"
+#include "lib/net/eloop/eloop.h"
+#include "lib/video/dvp/jpeg/jpg.h"
+#include "project_config.h"
+
+extern struct vpp_device* vpp_test;
+bool isStarted = false;
+bool showTimestamp = false;
+extern time_t g_ntpTime;
+extern void set_time_watermark(uint16 year, uint16 month, uint16 day, uint16 hour, uint16 min, uint16 sec);
+
+uint8 vcam_en()
+{
+	uint8 ret = TRUE;
+#if VCAM_EN
+	pmu_vcam_dis();
+	os_sleep_ms(1);
+	pmu_set_vcam_vol(VCAM_VOL_2V80);
+	pmu_vcam_lc_en();
+	pmu_vcam_oc_detect_dis();
+	pmu_vcam_oc_int_dis();
+	pmu_vcam_discharge_dis();
+	pmu_vcam_pg_dis();
+#ifdef VCAM_33
+	pmu_set_vcam_vol(VCAM_VOL_3V25);
+	pmu_vcam_en();
+	os_sleep_ms(1);
+	pmu_vcam_pg_en();
+#else
+	pmu_vcam_en();
+	os_sleep_ms(1);
+#endif    
+	//    sys_reset_pending_clr();
+	pmu_vcam_lc_dis();
+#ifndef VCAM_33
+	pmu_vcam_oc_detect_en();
+#endif
+	if(PMU_VCAM_OC_PENDING)
+	{
+		return FALSE;
+	}
+	pmu_vcam_oc_detect_dis();
+	pmu_vcam_oc_int_dis();
+	pmu_lvd_oe_en();
+#endif
+	return ret;
+}
+
+void CMD_ShowTimestamp(const void* context, const char* cmd, const char* args, int cmdFlags)
+{
+	Tokenizer_TokenizeString(args, 0);
+	showTimestamp = Tokenizer_GetArgInteger(0) > 0 ? 1 : 0;
+	vpp_set_watermark0_enable(vpp_test, showTimestamp);
+}
+
+void TXW_Cam_Init(void)
+{
+	if(!isStarted)
+	{
+		uint32_t buf_size = Tokenizer_GetArgIntegerDefault(1, 60 * 1000);
+		uint8 vcam;
+		vcam = vcam_en();
+		void* custom_buf = (void*)os_malloc(buf_size);
+		custom_mem_init(custom_buf, buf_size);
+		print_custom_sram();
+		stream_work_queue_start();
+		jpg_cfg(HG_JPG0_DEVID, VPP_DATA0);
+		bool csi_ret;
+		bool csi_cfg();
+		csi_ret = csi_cfg();
+		bool csi_open();
+		if(csi_ret)
+			csi_open();
+		audio_adc_init();
+		spook_init();
+	}
+	isStarted = true;
+
+	//cmddetail:{"name":"CAM_Show_Timestamp","args":"CMD_ShowTimestamp",
+	//cmddetail:"descr":"",
+	//cmddetail:"fn":"NULL);","file":"driver/drv_txw81x_camera.c","requires":"NTP",
+	//cmddetail:"examples":"CAM_Show_Timestamp 1"}
+	CMD_RegisterCommand("CAM_Show_Timestamp", CMD_ShowTimestamp, NULL);
+}
+
+void TXW_Cam_RunEverySecond(void)
+{
+	if(showTimestamp)
+	{
+		struct tm* ltm = gmtime(&g_ntpTime);
+		set_time_watermark(ltm->tm_year + 1900, ltm->tm_mon + 1, ltm->tm_mday, ltm->tm_hour, ltm->tm_min, ltm->tm_sec);
+	}
+}
+
+#endif
--- a/src/hal/generic/hal_ota_generic.c
+++ b/src/hal/generic/hal_ota_generic.c
@@ -0,0 +1,38 @@
+#include "../../obk_config.h"
+#include "../../new_common.h"
+#include "../../new_cfg.h"
+#include "../../logging/logging.h"
+#include "../../httpserver/new_http.h"
+#include "../hal_ota.h"
+
+int __attribute__((weak)) HAL_FlashRead(char*buffer, int readlen, int startaddr) {
+	int res;
+	res = 0;
+	return res;
+}
+
+int __attribute__((weak)) http_rest_post_flash(http_request_t* request, int startaddr, int maxaddr)
+{
+	int total = 0;
+	int towrite = request->bodylen;
+	char* writebuf = request->bodystart;
+	int writelen = request->bodylen;
+
+	ADDLOG_DEBUG(LOG_FEATURE_OTA, "OTA post len %d", request->contentLength);
+
+
+	int ret = 0;
+
+	if (request->contentLength > 0)
+	{
+		towrite = request->contentLength;
+	}
+	else
+	{
+		ret = -1;
+		ADDLOG_ERROR(LOG_FEATURE_OTA, "Content-length is 0");
+		goto update_ota_exit;
+	}
+update_ota_exit:
+	return 0;
+}
--- a/src/hal/generic/hal_pins_generic.c
+++ b/src/hal/generic/hal_pins_generic.c
@@ -2,7 +2,7 @@
 #include "../../logging/logging.h"
 #include "../../new_cfg.h"
 #include "../../new_pins.h"
-
+#include "../hal_pins.h"

 int __attribute__((weak)) PIN_GetPWMIndexForPinIndex(int pin)
 {
@@ -68,3 +68,12 @@ unsigned int __attribute__((weak)) HAL_GetGPIOPin(int index)
 {
 	return index;
 }
+
+void __attribute__((weak)) HAL_AttachInterrupt(int pinIndex, OBKInterruptType mode, OBKInterruptHandler function)
+{
+
+}
+void __attribute__((weak)) HAL_DetachInterrupt(int pinIndex)
+{
+
+}
--- a/src/hal/hal_wifi.h
+++ b/src/hal/hal_wifi.h
@@ -1,8 +1,12 @@
 #ifndef __HAL_WIFI_H__
 #define __HAL_WIFI_H__

+#ifndef MAC2STR
 #define MAC2STR(a) (a)[0], (a)[1], (a)[2], (a)[3], (a)[4], (a)[5]
+#endif
+#ifndef MACSTR
 #define MACSTR "%02x:%02x:%02x:%02x:%02x:%02x"
+#endif

 typedef enum HALWifiStatus {
 	WIFI_UNDEFINED,
--- a/src/hal/txw81x/hal_flashConfig_txw81x.c
+++ b/src/hal/txw81x/hal_flashConfig_txw81x.c
@@ -0,0 +1,29 @@
+#ifdef PLATFORM_TXW81X
+
+#include "../hal_flashConfig.h"
+#include <easyflash.h>
+
+static int g_easyFlash_Ready = 0;
+void InitEasyFlashIfNeeded()
+{
+	if(g_easyFlash_Ready == 0)
+	{
+		easyflash_init();
+		g_easyFlash_Ready = 1;
+	}
+}
+
+int HAL_Configuration_ReadConfigMemory(void* target, int dataLen)
+{
+	InitEasyFlashIfNeeded();
+	return ef_get_env_blob("ObkCfg", target, dataLen, NULL);
+}
+
+int HAL_Configuration_SaveConfigMemory(void* src, int dataLen)
+{
+	InitEasyFlashIfNeeded();
+	ef_set_env_blob("ObkCfg", src, dataLen);
+	return 1;
+}
+
+#endif // PLATFORM_TXW81X
--- a/src/hal/txw81x/hal_flashVars_txw81x.c
+++ b/src/hal/txw81x/hal_flashVars_txw81x.c
@@ -0,0 +1,182 @@
+#ifdef PLATFORM_TXW81X
+
+#include "../../new_common.h"
+#include "../hal_flashVars.h"
+#include "../../logging/logging.h"
+#include <easyflash.h>
+
+FLASH_VARS_STRUCTURE flash_vars;
+static int g_loaded = 0;
+
+#define KV_KEY_FLASH_VARS "OBK_FV"
+#define SAVE_CHANGE_IF_REQUIRED_AND_COUNT(target, source, counter) \
+	if((target) != (source)) { \
+		(target) = (source); \
+		counter++; \
+	}
+
+extern void InitEasyFlashIfNeeded();
+
+static int ReadFlashVars(void* target, int dataLen)
+{
+	InitEasyFlashIfNeeded();
+	int readLen;
+	ADDLOG_DEBUG(LOG_FEATURE_CFG, "ReadFlashVars: will read %d bytes", dataLen);
+	readLen = ef_get_env_blob(KV_KEY_FLASH_VARS, target, dataLen, NULL);
+	ADDLOG_DEBUG(LOG_FEATURE_CFG, "ReadFlashVars: really loaded %d bytes", 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, "SaveFlashVars: EF_ENV_INIT_FAILED for %d bytes", dataLen);
+		return 0;
+	}
+	if(res == EF_ENV_NAME_ERR)
+	{
+		ADDLOG_DEBUG(LOG_FEATURE_CFG, "SaveFlashVars: EF_ENV_ARG_ERR for %d bytes", dataLen);
+		return 0;
+	}
+	ADDLOG_DEBUG(LOG_FEATURE_CFG, "SaveFlashVars: saved %d bytes", dataLen);
+	return dataLen;
+}
+
+// call at startup
+void HAL_FlashVars_IncreaseBootCount()
+{
+	memset(&flash_vars, 0, sizeof(flash_vars));
+	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));
+	}
+
+	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);
+	SAVE_CHANGE_IF_REQUIRED_AND_COUNT(flash_vars.savedValues[MAX_RETAIN_CHANNELS - 4], bEnableAll, iChangesCount);
+	SAVE_CHANGE_IF_REQUIRED_AND_COUNT(flash_vars.rgb[0], r, iChangesCount);
+	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 #######");
+		SaveFlashVars(&flash_vars, sizeof(flash_vars));
+	}
+}
+
+short HAL_FlashVars_ReadUsage()
+{
+	return 0;
+}
+
+void HAL_FlashVars_SaveTotalUsage(short usage)
+{
+
+}
+
+// call once started (>30s?)
+void HAL_FlashVars_SaveBootComplete()
+{
+	flash_vars.boot_success_count = flash_vars.boot_count;
+	SaveFlashVars(&flash_vars, sizeof(flash_vars));
+}
+
+// call to return the number of boots since a HAL_FlashVars_SaveBootComplete
+int HAL_FlashVars_GetBootFailures()
+{
+	int diff = 0;
+	diff = flash_vars.boot_count - flash_vars.boot_success_count;
+	return diff;
+}
+
+int HAL_FlashVars_GetBootCount()
+{
+	return flash_vars.boot_count;
+}
+
+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)
+{
+	if(data != NULL)
+	{
+		if(g_loaded == 0)
+		{
+			ReadFlashVars(&flash_vars, sizeof(flash_vars));
+		}
+		memcpy(data, &flash_vars.emetering, sizeof(ENERGY_METERING_DATA));
+	}
+	return 0;
+}
+
+int HAL_SetEnergyMeterStatus(ENERGY_METERING_DATA* data)
+{
+	if(data != NULL)
+	{
+		memcpy(&flash_vars.emetering, data, sizeof(ENERGY_METERING_DATA));
+		SaveFlashVars(&flash_vars, sizeof(flash_vars));
+	}
+	return 0;
+}
+
+void HAL_FlashVars_SaveTotalConsumption(float total_consumption)
+{
+	flash_vars.emetering.TotalConsumption = total_consumption;
+}
+
+#endif // PLATFORM_TXW81X
+
--- a/src/hal/txw81x/hal_generic_txw81x.c
+++ b/src/hal/txw81x/hal_generic_txw81x.c
@@ -0,0 +1,49 @@
+#if PLATFORM_TXW81X
+
+#include "../hal_generic.h"
+#include "chip/txw81x/sysctrl.h"
+extern struct spi_nor_flash* obk_flash;
+
+void HAL_RebootModule()
+{
+	mcu_reset();
+}
+
+void HAL_Delay_us(int delay)
+{
+	delay_us(delay);
+}
+
+void HAL_Configure_WDT()
+{
+	mcu_watchdog_timeout(10);
+	mcu_watchdog_irq_request(HAL_RebootModule);
+}
+
+void HAL_Run_WDT()
+{
+	mcu_watchdog_feed();
+}
+
+int HAL_FlashRead(char* buffer, int readlen, int startaddr)
+{
+	int res = 1;
+	spi_nor_read(obk_flash, startaddr, buffer, readlen);
+	return res;
+}
+
+int HAL_FlashWrite(char* buffer, int writelen, int startaddr)
+{
+	int res = 1;
+	spi_nor_write(obk_flash, startaddr, buffer, writelen);
+	return res;
+}
+
+int HAL_FlashEraseSector(int startaddr)
+{
+	int res = 1;
+	spi_nor_sector_erase(obk_flash, startaddr);
+	return res;
+}
+
+#endif // PLATFORM_TXW81X
--- a/src/hal/txw81x/hal_main_txw81x.c
+++ b/src/hal/txw81x/hal_main_txw81x.c
@@ -0,0 +1,63 @@
+#if PLATFORM_TXW81X
+
+#include "../../new_common.h"
+#include "../../logging/logging.h"
+#include "../../quicktick.h"
+#include "sys_config.h"
+#include "typesdef.h"
+#include "osal/work.h"
+#include "lib/skb/skbpool.h"
+#include "lib/syscfg/syscfg.h"
+#include "syscfg.h"
+#include "lib/net/eloop/eloop.h"
+#include "lib/video/dvp/jpeg/jpg.h"
+#include "project_config.h"
+
+static struct os_work main_wk;
+extern void TXW_TakeEvents();
+uint8_t qc_mode = 0;
+struct spi_nor_flash* obk_flash = NULL;
+
+static int32 main_loop(struct os_work* work)
+{
+	os_run_work_delay(&main_wk, 1000);
+	Main_OnEverySecond();
+	return 0;
+}
+
+int main(void)
+{
+	uint32 sysheap_freesize(struct sys_heap* heap);
+	os_printf("freemem:%d\r\n", sysheap_freesize(&sram_heap));
+	void* skb_pool_addr = (void*)os_malloc(10 * 1024);
+	if(!skb_pool_addr)
+	{
+		while(1)
+		{
+			os_printf("skb malloc fail,malloc size:%d\tremain size:%d\n", 10 * 1024, sysheap_freesize(&sram_heap));
+			os_sleep_ms(1000);
+		}
+	}
+	skbpool_init((uint32_t)skb_pool_addr, 10 * 1024, 80, 0);
+	syscfg_set_default_val();
+
+	ip_addr_t ipaddr, netmask, gw;
+	struct netdev* ndev;
+	int offset = sys_cfgs.wifi_mode == WIFI_MODE_STA ? WIFI_MODE_STA : WIFI_MODE_AP;
+	tcpip_init(NULL, NULL);
+
+	struct syscfg_info info;
+	os_memset(&info, 0, sizeof(info));
+	syscfg_info_get(&info);
+	obk_flash = info.flash1;
+	spi_nor_open(obk_flash);
+
+	TXW_TakeEvents();
+	eloop_init();
+	os_task_create("eloop_run", user_eloop_run, NULL, OS_TASK_PRIORITY_NORMAL, 0, NULL, 2048);
+	Main_Init();
+	OS_WORK_INIT(&main_wk, main_loop, 0);
+	os_run_work_delay(&main_wk, 1000);
+}
+
+#endif
--- a/src/hal/txw81x/hal_ota_txw81x.c
+++ b/src/hal/txw81x/hal_ota_txw81x.c
@@ -0,0 +1,97 @@
+#if PLATFORM_TXW81X
+
+#include "../../obk_config.h"
+#include "../../new_common.h"
+#include "../../new_cfg.h"
+#include "../../logging/logging.h"
+#include "../../httpserver/new_http.h"
+#include "../hal_ota.h"
+#include "lib/ota/fw.h"
+
+typedef struct tcpNetUpgradeInfo
+{
+	char version[16];
+	int fileSize;
+}NetUpgrade_Info;
+
+int http_rest_post_flash(http_request_t* request, int startaddr, int maxaddr)
+{
+	int total = 0;
+	int towrite = request->bodylen;
+	char* writebuf = request->bodystart;
+	int writelen = request->bodylen;
+
+	ADDLOG_DEBUG(LOG_FEATURE_OTA, "OTA post len %d", request->contentLength);
+
+	int ret = 0;
+	int res = 0;
+
+	if (request->contentLength > 0)
+	{
+		towrite = request->contentLength;
+	}
+	else
+	{
+		ret = -1;
+		ADDLOG_ERROR(LOG_FEATURE_OTA, "Content-length is 0");
+		goto update_ota_exit;
+	}
+
+	writebuf = request->received;
+
+	for(int i = 0; i < writelen; i++)
+	{
+		if(writebuf[i] == 0x69 && writebuf[i + 1] == 0x5a && writebuf[i + 2] == 0x00 && writebuf[i + 3] == 0x1c)
+		{
+			writelen -= i;
+			towrite -= i;
+			writebuf = &writebuf[i];
+			break;
+		}
+	}
+	do
+	{
+		int res = libota_write_fw(request->contentLength, startaddr, writebuf, writelen);
+		if(res != -1)
+		{
+			ADDLOG_ERROR(LOG_FEATURE_OTA, "libota_write_fw,res:%d\n", res);
+			ret = -1;
+			goto update_ota_exit;
+		}
+		rtos_delay_milliseconds(10);
+		ADDLOG_INFO(LOG_FEATURE_OTA, "Writelen %i at %i, res %i", writelen, total, res);
+		total += writelen;
+		startaddr += writelen;
+		towrite -= writelen;
+		if(towrite > 0)
+		{
+			writebuf = request->received;
+			writelen = recv(request->fd, writebuf, 1464, 0);
+			if(writelen < 0)
+			{
+				ADDLOG_ERROR(LOG_FEATURE_OTA, "recv returned %d - end of data - remaining %d", writelen, towrite);
+				ret = -1;
+			}
+		}
+	} while((towrite > 0) && (writelen >= 0));
+
+update_ota_exit:
+	if(ret != -1)
+	{
+		ADDLOG_INFO(LOG_FEATURE_OTA, "OTA is successful");
+	}
+	else
+	{
+		ADDLOG_ERROR(LOG_FEATURE_OTA, "OTA failed");
+		return http_rest_error(request, ret, "error");
+	}
+
+	ADDLOG_DEBUG(LOG_FEATURE_OTA, "%d total bytes written", total);
+	http_setup(request, httpMimeTypeJson);
+	hprintf255(request, "{\"size\":%d}", total);
+	poststr(request, NULL);
+	CFG_IncrementOTACount();
+	return 0;
+}
+
+#endif
--- a/src/hal/txw81x/hal_pinmap_txw81x.h
+++ b/src/hal/txw81x/hal_pinmap_txw81x.h
@@ -0,0 +1,26 @@
+#if PLATFORM_TXW81X
+
+#include "txw81x/txw81x.h"
+#include "txw81x/pin_names.h"
+#include "txw81x/io_mask.h"
+#include "txw81x/io_function.h"
+#include "txw81x/adc_voltage_type.h"
+#include "hal/gpio.h"
+
+#include "../../new_common.h"
+#include "../../logging/logging.h"
+#include "../../new_cfg.h"
+#include "../../new_pins.h"
+#include "../hal_pins.h"
+
+typedef struct
+{
+	const char* name;
+	enum pin_name pin;
+	enum gpio_irq_event irq_mode;
+} txwpin_t;
+
+extern txwpin_t g_pins[];
+extern int g_numPins;
+
+#endif // PLATFORM_TXW81X
--- a/src/hal/txw81x/hal_pins_txw81x.c
+++ b/src/hal/txw81x/hal_pins_txw81x.c
@@ -0,0 +1,181 @@
+#if PLATFORM_TXW81X
+
+#include "../../new_common.h"
+#include "../../logging/logging.h"
+
+#include "hal_pinmap_txw81x.h"
+
+txwpin_t g_pins[] = {
+	{ "PA00",	PA_0, GPIO_IRQ_EVENT_NONE },
+	{ "PA01",	PA_1, GPIO_IRQ_EVENT_NONE },
+	{ "PA02",	PA_2, GPIO_IRQ_EVENT_NONE },
+	{ "PA03",	PA_3, GPIO_IRQ_EVENT_NONE },
+	{ "PA04",	PA_4, GPIO_IRQ_EVENT_NONE },
+	{ "PA05",	PA_5, GPIO_IRQ_EVENT_NONE },
+	{ "PA06",	PA_6, GPIO_IRQ_EVENT_NONE },
+	{ "PA07",	PA_7, GPIO_IRQ_EVENT_NONE },
+	{ "PA08",	PA_8, GPIO_IRQ_EVENT_NONE },
+	{ "PA09",	PA_9, GPIO_IRQ_EVENT_NONE },
+	{ "PA10",	PA_10, GPIO_IRQ_EVENT_NONE },
+	{ "PA11",	PA_11, GPIO_IRQ_EVENT_NONE },
+	{ "PA12",	PA_12, GPIO_IRQ_EVENT_NONE },
+	{ "PA13",	PA_13, GPIO_IRQ_EVENT_NONE },
+	{ "PA14",	PA_14, GPIO_IRQ_EVENT_NONE },
+	{ "PA15",	PA_15, GPIO_IRQ_EVENT_NONE },
+	{ "PB00",	PB_0, GPIO_IRQ_EVENT_NONE },
+	{ "PB01",	PB_1, GPIO_IRQ_EVENT_NONE },
+	{ "PB02",	PB_2, GPIO_IRQ_EVENT_NONE },
+	{ "PB03",	PB_3, GPIO_IRQ_EVENT_NONE },
+	{ "PB04",	PB_4, GPIO_IRQ_EVENT_NONE },
+	{ "PB05",	PB_5, GPIO_IRQ_EVENT_NONE },
+	{ "PB06",	PB_6, GPIO_IRQ_EVENT_NONE },
+	{ "PB07",	PB_7, GPIO_IRQ_EVENT_NONE },
+	{ "PB08",	PB_8, GPIO_IRQ_EVENT_NONE },
+	{ "PB09",	PB_9, GPIO_IRQ_EVENT_NONE },
+	{ "PB10",	PB_10, GPIO_IRQ_EVENT_NONE },
+	{ "PB11",	PB_11, GPIO_IRQ_EVENT_NONE },
+	{ "PB12",	PB_12, GPIO_IRQ_EVENT_NONE },
+	{ "PB13",	PB_13, GPIO_IRQ_EVENT_NONE },
+	{ "PB14",	PB_14, GPIO_IRQ_EVENT_NONE },
+	{ "PB15",	PB_15, GPIO_IRQ_EVENT_NONE },
+	{ "PC00",	PC_0, GPIO_IRQ_EVENT_NONE },
+	{ "PC01",	PC_1, GPIO_IRQ_EVENT_NONE },
+	{ "PC02",	PC_2, GPIO_IRQ_EVENT_NONE },
+	{ "PC03",	PC_3, GPIO_IRQ_EVENT_NONE },
+	{ "PC04",	PC_4, GPIO_IRQ_EVENT_NONE },
+	{ "PC05",	PC_5, GPIO_IRQ_EVENT_NONE },
+	{ "PC06",	PC_6, GPIO_IRQ_EVENT_NONE },
+	{ "PC07",	PC_7, GPIO_IRQ_EVENT_NONE },
+	{ "PC08",	PC_8, GPIO_IRQ_EVENT_NONE },
+	{ "PC09",	PC_9, GPIO_IRQ_EVENT_NONE },
+	{ "PC10",	PC_10, GPIO_IRQ_EVENT_NONE },
+	{ "PC11",	PC_11, GPIO_IRQ_EVENT_NONE },
+	{ "PC12",	PC_12, GPIO_IRQ_EVENT_NONE },
+	{ "PC13",	PC_13, GPIO_IRQ_EVENT_NONE },
+	{ "PC14",	PC_14, GPIO_IRQ_EVENT_NONE },
+	{ "PC15",	PC_15, GPIO_IRQ_EVENT_NONE },
+	{ "PE00",	PE_0, GPIO_IRQ_EVENT_NONE },
+	{ "PE01",	PE_1, GPIO_IRQ_EVENT_NONE },
+	{ "PE02",	PE_2, GPIO_IRQ_EVENT_NONE },
+	{ "PE03",	PE_3, GPIO_IRQ_EVENT_NONE },
+	{ "PE04",	PE_4, GPIO_IRQ_EVENT_NONE },
+	{ "PE05",	PE_5, GPIO_IRQ_EVENT_NONE },
+	{ "PE06",	PE_6, GPIO_IRQ_EVENT_NONE },
+	{ "PE07",	PE_7, GPIO_IRQ_EVENT_NONE },
+	{ "PE08",	PE_8, GPIO_IRQ_EVENT_NONE },
+	{ "PE09",	PE_9, GPIO_IRQ_EVENT_NONE },
+	{ "PE10",	PE_10, GPIO_IRQ_EVENT_NONE },
+	{ "PE11",	PE_11, GPIO_IRQ_EVENT_NONE },
+	{ "PE12",	PE_12, GPIO_IRQ_EVENT_NONE },
+	{ "PE13",	PE_13, GPIO_IRQ_EVENT_NONE },
+	{ "PE14",	PE_14, GPIO_IRQ_EVENT_NONE },
+	{ "PE15",	PE_15, GPIO_IRQ_EVENT_NONE },
+};
+
+int g_numPins = sizeof(g_pins) / sizeof(g_pins[0]);
+
+const char* HAL_PIN_GetPinNameAlias(int index)
+{
+	if(index >= g_numPins)
+		return "error";
+	return g_pins[index].name;
+}
+
+void HAL_PIN_SetOutputValue(int index, int iVal)
+{
+	if(index >= g_numPins)
+		return;
+	txwpin_t* pin = g_pins + index;
+	gpio_set_val(pin->pin, iVal ? 1 : 0);
+}
+
+int HAL_PIN_ReadDigitalInput(int index)
+{
+	if(index >= g_numPins)
+		return 0;
+	txwpin_t* pin = g_pins + index;
+	return gpio_get_val(pin->pin);
+}
+
+void HAL_PIN_Setup_Input_Pullup(int index)
+{
+	if(index >= g_numPins)
+		return;
+	txwpin_t* pin = g_pins + index;
+	gpio_set_dir(pin->pin, GPIO_DIR_INPUT);
+	gpio_set_mode(pin->pin, GPIO_PULL_UP, GPIO_PULL_LEVEL_4_7K);
+	gpio_iomap_input(pin->pin, GPIO_IOMAP_INPUT);
+}
+
+void HAL_PIN_Setup_Input_Pulldown(int index)
+{
+	if(index >= g_numPins)
+		return;
+	txwpin_t* pin = g_pins + index;
+	gpio_set_dir(pin->pin, GPIO_DIR_INPUT);
+	gpio_set_mode(pin->pin, GPIO_PULL_DOWN, GPIO_PULL_LEVEL_4_7K);
+	gpio_iomap_input(pin->pin, GPIO_IOMAP_INPUT);
+}
+
+void HAL_PIN_Setup_Input(int index)
+{
+	if(index >= g_numPins)
+		return;
+	txwpin_t* pin = g_pins + index;
+	gpio_set_dir(pin->pin, GPIO_DIR_INPUT);
+	gpio_set_mode(pin->pin, GPIO_PULL_NONE, GPIO_PULL_LEVEL_NONE);
+	gpio_iomap_input(pin->pin, GPIO_IOMAP_INPUT);
+}
+
+void HAL_PIN_Setup_Output(int index)
+{
+	if(index >= g_numPins)
+		return;
+	txwpin_t* pin = g_pins + index;
+	gpio_set_dir(pin->pin, GPIO_DIR_OUTPUT);
+	gpio_set_mode(pin->pin, GPIO_PULL_UP, GPIO_PULL_LEVEL_4_7K);
+	gpio_iomap_output(pin->pin, GPIO_IOMAP_OUTPUT);
+}
+
+OBKInterruptHandler g_handlers[PLATFORM_GPIO_MAX];
+OBKInterruptType g_modes[PLATFORM_GPIO_MAX];
+
+void TXW_Interrupt(int32 data, enum gpio_irq_event event)
+{
+	if(g_handlers[data])
+	{
+		g_handlers[data](data);
+	}
+}
+
+void HAL_AttachInterrupt(int index, OBKInterruptType mode, OBKInterruptHandler function)
+{
+	txwpin_t* pin = g_pins + index;
+	if(index >= g_numPins || pin->irq_mode != GPIO_IRQ_EVENT_NONE)
+		return;
+	g_handlers[index] = function;
+
+	enum gpio_irq_event txw_mode;
+	switch(mode)
+	{
+		case INTERRUPT_RISING: txw_mode = GPIO_IRQ_EVENT_RISE; break;
+		case INTERRUPT_FALLING: txw_mode = GPIO_IRQ_EVENT_FALL; break;
+		case INTERRUPT_CHANGE: txw_mode = GPIO_IRQ_EVENT_ALL; break;
+		default: txw_mode = GPIO_IRQ_EVENT_FALL; break;
+	}
+	gpio_request_pin_irq(pin->pin, TXW_Interrupt, pin->pin, txw_mode);
+
+}
+void HAL_DetachInterrupt(int index)
+{
+	if(g_handlers[index] == 0)
+	{
+		return; // already removed;
+	}
+	txwpin_t* pin = g_pins + index;
+	gpio_release_pin_irq(pin->pin, pin->irq_mode);
+	pin->irq_mode = GPIO_IRQ_EVENT_NONE;
+	g_handlers[index] = 0;
+}
+
+#endif
--- a/src/hal/txw81x/hal_wifi_txw81x.c
+++ b/src/hal/txw81x/hal_wifi_txw81x.c
@@ -0,0 +1,484 @@
+#ifdef PLATFORM_TXW81X
+
+#include "../hal_wifi.h"
+#include "../../new_common.h"
+#include "../../logging/logging.h"
+#include "sys_config.h"
+#include "typesdef.h"
+#include "lib/common/common.h"
+#include "lib/common/sysevt.h"
+#include "lib/syscfg/syscfg.h"
+#include "syscfg.h"
+#include "lib/lmac/lmac.h"
+#include "netif/ethernetif.h"
+#include "lib/net/eloop/eloop.h"
+#include "lib/net/dhcpd/dhcpd.h"
+
+static void (*g_wifiStatusCallback)(int code) = NULL;
+static int g_bOpenAccessPointMode = 0;
+struct system_status sys_status;
+extern u8_t netif_num;
+
+const char* HAL_GetMyIPString()
+{
+	ip_addr_t ip = lwip_netif_get_ip2("w0");
+	return ip4addr_ntoa(&ip);
+}
+
+const char* HAL_GetMyGatewayString()
+{
+	ip_addr_t gw = lwip_netif_get_gw2("w0");
+	return ip4addr_ntoa(&gw);
+}
+
+const char* HAL_GetMyDNSString()
+{
+	return "error";
+}
+
+const char* HAL_GetMyMaskString()
+{
+	ip_addr_t mask = lwip_netif_get_netmask2("w0");
+	return ip4addr_ntoa(&mask);
+}
+
+void WiFI_GetMacAddress(char* mac)
+{
+	memcpy(mac, (char*)sys_cfgs.mac, sizeof(sys_cfgs.mac));
+}
+
+const char* HAL_GetMACStr(char* macstr)
+{
+	unsigned char mac[6];
+	WiFI_GetMacAddress((char*)mac);
+	sprintf(macstr, MACSTR, MAC2STR(mac));
+	return macstr;
+}
+
+void HAL_PrintNetworkInfo()
+{
+	uint8_t mac[6];
+	WiFI_GetMacAddress((char*)mac);
+	ADDLOG_DEBUG(LOG_FEATURE_GENERAL, "+--------------- net device info ------------+\r\n");
+	ADDLOG_DEBUG(LOG_FEATURE_GENERAL, "|netif type    : %-16s            |\r\n", g_bOpenAccessPointMode == 0 ? "STA" : "AP");
+	ADDLOG_DEBUG(LOG_FEATURE_GENERAL, "|netif rssi    = %-16i            |\r\n", HAL_GetWifiStrength());
+	ADDLOG_DEBUG(LOG_FEATURE_GENERAL, "|netif ip      = %-16s            |\r\n", HAL_GetMyIPString());
+	ADDLOG_DEBUG(LOG_FEATURE_GENERAL, "|netif mask    = %-16s            |\r\n", HAL_GetMyMaskString());
+	ADDLOG_DEBUG(LOG_FEATURE_GENERAL, "|netif gateway = %-16s            |\r\n", HAL_GetMyGatewayString());
+	ADDLOG_DEBUG(LOG_FEATURE_GENERAL, "|netif mac     : ["MACSTR"] %-6s  |\r\n", MAC2STR(mac), "");
+	ADDLOG_DEBUG(LOG_FEATURE_GENERAL, "+--------------------------------------------+\r\n");
+}
+
+int HAL_GetWifiStrength()
+{
+	struct ieee80211_stainfo stainfo;
+	if(!g_bOpenAccessPointMode) ieee80211_conf_get_stainfo(WIFI_MODE_STA, 0, NULL, &stainfo);
+	return stainfo.rssi;
+}
+
+sysevt_hdl_res sysevt_wifi_event(uint32 event_id, uint32 data, uint32 priv)
+{
+	uint8 mac[6];
+	switch(event_id & 0xffff)
+	{
+		case SYSEVT_WIFI_CONNECT_START:
+			if(g_wifiStatusCallback != NULL)
+			{
+				g_wifiStatusCallback(WIFI_STA_CONNECTING);
+			}
+			break;
+		case SYSEVT_WIFI_WRONG_KEY:
+			if(g_wifiStatusCallback != NULL)
+			{
+				g_wifiStatusCallback(WIFI_STA_AUTH_FAILED);
+			}
+			break;
+		case SYSEVT_WIFI_UNPAIR:
+		case SYSEVT_WIFI_STA_DISCONNECT:
+		case SYSEVT_WIFI_DISCONNECT:
+			if(g_wifiStatusCallback != NULL)
+			{
+				g_wifiStatusCallback(WIFI_STA_DISCONNECTED);
+			}
+			break;
+		case SYSEVT_WIFI_CONNECTTED:
+			if(sys_cfgs.wifi_mode == WIFI_MODE_STA)
+			{
+				if(sys_cfgs.dhcpc_en)
+				{//dynamic ip, 
+					lwip_netif_set_dhcp2("w0", 1);
+				}
+				else
+				{ //static ip
+					ip_addr_t addr;
+					addr.addr = 0x0101A8C0 + ((data & 0xff) << 24);
+					lwip_netif_set_ip2("w0", &addr, NULL, NULL);
+					os_printf("w0_ip= %x\r\n", lwip_netif_get_ip2("w0"));
+				}
+			}
+			if(g_wifiStatusCallback != NULL)
+			{
+				g_wifiStatusCallback(WIFI_STA_CONNECTED);
+			}
+			break;
+		case SYSEVT_WIFI_STA_CONNECTTED:
+		case SYSEVT_WIFI_STA_PS_START:
+		case SYSEVT_WIFI_STA_PS_END:
+		case SYSEVT_WIFI_SCAN_DONE:
+			break;
+		case SYSEVT_WIFI_PAIR_DONE:
+			if(sys_status.pair_success)
+			{
+				ieee80211_conf_get_ssid(sys_cfgs.wifi_mode, sys_cfgs.ssid);
+				ieee80211_conf_get_psk(sys_cfgs.wifi_mode, sys_cfgs.psk);
+				sys_cfgs.key_mgmt = ieee80211_conf_get_keymgmt(sys_cfgs.wifi_mode);
+
+				if((int32)data == 1 && sys_cfgs.wifi_mode == WIFI_MODE_STA)
+				{
+					os_printf(KERN_NOTICE"wifi pair done, ngo role AP!\r\n");
+					sys_cfgs.wifi_mode = WIFI_MODE_AP;
+					ieee80211_iface_stop(WIFI_MODE_STA);
+					wificfg_flush(WIFI_MODE_AP);
+					ieee80211_iface_start(WIFI_MODE_AP);
+				}
+
+				if((int32)data == -1 && sys_cfgs.wifi_mode == WIFI_MODE_AP)
+				{
+					os_printf(KERN_NOTICE"wifi pair done, ngo role STA!\r\n");
+					sys_cfgs.wifi_mode = WIFI_MODE_STA;
+					ieee80211_iface_stop(WIFI_MODE_AP);
+					wificfg_flush(WIFI_MODE_STA);
+					ieee80211_iface_start(WIFI_MODE_STA);
+				}
+			}
+			break;
+		default:
+			os_printf("no this event(%x)...\r\n", event_id);
+			break;
+	}
+	return SYSEVT_CONTINUE;
+}
+
+sysevt_hdl_res sysevt_network_event(uint32 event_id, uint32 data, uint32 priv)
+{
+	struct netif* nif;
+
+	switch(event_id)
+	{
+		case SYS_EVENT(SYS_EVENT_NETWORK, SYSEVT_LWIP_DHCPC_DONE):
+			nif = netif_find("w0");
+			sys_status.dhcpc_done = 1;
+#ifdef CONFIG_SLEEP
+			err_t etharp_set_static(ip4_addr_t * ipaddr);
+			err_t etharp_request(struct netif* netif, const ip4_addr_t * ipaddr);
+
+			if(etharp_set_static(&nif->gw))
+			{
+				etharp_request(nif, &nif->gw);
+			}
+#endif
+			if(g_wifiStatusCallback != NULL)
+			{
+				g_wifiStatusCallback(WIFI_STA_CONNECTED);
+			}
+			break;
+	}
+	return SYSEVT_CONTINUE;
+}
+
+int32 sys_wifi_event(uint8 ifidx, uint16 evt, uint32 param1, uint32 param2)
+{
+	switch(evt)
+	{
+		case IEEE80211_EVENT_PAIR_SUCCESS:
+			sys_status.pair_success = 1;
+			if(WIFI_MODE_STA == ifidx)
+			{
+				sys_cfgs.net_pair_switch = 0;
+				ieee80211_pairing(sys_cfgs.wifi_mode, sys_cfgs.net_pair_switch);
+				sys_event_new(SYS_EVENT(SYS_EVENT_WIFI, SYSEVT_WIFI_PAIR_DONE), 1);
+			}
+			break;
+		case IEEE80211_EVENT_PAIR_DONE:
+			os_printf("inteface%d pair done, bssid: "MACSTR"\r\n", ifidx, MAC2STR((uint8*)param1));
+			sys_event_new(SYS_EVENT(SYS_EVENT_WIFI, SYSEVT_WIFI_PAIR_DONE), param2);
+			break;
+		default:
+			break;
+	}
+	return RET_OK;
+}
+__init static void sys_wifi_parameter_init(void* ops)
+{
+	lmac_set_rf_pwr_level(ops, WIFI_RF_PWR_LEVEL);
+#if WIFI_FEM_CHIP != LMAC_FEM_NONE
+	lmac_set_fem(ops, WIFI_FEM_CHIP);   //初始化FEM之后，不能进行RF档位选择！
+#endif
+#if WIFI_MODULE_80211W_EN
+	lmac_bgn_module_80211w_init(ops);
+#endif
+	lmac_set_rts(ops, WIFI_RTS_THRESHOLD);
+	lmac_set_retry_cnt(ops, WIFI_TX_MAX_RETRY, WIFI_RTS_MAX_RETRY);
+	lmac_set_txpower(ops, WIFI_TX_MAX_POWER);
+	lmac_set_supp_rate(ops, WIFI_TX_SUPP_RATE);
+	lmac_set_max_sta_cnt(ops, WIFI_MAX_STA_CNT);
+	lmac_set_mcast_dup_txcnt(ops, WIFI_MULICAST_RETRY);
+	lmac_set_max_ps_frame(ops, WIFI_MAX_PS_CNT);
+	lmac_set_tx_duty_cycle(ops, WIFI_TX_DUTY_CYCLE);
+#if WIFI_SSID_FILTER_EN
+	lmac_set_ssid_filter(ops, sys_cfgs.ssid, strlen(sys_cfgs.ssid));
+#endif
+#if WIFI_PREVENT_PS_MODE_EN
+	lmac_set_prevent_ps_mode(ops, WIFI_PREVENT_PS_MODE_EN);
+#endif
+#ifdef LMAC_BGN_PCF
+	lmac_set_prevent_ps_mode(ops, 0);//bbm允许sta休眠
+#endif
+
+#ifdef RATE_CONTROL_SELECT
+	//lmac_rate_ctrl_mcs_mask(ops, 0);
+	lmac_rate_ctrl_type(ops, RATE_CONTROL_SELECT);
+#endif
+	//使用小电流时，就不使用增大发射功率的功率表
+#if (WIFI_RF_PWR_LEVEL != 1) && (WIFI_RF_PWR_LEVEL != 2)
+#if (WIFI_FEM_CHIP == LMAC_FEM_GSR2701) || (WIFI_FEM_CHIP == LMAC_FEM_KCT8227D) || (WIFI_FEM_CHIP == LMAC_FEM_GSR2701_5V)
+	uint8 gain_table[] = {
+		96, 96, 96, 96, 88, 88, 64, 64,         // NON HT OFDM
+		96, 96, 96, 88, 88, 64, 64, 64,         // HT
+		64, 64, 64, 64,                         // DSSS
+	};
+#else
+	uint8 gain_table[] = {
+		125, 125, 105, 100, 85, 85, 64, 64,     // NON HT OFDM
+		125, 105, 105, 85,  85, 64, 64, 64,     // HT
+		80,  80,  80,  80,                      // DSSS
+	};
+#endif
+	lmac_set_tx_modulation_gain(ops, gain_table, sizeof(gain_table));
+#endif
+	lmac_set_temperature_compesate_en(ops, WIFI_TEMPERATURE_COMPESATE_EN);
+	lmac_set_freq_offset_track_mode(ops, WIFI_FREQ_OFFSET_TRACK_MODE);
+
+#if WIFI_HIGH_PRIORITY_TX_MODE_EN
+	struct lmac_txq_param txq_max;
+	struct lmac_txq_param txq_min;
+
+	txq_max.aifs = 0xFF;                  //不限制aifs
+	txq_max.txop = 0xFFFF;                //不限制txop
+	txq_max.cw_min = 1;                     //cwmin最大值。如果觉得冲突太厉害，可以改成3
+	txq_max.cw_max = 3;                     //cwmax最大值。如果觉得冲突太厉害，可以改成7
+	lmac_set_edca_max(ops, &txq_max);
+	lmac_set_tx_edca_slot_time(ops, 6);     //6us是其他客户推荐的值
+	lmac_set_nav_max(ops, 0);               //完全关闭NAV功能
+
+	txq_min.aifs = 0;
+	txq_min.txop = 100;                   //txop最小值限制为100
+	txq_min.cw_min = 0;
+	txq_min.cw_max = 0;
+	lmac_set_edca_min(ops, &txq_min);
+#endif
+}
+
+void HAL_WiFi_SetupStatusCallback(void (*cb)(int code))
+{
+	g_wifiStatusCallback = cb;
+}
+
+void TXW_TakeEvents()
+{
+	sys_event_init(32);
+	sys_event_take(SYS_EVENT(SYS_EVENT_WIFI, 0), sysevt_wifi_event, 0);
+	sys_event_take(SYS_EVENT(SYS_EVENT_NETWORK, 0), sysevt_network_event, 0);
+}
+
+void HAL_ConnectToWiFi(const char* oob_ssid, const char* connect_key, obkStaticIP_t* ip)
+{
+	int32 ret;
+	os_sprintf(sys_cfgs.ssid, "%s", oob_ssid);
+	os_sprintf(sys_cfgs.passwd, "%s", connect_key);
+	void* ops;
+	struct lmac_init_param lparam;
+
+#if DCDC_EN
+	pmu_dcdc_open();
+#endif
+	void* rxbuf = (void*)os_malloc(16 * 1024);
+	lparam.rxbuf = (uint32_t)rxbuf;
+	lparam.rxbuf_size = 16 * 1024;
+	ops = lmac_bgn_init(&lparam);
+#ifdef CONFIG_SLEEP
+	void* bgn_dsleep_init(void* ops);
+	bgn_dsleep_init(ops);
+#endif
+
+#ifdef LMAC_BGN_PCF
+	lmac_set_bbm_mode_init(ops, 1); //init before ieee80211_support_txw80x
+#endif
+
+	lmac_set_aggcnt(ops, 0);
+	lmac_set_rx_aggcnt(ops, 0);
+
+	//ieee80211_crypto_bignum_support();
+	//ieee80211_crypto_ec_support();
+
+	struct ieee80211_initparam param;
+	os_memset(&param, 0, sizeof(param));
+	param.vif_maxcnt = 2;
+	param.sta_maxcnt = 2;
+	param.bss_maxcnt = 2;
+	param.bss_lifetime = 300; //300 seconds
+	param.no_rxtask = 1;
+	param.evt_cb = sys_wifi_event;
+	ieee80211_init(&param);
+	ieee80211_support_txw80x(ops);
+
+	sys_wifi_parameter_init(ops);
+	ieee80211_iface_create_sta(WIFI_MODE_STA, IEEE80211_BAND_2GHZ);
+
+	wificfg_flush(WIFI_MODE_AP);
+	wificfg_flush(WIFI_MODE_STA);
+	//eloop_init();
+	//os_task_create("eloop_run", user_eloop_run, NULL, OS_TASK_PRIORITY_NORMAL, 0, NULL, 2048);
+	os_sleep_ms(1);
+
+	{
+		struct netdev* ndev;
+		ip_addr_t ipaddr, netmask, gw;
+		ndev = (struct netdev*)dev_get(HG_WIFI0_DEVID);
+		ipaddr.addr = sys_cfgs.ipaddr;
+		netmask.addr = sys_cfgs.netmask;
+		gw.addr = sys_cfgs.gw_ip;
+		lwip_netif_add(ndev, "w0", &ipaddr, &netmask, &gw);
+		lwip_netif_remove_register(ndev);
+		lwip_netif_set_default(ndev);
+		lwip_netif_set_dhcp(ndev, 1);
+	}
+
+	wifi_create_station(oob_ssid, connect_key, WPA_KEY_MGMT_PSK);
+	ieee80211_iface_start(WIFI_MODE_STA);
+}
+
+void HAL_DisconnectFromWifi()
+{
+	struct netdev* ndev;
+	ndev = (struct netdev*)dev_get(HG_WIFI0_DEVID);
+	if(ndev)
+	{
+		lwip_netif_set_dhcp(ndev, 0);
+		os_sleep_ms(1);
+		lwip_netif_remove(ndev);
+		netif_num--;
+	}
+}
+
+int HAL_SetupWiFiOpenAccessPoint(const char* ssid)
+{
+	int32 ret;
+	g_bOpenAccessPointMode = 1;
+
+	os_sprintf(sys_cfgs.ssid, "%s", ssid);
+	void* ops;
+	struct lmac_init_param lparam;
+
+#if DCDC_EN
+	pmu_dcdc_open();
+#endif
+	void* rxbuf = (void*)os_malloc(16 * 1024);
+	lparam.rxbuf = (uint32_t)rxbuf;
+	lparam.rxbuf_size = 16 * 1024;
+	ops = lmac_bgn_init(&lparam);
+#ifdef CONFIG_SLEEP
+	void* bgn_dsleep_init(void* ops);
+	bgn_dsleep_init(ops);
+#endif
+
+#ifdef LMAC_BGN_PCF
+	lmac_set_bbm_mode_init(ops, 1); //init before ieee80211_support_txw80x
+#endif
+
+	lmac_set_aggcnt(ops, 0);
+	lmac_set_rx_aggcnt(ops, 0);
+
+	struct ieee80211_initparam param;
+	os_memset(&param, 0, sizeof(param));
+	param.vif_maxcnt = 2;
+	param.sta_maxcnt = 2;
+	param.bss_maxcnt = 2;
+	param.bss_lifetime = 300; //300 seconds
+	param.no_rxtask = 1;
+	param.evt_cb = sys_wifi_event;
+	ieee80211_init(&param);
+	ieee80211_support_txw80x(ops);
+
+	sys_wifi_parameter_init(ops);
+	ieee80211_iface_create_ap(WIFI_MODE_AP, IEEE80211_BAND_2GHZ);
+	//ieee80211_iface_create_sta(WIFI_MODE_STA, IEEE80211_BAND_2GHZ);
+
+	wificfg_flush(WIFI_MODE_STA);
+
+	//sys_wifi_start_acs(ops);
+
+	struct lmac_acs_ctl acs_ctl;
+	if(sys_cfgs.wifi_mode == WIFI_MODE_AP)
+	{
+		if(sys_cfgs.channel == 0)
+		{
+			acs_ctl.enable = 1;
+			acs_ctl.scan_ms = WIFI_ACS_SCAN_TIME;;
+			acs_ctl.chn_bitmap = WIFI_ACS_CHAN_LISTS;
+
+			ret = lmac_start_acs(ops, &acs_ctl, 1);  //阻塞式扫描
+			if(ret != RET_ERR)
+			{
+				sys_cfgs.channel = ret;
+			}
+		}
+	}
+
+	wificfg_flush(WIFI_MODE_AP);
+
+	uint8 txq[][8] = {
+		{0x00, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00,},
+		{0x00, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x01,},
+		{0x00, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x02,},
+		{0x00, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x03,},
+	};
+
+
+	ieee80211_conf_set_wmm_param(WIFI_MODE_AP, 0xf0, (struct ieee80211_wmm_param*)&txq[0]);
+	ieee80211_conf_set_wmm_param(WIFI_MODE_AP, 0xf1, (struct ieee80211_wmm_param*)&txq[1]);
+	ieee80211_conf_set_wmm_param(WIFI_MODE_AP, 0xf2, (struct ieee80211_wmm_param*)&txq[2]);
+	ieee80211_conf_set_wmm_param(WIFI_MODE_AP, 0xf3, (struct ieee80211_wmm_param*)&txq[3]);
+	os_sleep_ms(1);
+
+	{
+		struct netdev* ndev;
+		ip_addr_t ipaddr, netmask, gw;
+		ndev = (struct netdev*)dev_get(HG_WIFI1_DEVID);
+		ipaddr.addr = sys_cfgs.ipaddr;
+		netmask.addr = sys_cfgs.netmask;
+		gw.addr = sys_cfgs.gw_ip;
+		lwip_netif_add(ndev, "w0", &ipaddr, &netmask, &gw);
+		lwip_netif_remove_register(ndev);
+		lwip_netif_set_default(ndev);
+
+		struct dhcpd_param param;
+		os_memset(&param, 0, sizeof(param));
+		param.start_ip = sys_cfgs.dhcpd_startip;
+		param.end_ip = sys_cfgs.dhcpd_endip;
+		param.netmask = sys_cfgs.netmask;
+		param.router = sys_cfgs.gw_ip;
+		param.dns1 = sys_cfgs.gw_ip;
+		param.lease_time = sys_cfgs.dhcpd_lease_time;
+		if(dhcpd_start_eloop("w0", &param))
+		{
+			os_printf("dhcpd start error\r\n");
+		}
+		dns_start_eloop("w0");
+	}
+
+	wifi_create_ap(ssid, NULL, WPA_KEY_MGMT_NONE, 1);
+	ieee80211_iface_start(WIFI_MODE_AP);
+}
+
+#endif // PLATFORM_TXW81X
--- a/src/httpserver/http_fns.c
+++ b/src/httpserver/http_fns.c
@@ -1833,8 +1833,13 @@ void doHomeAssistantDiscovery(const char* topic, http_request_t* request) {
 	ledDriverChipRunning = 0;
 #endif

+#if PLATFORM_TXW81X
+	hooks.malloc_fn = _os_malloc;
+	hooks.free_fn = _os_free;
+#else
 	hooks.malloc_fn = os_malloc;
 	hooks.free_fn = os_free;
+#endif
 	cJSON_InitHooks(&hooks);

 	DRV_OnHassDiscovery(topic);
--- a/src/httpserver/new_tcp_server.c
+++ b/src/httpserver/new_tcp_server.c
@@ -35,11 +35,11 @@ void HTTPServer_Start();
 typedef struct
 {
 	int fd;
-	xTaskHandle thread;
+	beken_thread_t thread;
 	bool isCompleted;
 } tcp_thread_t;

-static xTaskHandle g_http_thread = NULL;
+static beken_thread_t g_http_thread = NULL;
 static const size_t max_socks = MAX_SOCKETS_TCP - 1;
 static int listen_sock = INVALID_SOCK;
 static tcp_thread_t sock[MAX_SOCKETS_TCP - 1] =
@@ -178,7 +178,7 @@ void HTTPServer_Stop(void* arg)
 void restart_tcp_server(void* arg)
 {
 	HTTPServer_Start();
-	vTaskDelete(NULL);
+	rtos_delete_thread(NULL);
 }

 static void tcp_server_thread(beken_thread_arg_t arg)
@@ -329,13 +329,11 @@ error:
 		}
 	}
 	rtos_delay_milliseconds(2000);
-	xTaskCreate(
-		(TaskFunction_t)restart_tcp_server,
+	rtos_create_thread(NULL, BEKEN_APPLICATION_PRIORITY,
 		"TCP Restart",
-		2048 / sizeof(StackType_t),
-		NULL,
-		BEKEN_APPLICATION_PRIORITY,
-		NULL);
+		(beken_thread_function_t)restart_tcp_server,
+		2048,
+		(beken_thread_arg_t)0);
 }

 void HTTPServer_Start()
--- a/src/httpserver/rest_interface.c
+++ b/src/httpserver/rest_interface.c
@@ -202,6 +202,8 @@ static int http_rest_post(http_request_t* request) {
 		r = http_rest_post_flash(request, -1, -1);
 #elif PLATFORM_XRADIO && !PLATFORM_XR809
 		r = http_rest_post_flash(request, 0, -1);
+#elif PLATFORM_TXW81X
+		r = http_rest_post_flash(request, 0, -1);
 #else
 		// TODO
 		ADDLOG_ERROR(LOG_FEATURE_API, "No OTA");
--- a/src/littlefs/lfs_util.h
+++ b/src/littlefs/lfs_util.h
@@ -23,7 +23,11 @@
 #include <stdint.h>
 #include <stdbool.h>
 #include <string.h>
+#if !PLATFORM_TXW81X
 #include <inttypes.h>
+#else
+#include "../win32/stubs/win_inttypes.h"
+#endif

 #ifndef LFS_NO_MALLOC
 #include <stdlib.h>
@@ -40,7 +44,7 @@

 #if PLATFORM_BEKEN
 #include "mem_pub.h"
-#elif PLATFORM_BL602 || PLATFORM_ESPIDF || PLATFORM_XRADIO || PLATFORM_ESP8266
+#elif PLATFORM_BL602 || PLATFORM_ESPIDF || PLATFORM_XRADIO || PLATFORM_ESP8266 || PLATFORM_TXW81X
 #define os_free free
 #define os_malloc malloc
 #elif PLATFORM_REALTEK || PLATFORM_W800 || PLATFORM_W600 || PLATFORM_LN882H
--- a/src/littlefs/our_lfs.c
+++ b/src/littlefs/our_lfs.c
@@ -1131,6 +1131,55 @@ static int lfs_erase(const struct lfs_config* c, lfs_block_t block)
 	return res;
 }

+#elif PLATFORM_TXW81X
+
+static int lfs_read(const struct lfs_config* c, lfs_block_t block,
+	lfs_off_t off, void* buffer, lfs_size_t size)
+{
+	int res;
+
+	unsigned int startAddr = LFS_Start;
+	startAddr += block * LFS_BLOCK_SIZE;
+	startAddr += off;
+
+	HAL_FlashRead(buffer, size, startAddr);
+	res = LFS_ERR_OK;
+	return res;
+}
+
+// Program a region in a block. The block must have previously
+// been erased. Negative error codes are propogated to the user.
+// May return LFS_ERR_CORRUPT if the block should be considered bad.
+static int lfs_write(const struct lfs_config* c, lfs_block_t block,
+	lfs_off_t off, const void* buffer, lfs_size_t size)
+{
+	int res;
+
+	unsigned int startAddr = LFS_Start;
+	startAddr += block * LFS_BLOCK_SIZE;
+	startAddr += off;
+
+	HAL_FlashWrite(buffer, size, startAddr);
+	res = LFS_ERR_OK;
+	return res;
+}
+
+// Erase a block. A block must be erased before being programmed.
+// The state of an erased block is undefined. Negative error codes
+// are propogated to the user.
+// May return LFS_ERR_CORRUPT if the block should be considered bad.
+static int lfs_erase(const struct lfs_config* c, lfs_block_t block)
+{
+	int res;
+
+	unsigned int startAddr = LFS_Start;
+	startAddr += block * LFS_BLOCK_SIZE;
+
+	HAL_FlashEraseSector(startAddr);
+	res = LFS_ERR_OK;
+	return res;
+}
+
 #endif 

 // Sync the state of the underlying block device. Negative error codes
--- a/src/littlefs/our_lfs.h
+++ b/src/littlefs/our_lfs.h
@@ -151,6 +151,12 @@
 #define LFS_BLOCKS_START_MIN 0xF7000
 #define LFS_BLOCKS_END 0xFF000

+#elif PLATFORM_TXW81X
+
+#define LFS_BLOCKS_START 0xF5000
+#define LFS_BLOCKS_START_MIN 0xF5000
+#define LFS_BLOCKS_END 0x100000
+
 #else
 // TODO
 // start 0x1000 after OTA addr
--- a/src/mqtt/new_mqtt.c
+++ b/src/mqtt/new_mqtt.c
@@ -1756,7 +1756,7 @@ static BENCHMARK_TEST_INFO* info = NULL;
 #if WINDOWS

 #elif PLATFORM_BL602 || PLATFORM_W600 || PLATFORM_W800 || PLATFORM_ESPIDF || PLATFORM_TR6260 \
-	|| PLATFORM_REALTEK || PLATFORM_ECR6600 || PLATFORM_ESP8266
+	|| PLATFORM_REALTEK || PLATFORM_ECR6600 || PLATFORM_ESP8266 || PLATFORM_TXW81X
 static void mqtt_timer_thread(void* param)
 {
 	while (1)
@@ -1799,6 +1799,8 @@ commandResult_t MQTT_StartMQTTTestThread(const void* context, const char* cmd, c
 #elif PLATFORM_BL602 || PLATFORM_W600 || PLATFORM_W800 || PLATFORM_ESPIDF || PLATFORM_TR6260 \
 	|| PLATFORM_REALTEK || PLATFORM_ECR6600 || PLATFORM_ESP8266
 	xTaskCreate(mqtt_timer_thread, "mqtt", 1024, (void*)info, 15, NULL);
+#elif PLATFORM_TXW81X
+	os_task_create("mqtt", mqtt_timer_thread, (void*)info, 15, 0, NULL, 1024);
 #elif PLATFORM_XRADIO || PLATFORM_LN882H
 	OS_TimerSetInvalid(&timer);
 	if (OS_TimerCreate(&timer, OS_TIMER_PERIODIC, MQTT_Test_Tick, (void*)info, MQTT_TMR_DURATION) != OS_OK)
--- a/src/new_common.c
+++ b/src/new_common.c
@@ -62,7 +62,7 @@ int vsprintf3(char *buffer, const char *fmt, va_list val) {

 #endif

-#if WINDOWS || PLATFORM_W800
+#if WINDOWS || PLATFORM_W800 || PLATFORM_TXW81X
 const char* strcasestr(const char* str1, const char* str2)
 {
 	const char* p1 = str1;
--- a/src/new_common.h
+++ b/src/new_common.h
@@ -182,6 +182,11 @@ typedef long BaseType_t;
 #define DEVICENAME_PREFIX_SHORT "rtl8720e"
 #define PLATFORM_MCU_NAME "RTL8720E"
 #define MANUFACTURER "Realtek"
+#elif PLATFORM_TXW81X
+#define DEVICENAME_PREFIX_FULL "OpenTXW81X"
+#define DEVICENAME_PREFIX_SHORT "txw81x"
+#define PLATFORM_MCU_NAME "TXW81X"
+#define MANUFACTURER "Taixin"
 #else
 #error "You must define a platform.."
 This platform is not supported, error!
@@ -239,6 +244,8 @@ This platform is not supported, error!
 #define USER_SW_VER "RTL8721DA_Test"
 #elif PLATFORM_RTL8720E
 #define USER_SW_VER "RTL8720E_Test"
+#elif PLATFORM_TXW81X
+#define USER_SW_VER "TXW81X_Test"
 #else
 #warning "USER_SW_VER undefined"
 #define USER_SW_VER "unknown"
@@ -802,6 +809,56 @@ OSStatus rtos_suspend_thread(beken_thread_t* thread);

 #define OBK_OTA_EXTENSION ".img"

+#elif PLATFORM_TXW81X
+
+#include "csi_kernel.h"
+#include "stdbool.h"
+#include "lwip/err.h"
+#include "lwip/sockets.h"
+#include "lwip/sys.h"
+#include "lwip/netdb.h"
+#include "lwip/dns.h"
+#include "osal/csky/defs.h"
+#include "lib/heap/sysheap.h"
+#include "osal/csky/string.h"
+
+#define bk_printf printf
+
+#define rtos_delay_milliseconds csi_kernel_delay_ms
+#define delay_ms csi_kernel_delay_ms
+
+#define lwip_close_force(x) lwip_close(x)
+#define kNoErr                      0       //! No error occurred.
+typedef void* beken_thread_arg_t;
+typedef k_task_handle_t beken_thread_t;
+typedef void (*beken_thread_function_t)(beken_thread_arg_t arg);
+typedef int OSStatus;
+typedef k_mutex_handle_t SemaphoreHandle_t;
+#define xSemaphoreCreateMutex csi_kernel_mutex_new
+#define xSemaphoreTake(a, b) (csi_kernel_mutex_lock(a, csi_kernel_ms2tick(b), 0) == 0)
+#define xSemaphoreGive csi_kernel_mutex_unlock
+#define pdTRUE true
+
+#define xPortGetFreeHeapSize() sysheap_freesize(&sram_heap)
+#define portTICK_RATE_MS RHINO_CONFIG_TICKS_PER_SECOND 
+typedef int BaseType_t;
+typedef uint64_t portTickType;
+#define xTaskGetTickCount csi_kernel_get_ticks
+
+#define BEKEN_DEFAULT_WORKER_PRIORITY      (6)
+#define BEKEN_APPLICATION_PRIORITY         (7)
+
+OSStatus rtos_delete_thread(beken_thread_t* thread);
+OSStatus rtos_create_thread(beken_thread_t* thread,
+	uint8_t priority, const char* name,
+	beken_thread_function_t function,
+	uint32_t stack_size, beken_thread_arg_t arg);
+OSStatus rtos_suspend_thread(beken_thread_t* thread);
+
+#define GLOBAL_INT_DECLARATION()	;
+#define GLOBAL_INT_DISABLE()		;
+#define GLOBAL_INT_RESTORE()		;
+
 #else

 #include "gw_intf.h"
@@ -923,7 +980,7 @@ int LWIP_GetMaxSockets();
 int LWIP_GetActiveSockets();

 #ifndef LINUX
-#if !PLATFORM_ESPIDF && !PLATFORM_ESP8266 && !PLATFORM_REALTEK_NEW
+#if !PLATFORM_ESPIDF && !PLATFORM_ESP8266 && !PLATFORM_REALTEK_NEW && !PLATFORM_TXW81X
 //delay function do 10*r nops, because rtos_delay_milliseconds is too much
 void usleep(int r);
 #endif
@@ -949,7 +1006,7 @@ typedef enum
    EXCELLENT,
 } WIFI_RSSI_LEVEL;

-#if PLATFORM_LN882H || PLATFORM_REALTEK || PLATFORM_ECR6600 || PLATFORM_TR6260 || PLATFORM_XRADIO
+#if PLATFORM_LN882H || PLATFORM_REALTEK || PLATFORM_ECR6600 || PLATFORM_TR6260 || PLATFORM_XRADIO || PLATFORM_TXW81X
 #define IP_STRING_FORMAT	"%u.%u.%u.%u"
 #else
 #define IP_STRING_FORMAT	"%hhu.%hhu.%hhu.%hhu"
--- a/src/new_pins.h
+++ b/src/new_pins.h
@@ -1081,7 +1081,7 @@ typedef enum channelType_e {
 #define PLATFORM_GPIO_MAX 17
 #elif PLATFORM_RTL8710A
 #define PLATFORM_GPIO_MAX 20
-#elif PLATFORM_RTL8720D || PLATFORM_RTL8721DA
+#elif PLATFORM_RTL8720D || PLATFORM_RTL8721DA || PLATFORM_TXW81X
 #define PLATFORM_GPIO_MAX 64
 #elif PLATFORM_RTL8720E
 #define PLATFORM_GPIO_MAX 52
@@ -1156,7 +1156,7 @@ typedef struct pinsState_s
 	byte channelTypes[CHANNEL_MAX];
 } pinsState_t;

-#elif PLATFORM_RTL8720D || PLATFORM_RTL8721DA || PLATFORM_RTL8720E
+#elif PLATFORM_RTL8720D || PLATFORM_RTL8721DA || PLATFORM_RTL8720E || PLATFORM_TXW81X

 #define MAX_PIN_ROLES 64

@@ -1410,7 +1410,7 @@ typedef struct mainConfig_s {
 	byte unusedSectorAB[51];
 #elif PLATFORM_ESPIDF
 	byte unusedSectorAB[43];
-#elif PLATFORM_RTL8720D || PLATFORM_RTL8721DA || PLATFORM_RTL8720E
+#elif PLATFORM_RTL8720D || PLATFORM_RTL8721DA || PLATFORM_RTL8720E || PLATFORM_TXW81X
 	byte unusedSectorAB;
 #else    
 	byte unusedSectorAB[99];
--- a/src/obk_config.h
+++ b/src/obk_config.h
@@ -529,6 +529,20 @@

 // #define ENABLE_OBK_BERRY						1

+#elif PLATFORM_TXW81X
+
+#define NO_CHIP_TEMPERATURE						1
+#define NEW_TCP_SERVER							1
+#define ENABLE_MQTT								1
+#define ENABLE_HA_DISCOVERY						1
+#define ENABLE_EXPAND_CONSTANT					1
+#define ENABLE_OBK_SCRIPTING					1
+//#define ENABLE_ADVANCED_CHANNELTYPES_DISCOVERY	1
+#define ENABLE_LITTLEFS							1
+#define ENABLE_NTP 								1
+#undef ENABLE_HTTP_MAC
+#undef ENABLE_LED_BASIC
+
 #else

 // #error "Platform not defined"
--- a/src/user_main.c
+++ b/src/user_main.c
@@ -254,6 +254,49 @@ OSStatus rtos_suspend_thread(beken_thread_t* thread)
 	return kNoErr;
 }

+#elif PLATFORM_TXW81X
+
+OSStatus rtos_create_thread(beken_thread_t* thread,
+	uint8_t priority, const char* name,
+	beken_thread_function_t function,
+	uint32_t stack_size, beken_thread_arg_t arg)
+{
+	OSStatus err = kNoErr;
+
+	*thread = os_task_create(name, function, arg, priority, 0, NULL, stack_size);
+	if(*thread != NULL)
+	{
+		return 0;
+	}
+	else
+	{
+		printf("Thread create %s - err %i\n", name, err);
+	}
+	return 1;
+}
+
+OSStatus rtos_delete_thread(beken_thread_t* thread)
+{
+	if(thread == NULL)
+	{
+		k_task_handle_t hdl = os_task_current();
+		os_task_destroy(hdl);
+	}
+	else os_task_destroy(*thread);
+	return kNoErr;
+}
+
+OSStatus rtos_suspend_thread(beken_thread_t* thread)
+{
+	if(thread == NULL)
+	{
+		k_task_handle_t hdl = os_task_current();
+		os_task_suspend2(hdl);
+	}
+	else os_task_suspend2(*thread);
+	return kNoErr;
+}
+
 #endif

 void MAIN_ScheduleUnsafeInit(int delSeconds) {
@@ -1041,7 +1084,7 @@ void QuickTick(void* param)
 #if WINDOWS

 #elif PLATFORM_BL602 || PLATFORM_W600 || PLATFORM_W800 || PLATFORM_TR6260 || defined(PLATFORM_REALTEK) || PLATFORM_ECR6600 \
-	|| PLATFORM_ESP8266 || PLATFORM_ESPIDF || PLATFORM_XRADIO || PLATFORM_LN882H
+	|| PLATFORM_ESP8266 || PLATFORM_ESPIDF || PLATFORM_XRADIO || PLATFORM_LN882H || PLATFORM_TXW81X
 void quick_timer_thread(void* param)
 {
 	while (1) {
@@ -1059,6 +1102,8 @@ void QuickTick_StartThread(void)
 #elif PLATFORM_BL602 || PLATFORM_W600 || PLATFORM_W800 || PLATFORM_TR6260 || defined(PLATFORM_REALTEK) || PLATFORM_ECR6600 \
 	|| PLATFORM_ESP8266 || PLATFORM_ESPIDF || PLATFORM_XRADIO || PLATFORM_LN882H
 	xTaskCreate(quick_timer_thread, "quick", QT_STACK_SIZE, NULL, 15, NULL);
+#elif PLATFORM_TXW81X
+	os_task_create("quick", quick_timer_thread, NULL, 15, 0, NULL, QT_STACK_SIZE);
 #else
 	OSStatus result;