diff --git a/.github/workflows/workflow.yaml b/.github/workflows/workflow.yaml
index 23a0f2fd4..5368b61e2 100644
--- a/.github/workflows/workflow.yaml
+++ b/.github/workflows/workflow.yaml
@@ -106,7 +106,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        platform: [OpenBK7231N, OpenBK7238, OpenXR809, OpenBL602, OpenW800, OpenW600, OpenLN882H, OpenTR6260, OpenRTL8710A, OpenRTL8710B, OpenRTL87X0C, OpenRTL8720D]
+        platform: [OpenBK7231N, OpenBK7238, OpenXR809, OpenBL602, OpenW800, OpenW600, OpenLN882H, OpenTR6260, OpenRTL8710A, OpenRTL8710B, OpenRTL87X0C, OpenRTL8720D, OpenECR6600]
     steps:
       - name: Source checkout
         uses: actions/checkout@v4
diff --git a/.gitmodules b/.gitmodules
index 88331f114..fcd4298f1 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -49,3 +49,7 @@
 	path = sdk/OpenRTL8720D
 	url = https://github.com/NonPIayerCharacter/OpenRTL8720D.git
 	branch = master
+[submodule "sdk/OpenECR6600"]
+	path = sdk/OpenECR6600
+	url = https://github.com/NonPIayerCharacter/OpenECR6600.git
+	branch = master
diff --git a/Makefile b/Makefile
index 7d10d2f40..cc252963c 100644
--- a/Makefile
+++ b/Makefile
@@ -205,6 +205,14 @@ prebuild_OpenBK7231N_ALT:
 	else echo "prebuild for OpenBK7231N not found ... "; \
 	fi
 
+prebuild_OpenECR6600:
+	git submodule update --init --recursive sdk/OpenECR6600
+	@if [ -e platforms/ECR6600/pre_build.sh ]; then \
+		echo "prebuild found for OpenECR6600"; \
+		sh platforms/ECR6600/pre_build.sh; \
+	else echo "prebuild for OpenECR6600 not found ... "; \
+	fi
+
 # Build main binaries
 OpenBK7231T: prebuild_OpenBK7231T
 	mkdir -p output
@@ -395,6 +403,16 @@ OpenBK7231N_ALT: prebuild_OpenBK7231N_ALT
 	cp sdk/beken_freertos_sdk/out/all_2M.1220.bin output/$(APP_VERSION)/OpenBK7231N_ALT_QIO_${APP_VERSION}.bin
 	cp sdk/beken_freertos_sdk/out/app.rbl output/$(APP_VERSION)/OpenBK7231N_ALT_${APP_VERSION}.rbl
 	cp sdk/beken_freertos_sdk/out/bk7231n_bsp_uart_2M.1220.bin output/$(APP_VERSION)/OpenBK7231N_ALT_UA_${APP_VERSION}.bin
+	
+.PHONY: OpenECR6600
+ECRDIR := $(PWD)/sdk/OpenECR6600
+OpenECR6600: prebuild_OpenECR6600
+	if [ ! -e sdk/OpenECR6600/tool/nds32le-elf-mculib-v3s ]; then cd sdk/OpenECR6600/tool && xz -d < nds32le-elf-mculib-v3s.txz | tar xvf - > /dev/null; fi
+	cd sdk/OpenECR6600 && make BOARD_DIR=$(ECRDIR)/Boards/ecr6600/standalone APP_NAME=OpenBeken TOPDIR=$(ECRDIR) GCC_PATH=$(ECRDIR)/tool/nds32le-elf-mculib-v3s/bin/ APP_VERSION=$(APP_VERSION) defconfig
+	cd sdk/OpenECR6600 && make BOARD_DIR=$(ECRDIR)/Boards/ecr6600/standalone APP_NAME=OpenBeken TOPDIR=$(ECRDIR) GCC_PATH=$(ECRDIR)/tool/nds32le-elf-mculib-v3s/bin/ APP_VERSION=$(APP_VERSION) REL_V=OpenECR6600_$(APP_VERSION) all
+	mkdir -p output/$(APP_VERSION)
+	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
 
 # clean .o files and output directory
 .PHONY: clean
@@ -417,6 +435,7 @@ clean:
 	test -d ./platforms/ESP-IDF/build-c6 && cmake --build ./platforms/ESP-IDF/build-c6 --target clean
 	test -d ./platforms/ESP-IDF/build-s2 && cmake --build ./platforms/ESP-IDF/build-s2 --target clean
 	test -d ./platforms/ESP-IDF/build-s3 && cmake --build ./platforms/ESP-IDF/build-s3 --target clean
+	cd sdk/OpenECR6600 && make BOARD_DIR=$(ECRDIR)/Boards/ecr6600/standalone APP_NAME=OpenBeken TOPDIR=$(ECRDIR) GCC_PATH=$(ECRDIR)/tool/nds32le-elf-mculib-v3s/bin/ clean
 
 # Add custom Makefile if required
 -include custom.mk
diff --git a/platforms/ECR6600/OpenBeken.mk b/platforms/ECR6600/OpenBeken.mk
new file mode 100644
index 000000000..d3de6ce1f
--- /dev/null
+++ b/platforms/ECR6600/OpenBeken.mk
@@ -0,0 +1,159 @@
+CFLAGS +=  -DPLATFORM_ECR6600 -DUSER_SW_VER='"$(APP_VERSION)"' -Wno-error -DTCP_MSL=3000
+#VPATH += $(TOPDIR)/../../src/base64
+#VPATH += $(TOPDIR)/../../src/bitmessage
+#VPATH += $(TOPDIR)/../../src/cJSON
+#VPATH += $(TOPDIR)/../../src/cmnds
+#VPATH += $(TOPDIR)/../../src/devicegroups
+#VPATH += $(TOPDIR)/../../src/driver
+#VPATH += $(TOPDIR)/../../src/hal
+#VPATH += $(TOPDIR)/../../src/hal/ecr6600
+#VPATH += $(TOPDIR)/../../src/hal/generic
+#VPATH += $(TOPDIR)/../../src/httpserver
+#VPATH += $(TOPDIR)/../../src/jsmn
+#VPATH += $(TOPDIR)/../../src/logging
+#VPATH += $(TOPDIR)/../../src/mqtt
+#VPATH += $(TOPDIR)/../../src/i2c
+#VPATH += $(TOPDIR)/../../src/littlefs
+VPATH += $(TOPDIR)/../../src
+VPATH += $(TOPDIR)/../../platforms/ECR6600
+
+INCPATHS += $(TOPDIR)/../../src
+INCPATHS += $(TOPDIR)/include/ota
+INCPATHS += $(TOPDIR)/include
+INCPATHS += $(TOPDIR)
+
+CSRCS  = main.c
+CSRCS  += base64/base64.c
+CSRCS  += bitmessage/bitmessage_read.c
+CSRCS  += bitmessage/bitmessage_write.c
+CSRCS  += cJSON/cJSON.c
+CSRCS  += cmnds/cmd_channels.c
+CSRCS  += cmnds/cmd_eventHandlers.c
+CSRCS  += cmnds/cmd_if.c
+CSRCS  += cmnds/cmd_main.c
+CSRCS  += cmnds/cmd_newLEDDriver_colors.c
+CSRCS  += cmnds/cmd_newLEDDriver.c
+CSRCS  += cmnds/cmd_repeatingEvents.c
+CSRCS  += cmnds/cmd_script.c
+CSRCS  += cmnds/cmd_simulatorOnly.c
+CSRCS  += cmnds/cmd_tasmota.c
+CSRCS  += cmnds/cmd_tcp.c
+CSRCS  += cmnds/cmd_test.c
+CSRCS  += cmnds/cmd_tokenizer.c
+CSRCS  += devicegroups/deviceGroups_read.c
+CSRCS  += devicegroups/deviceGroups_util.c
+CSRCS  += devicegroups/deviceGroups_write.c
+CSRCS  += driver/drv_main.c
+CSRCS  += hal/ecr6600/hal_adc_ecr6600.c
+CSRCS  += hal/ecr6600/hal_flashConfig_ecr6600.c
+CSRCS  += hal/ecr6600/hal_flashVars_ecr6600.c
+CSRCS  += hal/ecr6600/hal_generic_ecr6600.c
+CSRCS  += hal/ecr6600/hal_pins_ecr6600.c
+CSRCS  += hal/ecr6600/hal_wifi_ecr6600.c
+CSRCS  += hal/ecr6600/hal_uart_ecr6600.c
+CSRCS  += hal/generic/hal_adc_generic.c
+CSRCS  += hal/generic/hal_flashConfig_generic.c
+CSRCS  += hal/generic/hal_flashVars_generic.c
+CSRCS  += hal/generic/hal_generic.c
+CSRCS  += hal/generic/hal_main_generic.c
+CSRCS  += hal/generic/hal_pins_generic.c
+CSRCS  += hal/generic/hal_wifi_generic.c
+CSRCS  += hal/generic/hal_uart_generic.c
+CSRCS  += httpserver/hass.c
+CSRCS  += httpserver/http_basic_auth.c
+CSRCS  += httpserver/http_fns.c
+CSRCS  += httpserver/http_tcp_server.c
+CSRCS  += httpserver/new_tcp_server.c
+CSRCS  += httpserver/json_interface.c
+CSRCS  += httpserver/new_http.c
+CSRCS  += httpserver/rest_interface.c
+CSRCS  += mqtt/new_mqtt_deduper.c
+CSRCS  += jsmn/jsmn.c
+CSRCS  += logging/logging.c
+CSRCS  += mqtt/new_mqtt.c
+CSRCS  += new_cfg.c
+CSRCS  += new_common.c
+CSRCS  += new_ping.c
+CSRCS  += new_pins.c
+CSRCS  += rgb2hsv.c
+CSRCS  += tiny_crc8.c
+CSRCS  += user_main.c
+#CSRCS += cmnds/cmd_send.c
+CSRCS  += driver/drv_adcButton.c
+CSRCS  += driver/drv_adcSmoother.c
+CSRCS  += driver/drv_aht2x.c
+CSRCS  += driver/drv_battery.c
+CSRCS  += driver/drv_bl_shared.c
+CSRCS  += driver/drv_bl0937.c
+CSRCS  += driver/drv_bl0942.c
+#CSRCS += driver/drv_bmp280.c
+CSRCS  += driver/drv_bmpi2c.c
+CSRCS  += driver/drv_bp1658cj.c
+CSRCS  += driver/drv_bp5758d.c
+CSRCS  += driver/drv_bridge_driver.c
+CSRCS  += driver/drv_chargingLimit.c
+CSRCS  += driver/drv_charts.c
+CSRCS  += driver/drv_cht8305.c
+CSRCS  += driver/drv_cse7766.c
+CSRCS  += driver/drv_ddp.c
+CSRCS  += driver/drv_debouncer.c
+CSRCS  += driver/drv_dht_internal.c
+CSRCS  += driver/drv_dht.c
+CSRCS  += driver/drv_doorSensorWithDeepSleep.c
+CSRCS  += driver/drv_gn6932.c
+CSRCS  += driver/drv_hd2015.c
+CSRCS  += driver/drv_ht16k33.c
+CSRCS  += driver/drv_httpButtons.c
+CSRCS  += driver/drv_hue.c
+CSRCS  += driver/drv_kp18058.c
+CSRCS  += driver/drv_kp18068.c
+CSRCS  += driver/drv_max72xx_clock.c
+CSRCS  += driver/drv_max72xx_internal.c
+CSRCS  += driver/drv_max72xx_single.c
+CSRCS  += driver/drv_mcp9808.c
+CSRCS  += driver/drv_ntp_events.c
+CSRCS  += driver/drv_ntp.c
+CSRCS  += driver/drv_pt6523.c
+CSRCS  += driver/drv_pwm_groups.c
+CSRCS  += driver/drv_pwmToggler.c
+CSRCS  += driver/drv_pwrCal.c
+CSRCS  += driver/drv_rn8209.c
+CSRCS  += driver/drv_sgp.c
+CSRCS  += driver/drv_shiftRegister.c
+CSRCS  += driver/drv_sht3x.c
+#CSRCS += driver/drv_sm15155e.c
+#CSRCS += driver/drv_sm16703P.c
+CSRCS  += driver/drv_sm2135.c
+CSRCS  += driver/drv_sm2235.c
+CSRCS  += driver/drv_soft_i2c.c
+#CSRCS += driver/drv_soft_spi.c
+#CSRCS += driver/drv_spi_flash.c
+#CSRCS += driver/drv_spi.c
+#CSRCS += driver/drv_spidma.c
+CSRCS  += driver/drv_ssdp.c
+CSRCS  += driver/drv_tasmotaDeviceGroups.c
+CSRCS  += driver/drv_test_drivers.c
+CSRCS  += driver/drv_textScroller.c
+CSRCS  += driver/drv_tm_gn_display_shared.c
+CSRCS  += driver/drv_tm1637.c
+CSRCS  += driver/drv_tm1638.c
+CSRCS  += driver/drv_tuyaMCU.c
+CSRCS  += driver/drv_tuyaMCUSensor.c
+CSRCS  += driver/drv_uart.c
+CSRCS  += driver/drv_ucs1912.c
+CSRCS  += driver/drv_wemo.c
+CSRCS  += driver/drv_ds1820_simple.c
+CSRCS  += driver/drv_uart_tcp.c
+#CSRCS += httpclient/http_client.c
+#CSRCS += httpclient/utils_net.c
+#CSRCS += httpclient/utils_timer.c
+CSRCS  += i2c/drv_i2c_lcd_pcf8574t.c
+CSRCS  += i2c/drv_i2c_main.c
+CSRCS  += i2c/drv_i2c_mcp23017.c
+CSRCS  += i2c/drv_i2c_tc74.c
+CSRCS  += littlefs/lfs_util.c
+CSRCS  += littlefs/lfs.c
+CSRCS  += littlefs/our_lfs.c
+#CSRCS += memory/memtest.c
+#CSRCS += ota/ota.c
+#CSRCS += sim/sim_uart.c
diff --git a/platforms/ECR6600/main.c b/platforms/ECR6600/main.c
new file mode 100644
index 000000000..493a09180
--- /dev/null
+++ b/platforms/ECR6600/main.c
@@ -0,0 +1,124 @@
+#include "oshal.h"
+#include "cli.h"
+#include "flash.h"
+#include "sdk_version.h"
+#include "psm_system.h"
+
+#define DFE_VAR
+#include "tx_power_config.h"
+
+extern void vTaskStartScheduler(void);
+extern void wifi_main();
+extern void rf_platform_int();
+extern void ke_init(void);
+extern void amt_cal_info_obtain();
+extern void wifi_conn_main();
+extern int version_get(void);
+
+extern void Main_Init();
+extern void Main_OnEverySecond();
+
+TaskHandle_t g_sys_task_handle1;
+extern uint8_t wmac[6];
+
+int _close_r()
+{
+	return 0;
+}
+
+void sys_task1(void* pvParameters)
+{
+	while(!wifi_is_ready())
+	{
+		sys_delay_ms(20);
+		printf("wifi not ready!\n");
+	}
+
+	Main_Init();
+	while(true)
+	{
+		sys_delay_ms(1000);
+		Main_OnEverySecond();
+	}
+}
+
+#undef os_malloc
+void* os_malloc(size_t size)
+{
+	return pvPortMalloc(size);
+}
+
+int main(void)
+{
+	component_cli_init(E_UART_NUM_2);
+	printf("SDK version %s, Release version %s\n",
+			  sdk_version, RELEASE_VERSION);
+
+	rf_platform_int();
+
+	int pinit = partion_init();
+	if (pinit != 0)
+	{
+		printf("partition error %i\n", pinit);
+	}
+	if (easyflash_init() != 0)
+	{
+		printf("easyflash error\n");
+	}
+
+	ke_init();
+
+	if (version_get() == 1)
+	{
+		drv_adc_init();
+		get_volt_calibrate_data();
+		time_check_temp();
+	}
+
+	// disabling this allowed connecting to ap with -91 rssi
+	//amt_cal_info_obtain();
+
+	wifi_main();
+
+	// disabling this will crash when getting ip
+	psm_wifi_ble_init();
+	//psm_wifi_ps_to_active();
+	//psm_sleep_mode_ena_op(true, 0);
+	//psm_set_psm_enable(0);
+	//psm_pwr_mgt_ctrl(0);
+	//psm_sleep_mode_ena_op(true, 0);
+	//PSM_SLEEP_CLEAR(MODEM_SLEEP);
+	//PSM_SLEEP_CLEAR(WFI_SLEEP);
+	//psm_set_device_status(PSM_DEVICE_WIFI_STA, PSM_DEVICE_STATUS_ACTIVE);
+	//psm_set_normal();
+	//psm_set_sleep_mode(0, 0);
+	//psm_boot_flag_dbg_op(true, 1);
+	//AmtRfStart(1, "1");
+	//int txgf = AmtRfGetTxGainFlag();
+	//int txg = AmtRfGetTxGain();
+	//printf("\r\nAmtRfGetTxGainFlag:%i AmtRfGetTxGain: %i\r\n", txgf, txg);
+	// max txpower reported in console is 137 - 13.7dbm.
+	//AmtRfSetApcIndex(1, "137");
+	//uint8_t str[240];
+	//amt_get_env_blob("txPower", &str, 240, NULL);
+	//printf("txPower: %.*s\r\n", 240, str);
+	//for(int i = 0; i < 240; i += 2)
+	//{
+	//	str[i] = 0xFF;
+	//	str[i + 1] = 0x89;
+	//}
+	//amt_set_env_blob("txPower", str, 240);
+	// efuse mac is not burnt on wg236p (or probably on anything, since writing it is unsupported in console)
+	//drv_efuse_read(0x18, (unsigned int*)wmac, 6);
+
+	xTaskCreate(
+		sys_task1,
+		"OpenBeken",
+		8 * 256,
+		NULL,
+		6,
+		&g_sys_task_handle1);
+
+	vTaskStartScheduler();
+	return 0;
+}
diff --git a/sdk/OpenECR6600 b/sdk/OpenECR6600
new file mode 160000
index 000000000..cbd9f65f6
--- /dev/null
+++ b/sdk/OpenECR6600
@@ -0,0 +1 @@
+Subproject commit cbd9f65f6bc68d08bb8395dfdcd78c1189822dd1
diff --git a/src/cmnds/cmd_tokenizer.c b/src/cmnds/cmd_tokenizer.c
index ff83bf1e3..aeb2033d5 100644
--- 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
+#if PLATFORM_W600 || PLATFORM_LN882H || PLATFORM_REALTEK || PLATFORM_ECR6600
 	//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];
diff --git a/src/driver/drv_bl0937.c b/src/driver/drv_bl0937.c
index e1734b2bb..321e119f6 100644
--- a/src/driver/drv_bl0937.c
+++ b/src/driver/drv_bl0937.c
@@ -46,6 +46,10 @@ extern rtlPinMapping_t g_pins[];
 rtlPinMapping_t* rtl_cf;
 rtlPinMapping_t* rtl_cf1;
 
+#elif PLATFORM_ECR6600
+
+#include "gpio.h"
+
 #else
 
 
@@ -232,6 +236,11 @@ void BL0937_Shutdown_Pins()
 	rtl_cf1->irq = NULL;
 	rtl_cf->irq = NULL;
 
+#elif PLATFORM_ECR6600
+
+	drv_gpio_ioctrl(GPIO_HLW_CF1_pin, DRV_GPIO_CTRL_INTR_DISABLE, 0);
+	drv_gpio_ioctrl(GPIO_HLW_CF_pin, DRV_GPIO_CTRL_INTR_DISABLE, 0);
+
 #endif
 }
 
@@ -320,6 +329,12 @@ void BL0937_Init_Pins()
 	gpio_irq_set(rtl_cf1->irq, IRQ_FALL, 1);
 	gpio_irq_enable(rtl_cf1->irq);
 
+#elif PLATFORM_ECR6600
+
+	drv_gpio_ioctrl(GPIO_HLW_CF1_pin, DRV_GPIO_CTRL_INTR_MODE, DRV_GPIO_ARG_INTR_MODE_N_EDGE);
+	drv_gpio_ioctrl(GPIO_HLW_CF1_pin, DRV_GPIO_CTRL_REGISTER_ISR, (int)&HlwCf1Interrupt);
+	drv_gpio_ioctrl(GPIO_HLW_CF1_pin, DRV_GPIO_CTRL_INTR_ENABLE, 0);
+
 #endif
 
 	HAL_PIN_Setup_Input_Pullup(GPIO_HLW_CF);
@@ -351,6 +366,12 @@ void BL0937_Init_Pins()
 	gpio_irq_set(rtl_cf->irq, IRQ_FALL, 1);
 	gpio_irq_enable(rtl_cf->irq);
 
+#elif PLATFORM_ECR6600
+
+	drv_gpio_ioctrl(GPIO_HLW_CF_pin, DRV_GPIO_CTRL_INTR_MODE, DRV_GPIO_ARG_INTR_MODE_N_EDGE);
+	drv_gpio_ioctrl(GPIO_HLW_CF_pin, DRV_GPIO_CTRL_REGISTER_ISR, (int)&HlwCfInterrupt);
+	drv_gpio_ioctrl(GPIO_HLW_CF_pin, DRV_GPIO_CTRL_INTR_ENABLE, 0);
+
 #endif
 
 	g_vc_pulses = 0;
diff --git a/src/hal/ecr6600/hal_adc_ecr6600.c b/src/hal/ecr6600/hal_adc_ecr6600.c
new file mode 100644
index 000000000..2b953b18e
--- /dev/null
+++ b/src/hal/ecr6600/hal_adc_ecr6600.c
@@ -0,0 +1,29 @@
+#ifdef PLATFORM_ECR6600
+
+#include "../hal_adc.h"
+#include "adc.h"
+
+int HAL_ADC_Read(int pinNumber)
+{
+	//DRV_ADC_INPUT_SIGNAL_A_SEL adc = 0xFF;
+	switch(pinNumber)
+	{
+		//case 14: adc = DRV_ADC_A_INPUT_GPIO_0;
+		//case 15: adc = DRV_ADC_A_INPUT_GPIO_1;
+		//case 18: adc = DRV_ADC_A_INPUT_GPIO_3;
+		//case 20: adc = DRV_ADC_A_INPUT_GPIO_2;
+		case 26: drv_adc_lock(); int vout = vbat_temp_share_test(0); drv_adc_unlock(); return vout / 1000;
+		default:
+			return 0;
+	}
+	//if(adc != 0xFF)
+	//{
+	//	drv_adc_lock();
+	//	drv_aux_adc_config(adc, DRV_ADC_B_INPUT_VREF_BUFFER, DRV_ADC_EXPECT_MAX_VOLT3);
+	//	int vout = drv_aux_adc_single();
+	//	drv_adc_unlock();
+	//	return vout;
+	//}
+}
+
+#endif // PLATFORM_ECR6600
diff --git a/src/hal/ecr6600/hal_flashConfig_ecr6600.c b/src/hal/ecr6600/hal_flashConfig_ecr6600.c
new file mode 100644
index 000000000..3004c12c9
--- /dev/null
+++ b/src/hal/ecr6600/hal_flashConfig_ecr6600.c
@@ -0,0 +1,24 @@
+#ifdef PLATFORM_ECR6600
+
+#include "../hal_flashConfig.h"
+#include <easyflash.h>
+#define ef_get_env_blob obk_get_env_blob
+#define ef_set_env_blob obk_set_env_blob
+
+extern int obk_get_env_blob(const char* key, void* value_buf, signed int buf_len, signed int* value_len);
+extern EfErrCode obk_set_env_blob(const char* key, const void* value_buf, signed int buf_len);
+
+
+int HAL_Configuration_ReadConfigMemory(void* target, int dataLen)
+{
+	return ef_get_env_blob("ObkCfg", target, dataLen, NULL);
+}
+
+int HAL_Configuration_SaveConfigMemory(void* src, int dataLen)
+{
+	//ef_del_env("ObkCfg");
+	ef_set_env_blob("ObkCfg", src, dataLen);
+	return 1;
+}
+
+#endif // PLATFORM_ECR6600
diff --git a/src/hal/ecr6600/hal_flashVars_ecr6600.c b/src/hal/ecr6600/hal_flashVars_ecr6600.c
new file mode 100644
index 000000000..9e4830a10
--- /dev/null
+++ b/src/hal/ecr6600/hal_flashVars_ecr6600.c
@@ -0,0 +1,179 @@
+#ifdef PLATFORM_ECR6600
+
+#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 ef_get_env_blob customer_get_env_blob
+#define ef_set_env_blob customer_set_env_blob
+
+#define KV_KEY_FLASH_VARS "OBK_FV"
+#define SAVE_CHANGE_IF_REQUIRED_AND_COUNT(target, source, counter) \
+	if((target) != (source)) { \
+		(target) = (source); \
+		counter++; \
+	}
+
+static int ReadFlashVars(void* target, int dataLen)
+{
+	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)
+{
+	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_ECR6600
diff --git a/src/hal/ecr6600/hal_generic_ecr6600.c b/src/hal/ecr6600/hal_generic_ecr6600.c
new file mode 100644
index 000000000..e08db6ee5
--- /dev/null
+++ b/src/hal/ecr6600/hal_generic_ecr6600.c
@@ -0,0 +1,30 @@
+#ifdef PLATFORM_ECR6600
+
+#include "../hal_generic.h"
+#include "os/oshal.h"
+#include "hal_system.h"
+#include "hal_wdt.h"
+
+void HAL_RebootModule()
+{
+	hal_system_reset(RST_TYPE_SOFTWARE_REBOOT);
+}
+
+void HAL_Delay_us(int delay)
+{
+	os_usdelay(delay);
+}
+
+void HAL_Configure_WDT()
+{
+	unsigned int effect_time = 0;
+	hal_wdt_init(10000, &effect_time);
+	hal_wdt_start();
+}
+
+void HAL_Run_WDT()
+{
+	hal_wdt_feed();
+}
+
+#endif // PLATFORM_ECR6600
diff --git a/src/hal/ecr6600/hal_pins_ecr6600.c b/src/hal/ecr6600/hal_pins_ecr6600.c
new file mode 100644
index 000000000..b8111da62
--- /dev/null
+++ b/src/hal/ecr6600/hal_pins_ecr6600.c
@@ -0,0 +1,309 @@
+#if PLATFORM_ECR6600
+
+#include "../../new_common.h"
+#include "../../logging/logging.h"
+#include "../../new_cfg.h"
+#include "../../new_pins.h"
+#include "hal_gpio.h"
+#include "gpio.h"
+#include "pwm.h"
+#include "chip_pinmux.h"
+
+extern int g_pwmFrequency;
+
+typedef struct ecrPinMapping_s
+{
+	const char* name;
+	int pin;
+} ecrPinMapping_t;
+
+ecrPinMapping_t g_pins[] = {
+	{ "P0 (PWM0/TX2)",  GPIO_NUM_0 },
+	{ "P1 (PWM1/RX1)",  GPIO_NUM_1 },
+	{ "P2 (PWM2/TX1)",  GPIO_NUM_2 },
+	{ "P3 (PWM3)",  GPIO_NUM_3 },
+	{ "P4 (PWM4)",  GPIO_NUM_4 },
+	{ "P5 (RX0)",  GPIO_NUM_5 },
+	{ "P6 (TX0)",  GPIO_NUM_6 },
+	{ "P7",  GPIO_NUM_7 },
+	{ "P8",  GPIO_NUM_8 },
+	{ "P9",  GPIO_NUM_9 },
+	{ "P10", GPIO_NUM_10 },
+	{ "P11", GPIO_NUM_11 },
+	{ "P12", GPIO_NUM_12 },
+	{ "P13 (TX2)", GPIO_NUM_13 },
+	{ "P14 (PWM4/ADC0)", GPIO_NUM_14 },
+	{ "P15 (PWM5/ADC1)", GPIO_NUM_15 },
+	{ "P16 (PWM2)", GPIO_NUM_16 },
+	{ "P17 (PWM5/RX2)", GPIO_NUM_17 },
+	{ "P18 (ADC3)", GPIO_NUM_18 },
+	{ "P19 (NC)", GPIO_NUM_19 },
+	{ "P20 (PWM3/ADC2)", GPIO_NUM_20 },
+	{ "P21 (RX0)", GPIO_NUM_21 },
+	{ "P22 (PWM0/TX0)", GPIO_NUM_22 },
+	{ "P23 (PWM1)", GPIO_NUM_23 },
+	{ "P24 (PWM2)", GPIO_NUM_24 },
+	{ "P25 (PWM3)", GPIO_NUM_25 },
+	{ "VBAT", -1 },
+};
+
+static int g_numPins = (sizeof(g_pins) / sizeof(g_pins[0])) - 1;
+
+static uint32_t g_periods[6] = { 0 };
+
+int PIN_GetPWMIndexForPinIndex(int pin)
+{
+	switch(pin)
+	{
+		case 0:  return 0;
+		case 22: return 0;
+		case 1:  return 1;
+		case 23: return 1;
+		case 2:  return 2;
+		case 16: return 2;
+		case 24: return 2;
+		case 3:  return 3;
+		case 25: return 3;
+		case 4:  return 4;
+		case 14: return 4;
+		case 15: return 5;
+		case 17: return 5;
+		default: return -1;
+	}
+}
+
+bool HAL_PIN_Set_As_GPIO(int pin)
+{
+	switch(pin)
+	{
+		case GPIO_NUM_0:
+			PIN_FUNC_SET(IO_MUX_GPIO0, FUNC_GPIO0_GPIO0);
+			return true;
+		case GPIO_NUM_1:
+			PIN_FUNC_SET(IO_MUX_GPIO1, FUNC_GPIO1_GPIO1);
+			return true;
+		case GPIO_NUM_2:
+			PIN_FUNC_SET(IO_MUX_GPIO2, FUNC_GPIO2_GPIO2);
+			return true;
+		case GPIO_NUM_3:
+			PIN_FUNC_SET(IO_MUX_GPIO3, FUNC_GPIO3_GPIO3);
+			return true;
+		case GPIO_NUM_4:
+			PIN_FUNC_SET(IO_MUX_GPIO4, FUNC_GPIO4_GPIO4);
+			return true;
+		case GPIO_NUM_5:
+			PIN_FUNC_SET(IO_MUX_GPIO5, FUNC_GPIO5_GPIO5);
+			return true;
+		case GPIO_NUM_6:
+			PIN_FUNC_SET(IO_MUX_GPIO6, FUNC_GPIO6_GPIO6);
+			return true;
+		// spi?
+		//case GPIO_NUM_7:
+		//	PIN_FUNC_SET(IO_MUX_GPIO7, FUNC_GPIO7_GPIO7);
+		//	return true;
+		//case GPIO_NUM_8:
+		//	PIN_FUNC_SET(IO_MUX_GPIO8, FUNC_GPIO8_GPIO8);
+		//	return true;
+		//case GPIO_NUM_9:
+		//	PIN_FUNC_SET(IO_MUX_GPIO9, FUNC_GPIO9_GPIO9);
+		//	return true;
+		//case GPIO_NUM_10:
+		//	PIN_FUNC_SET(IO_MUX_GPIO10, FUNC_GPIO10_GPIO10);
+		//	return true;
+		//case GPIO_NUM_11:
+		//	PIN_FUNC_SET(IO_MUX_GPIO11, FUNC_GPIO11_GPIO11);
+		//	return true;
+		//case GPIO_NUM_12:
+		//	PIN_FUNC_SET(IO_MUX_GPIO12, FUNC_GPIO12_GPIO12);
+		//	return true;
+		case GPIO_NUM_13:
+			PIN_FUNC_SET(IO_MUX_GPIO13, FUNC_GPIO13_GPIO13);
+			return true;
+		case GPIO_NUM_14:
+			PIN_FUNC_SET(IO_MUX_GPIO14, FUNC_GPIO14_GPIO14);
+			return true;
+		case GPIO_NUM_15:
+			PIN_FUNC_SET(IO_MUX_GPIO15, FUNC_GPIO15_GPIO15);
+			return true;
+		case GPIO_NUM_16:
+			PIN_FUNC_SET(IO_MUX_GPIO16, FUNC_GPIO16_GPIO16);
+			return true;
+		case GPIO_NUM_17:
+			PIN_FUNC_SET(IO_MUX_GPIO17, FUNC_GPIO17_GPIO17);
+			return true;
+		case GPIO_NUM_18:
+			PIN_FUNC_SET(IO_MUX_GPIO18, FUNC_GPIO18_GPIO18);
+			return true;
+		//case GPIO_NUM_19:
+		//	PIN_FUNC_SET(IO_MUX_GPIO19, FUNC_GPIO19_GPIO19);
+		//	return true;
+		case GPIO_NUM_20:
+			PIN_FUNC_SET(IO_MUX_GPIO20, FUNC_GPIO20_GPIO20);
+			return true;
+		case GPIO_NUM_21:
+			PIN_FUNC_SET(IO_MUX_GPIO21, FUNC_GPIO21_GPIO21);
+			return true;
+		case GPIO_NUM_22:
+			PIN_FUNC_SET(IO_MUX_GPIO22, FUNC_GPIO22_GPIO22);
+			return true;
+		case GPIO_NUM_23:
+			PIN_FUNC_SET(IO_MUX_GPIO23, FUNC_GPIO23_GPIO23);
+			return true;
+		case GPIO_NUM_24:
+			PIN_FUNC_SET(IO_MUX_GPIO24, FUNC_GPIO24_GPIO24);
+			return true;
+		case GPIO_NUM_25:
+			PIN_FUNC_SET(IO_MUX_GPIO25, FUNC_GPIO25_GPIO25);
+			return true;
+		default:
+			return false;
+	}
+}
+
+const char* HAL_PIN_GetPinNameAlias(int index)
+{
+	if(index >= g_numPins + 1)
+		return "error";
+	return g_pins[index].name;
+}
+
+int HAL_PIN_CanThisPinBePWM(int index)
+{
+	int ch = PIN_GetPWMIndexForPinIndex(index);
+	if(ch == -1) return 0;
+	return 1;
+}
+
+void HAL_PIN_SetOutputValue(int index, int iVal)
+{
+	if(index >= g_numPins)
+		return;
+	ecrPinMapping_t* pin = g_pins + index;
+	hal_gpio_write(pin->pin, iVal);
+}
+
+int HAL_PIN_ReadDigitalInput(int index)
+{
+	if(index >= g_numPins)
+		return 0;
+	ecrPinMapping_t* pin = g_pins + index;
+	return hal_gpio_read(pin->pin);
+}
+
+void HAL_PIN_Setup_Input_Pullup(int index)
+{
+	if(index >= g_numPins)
+		return;
+	ecrPinMapping_t* pin = g_pins + index;
+	if(HAL_PIN_Set_As_GPIO(pin->pin))
+	{
+		hal_gpio_dir_set(pin->pin, DRV_GPIO_ARG_DIR_IN);
+		hal_gpio_set_pull_mode(pin->pin, DRV_GPIO_ARG_PULL_UP);
+	}
+}
+
+void HAL_PIN_Setup_Input_Pulldown(int index)
+{
+	if(index >= g_numPins)
+		return;
+	ecrPinMapping_t* pin = g_pins + index;
+	if(HAL_PIN_Set_As_GPIO(pin->pin))
+	{
+		hal_gpio_dir_set(pin->pin, DRV_GPIO_ARG_DIR_IN);
+		hal_gpio_set_pull_mode(pin->pin, DRV_GPIO_ARG_PULL_DOWN);
+	}
+}
+
+void HAL_PIN_Setup_Input(int index)
+{
+	if(index >= g_numPins)
+		return;
+	ecrPinMapping_t* pin = g_pins + index;
+	if(HAL_PIN_Set_As_GPIO(pin->pin))
+	{
+		hal_gpio_dir_set(pin->pin, DRV_GPIO_ARG_DIR_IN);
+	}
+}
+
+void HAL_PIN_Setup_Output(int index)
+{
+	if(index >= g_numPins)
+		return;
+	ecrPinMapping_t* pin = g_pins + index;
+	if(HAL_PIN_Set_As_GPIO(pin->pin))
+	{
+		hal_gpio_dir_set(pin->pin, DRV_GPIO_ARG_DIR_OUT);
+		hal_gpio_set_pull_mode(pin->pin, DRV_GPIO_ARG_PULL_UP);
+	}
+}
+
+void ECR_SetPinAsPWM(int pin)
+{
+	switch(pin)
+	{
+		case 0:  chip_pwm_pinmux_cfg(PWM_CH0_USED_GPIO0);	break;
+		case 22: chip_pwm_pinmux_cfg(PWM_CH0_USED_GPIO22);	break;
+		case 1:  chip_pwm_pinmux_cfg(PWM_CH1_USED_GPIO1);	break;
+		case 23: chip_pwm_pinmux_cfg(PWM_CH1_USED_GPIO23);	break;
+		case 2:  chip_pwm_pinmux_cfg(PWM_CH2_USED_GPIO2);	break;
+		case 16: chip_pwm_pinmux_cfg(PWM_CH2_USED_GPIO16);	break;
+		case 24: chip_pwm_pinmux_cfg(PWM_CH2_USED_GPIO24);	break;
+		case 3:  chip_pwm_pinmux_cfg(PWM_CH3_USED_GPIO3);	break;
+		case 25: chip_pwm_pinmux_cfg(PWM_CH3_USED_GPIO25);	break;
+		case 4:  chip_pwm_pinmux_cfg(PWM_CH4_USED_GPIO4);	break;
+		case 14: chip_pwm_pinmux_cfg(PWM_CH4_USED_GPIO14);	break;
+		case 15: chip_pwm_pinmux_cfg(PWM_CH5_USED_GPIO15);	break;
+		case 17: chip_pwm_pinmux_cfg(PWM_CH5_USED_GPIO17);	break;
+		default: break;
+	}
+}
+
+void HAL_PIN_PWM_Stop(int index)
+{
+	if(index >= g_numPins)
+		return;
+	int ch = PIN_GetPWMIndexForPinIndex(index);
+	if(ch < 0) return;
+	drv_pwm_stop(ch);
+	drv_pwm_close(ch);
+	g_periods[ch] = 0;
+}
+
+void HAL_PIN_PWM_Start(int index, int freq)
+{
+	if(index >= g_numPins)
+		return;
+	int ch = PIN_GetPWMIndexForPinIndex(index);
+	if(ch < 0) return;
+	if(g_periods[ch] != 0)
+	{
+		ADDLOG_ERROR(LOG_FEATURE_PINS, "PWM Channel %i is already configured, stopping it!", ch);
+		drv_pwm_stop(ch);
+		drv_pwm_close(ch);
+	}
+	g_periods[ch] = (uint32_t)freq;
+	ECR_SetPinAsPWM(index);
+	drv_pwm_open(ch);
+	drv_pwm_start(ch);
+}
+
+void HAL_PIN_PWM_Update(int index, float value)
+{
+	if(index >= g_numPins)
+		return;
+	int ch = PIN_GetPWMIndexForPinIndex(index);
+	if(ch < 0) return;
+	if(value < 0)
+		value = 0;
+	if(value > 100)
+		value = 100;
+	drv_pwm_config(ch, g_periods[ch], (uint32_t)(value * 10));
+	drv_pwm_update(ch);
+}
+
+unsigned int HAL_GetGPIOPin(int index)
+{
+	return index;
+}
+
+#endif // PLATFORM_ECR6600
diff --git a/src/hal/ecr6600/hal_uart_ecr6600.c b/src/hal/ecr6600/hal_uart_ecr6600.c
new file mode 100644
index 000000000..09294d253
--- /dev/null
+++ b/src/hal/ecr6600/hal_uart_ecr6600.c
@@ -0,0 +1,63 @@
+#ifdef PLATFORM_ECR6600
+
+#include "../../new_pins.h"
+#include "../../new_cfg.h"
+#include "../hal_uart.h"
+#include "uart.h"
+#include "chip_pinmux.h"
+
+E_DRV_UART_NUM uart = E_UART_NUM_0;
+unsigned int uart_base;
+
+static void uart_cb(void* data)
+{
+	while(drv_uart_rx_tstc(uart_base))
+	{
+		if(drv_uart_rx_tstc(uart_base))
+		{
+			UART_AppendByteToReceiveRingBuffer(drv_uart_rx_getc(uart_base));
+		}
+	}
+}
+
+void HAL_UART_SendByte(byte b)
+{
+	drv_uart_send_poll(uart, &b, 1);
+}
+
+int HAL_UART_Init(int baud, int parity, bool hwflowc)
+{
+	drv_uart_close(uart);
+	T_DRV_UART_CONFIG config = 
+	{
+		.uart_baud_rate = baud,
+		.uart_data_bits = UART_DATA_BITS_8,
+		.uart_stop_bits = UART_STOP_BITS_1,
+		.uart_flow_ctrl = hwflowc == true ? UART_FLOW_CONTROL_ENABLE : UART_FLOW_CONTROL_DISABLE,
+		.uart_tx_mode = UART_TX_MODE_STREAM,
+		.uart_rx_mode = UART_RX_MODE_USER,
+	};
+	switch(parity)
+	{
+		case 1:  config.uart_parity_bit = UART_PARITY_BIT_ODD; break;
+		case 2:  config.uart_parity_bit = UART_PARITY_BIT_EVEN; break;
+		default: config.uart_parity_bit = UART_PARITY_BIT_NONE; break;
+	}
+	if(CFG_HasFlag(OBK_FLAG_USE_SECONDARY_UART))
+	{
+		uart = E_UART_NUM_1;
+		chip_uart1_pinmux_cfg(hwflowc);
+	}
+	else
+	{
+		chip_uart0_pinmux_cfg(UART0_RX_USED_GPIO5, UART0_TX_USED_GPIO6, hwflowc);
+	}
+	drv_uart_open(uart, &config);
+	T_UART_ISR_CALLBACK callback;
+	callback.uart_callback = uart_cb;
+	drv_uart_ioctrl(uart, DRV_UART_CTRL_REGISTER_RX_CALLBACK, &callback);
+	drv_uart_ioctrl(uart, DRV_UART_CTRL_GET_REG_BASE, (void*)(&uart_base));
+	return 1;
+}
+
+#endif
\ No newline at end of file
diff --git a/src/hal/ecr6600/hal_wifi_ecr6600.c b/src/hal/ecr6600/hal_wifi_ecr6600.c
new file mode 100644
index 000000000..bea2631df
--- /dev/null
+++ b/src/hal/ecr6600/hal_wifi_ecr6600.c
@@ -0,0 +1,235 @@
+#ifdef PLATFORM_ECR6600
+
+#include "../hal_wifi.h"
+#include "../hal_generic.h"
+#include "../../new_common.h"
+#include "../../new_cfg.h"
+#include "../../logging/logging.h"
+#include <lwip/sockets.h>
+#include <stdbool.h>
+#include <easyflash.h>
+#include "system_event.h"
+#include "system_wifi.h"
+#include "system_wifi_def.h"
+#include "psm_system.h"
+
+static void (*g_wifiStatusCallback)(int code) = NULL;
+extern system_event_cb_t s_event_handler_cb;
+uint8_t wmac[6] = { 0 };
+
+bool g_bStaticIP = false, mac_init = false;
+
+static struct ip_info if_ip;
+static int g_bOpenAccessPointMode = 0;
+
+const char* HAL_GetMyIPString()
+{
+	return ip4addr_ntoa(ip_2_ip4(&if_ip.ip));
+}
+
+const char* HAL_GetMyGatewayString()
+{
+	return ip4addr_ntoa(ip_2_ip4(&if_ip.gw));
+}
+
+const char* HAL_GetMyDNSString()
+{
+	return ip4addr_ntoa(ip_2_ip4(&if_ip.dns1));
+}
+
+const char* HAL_GetMyMaskString()
+{
+	return ip4addr_ntoa(ip_2_ip4(&if_ip.netmask));
+}
+
+int WiFI_SetMacAddress(char* mac)
+{
+	char macstr[18] = { 0 };
+	sprintf(macstr, MAC_STR, MAC_VALUE((uint8_t*)mac));
+	return !amt_set_env_blob("mac", &macstr, strlen(macstr));
+}
+
+void WiFI_GetMacAddress(char* mac)
+{
+	if(!mac_init)
+	{
+		wifi_get_mac_addr(0, wmac);
+		mac_init = true;
+	}
+	memcpy(mac, (char*)wmac, sizeof(wmac));
+}
+
+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);
+	// left align not working, mculib problem? But then tr6260 uses mculib too, and no such problem there.
+	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     : ["MAC_STR"] %-7s |\r\n", MAC_VALUE(mac), "");
+	ADDLOG_DEBUG(LOG_FEATURE_GENERAL, "+--------------------------------------------+\r\n");
+}
+
+int HAL_GetWifiStrength()
+{
+	wifi_info_t ap_info;
+	memset((void*)&ap_info, 0, sizeof(wifi_info_t));
+	wifi_get_wifi_info(&ap_info);
+	return ap_info.rssi;
+}
+
+static sys_err_t handle_wifi_event(void* ctx, system_event_t* event)
+{
+	switch(event->event_id)
+	{
+		case SYSTEM_EVENT_STA_START:
+		{
+			if(g_wifiStatusCallback != NULL)
+			{
+				g_wifiStatusCallback(WIFI_STA_CONNECTING);
+			}
+		}
+		case SYSTEM_EVENT_STA_CONNECTED: if(!g_bStaticIP) break;
+		case SYSTEM_EVENT_STA_GOT_IP:
+		{
+			if(g_wifiStatusCallback != NULL)
+			{
+				g_wifiStatusCallback(WIFI_STA_CONNECTED);
+			}
+			if(!g_bStaticIP) wifi_get_ip_info(STATION_IF, &if_ip);
+			//delay_ms(100);
+			//psm_set_device_status(PSM_DEVICE_WIFI_STA, PSM_DEVICE_STATUS_ACTIVE);
+			break;
+		}
+		case SYSTEM_EVENT_STA_LOST_IP:
+		case SYSTEM_EVENT_STA_DISCONNECTED:
+		{
+			if(g_wifiStatusCallback != NULL)
+			{
+				g_wifiStatusCallback(WIFI_STA_DISCONNECTED);
+			}
+			//HAL_DisconnectFromWifi();
+			//hal_lmac_reset_all();
+			//HAL_RebootModule();
+			break;
+		}
+		case SYSTEM_EVENT_STA_SAE_AUTH_FAIL:
+		case SYSTEM_EVENT_STA_4WAY_HS_FAIL:
+		{
+			if(g_wifiStatusCallback != NULL)
+			{
+				g_wifiStatusCallback(WIFI_STA_AUTH_FAILED);
+			}
+			break;
+		}
+		case SYSTEM_EVENT_AP_STACONNECTED:
+		{
+			if(g_wifiStatusCallback != NULL)
+			{
+				g_wifiStatusCallback(WIFI_AP_CONNECTED);
+			}
+			break;
+		}
+		default: break;
+	}
+
+	return SYS_OK;
+}
+
+void HAL_WiFi_SetupStatusCallback(void (*cb)(int code))
+{
+	printf("HAL_WiFi_SetupStatusCallback");
+	g_wifiStatusCallback = cb;
+	sys_event_loop_set_cb(handle_wifi_event, NULL);
+}
+
+void HAL_ConnectToWiFi(const char* oob_ssid, const char* connect_key, obkStaticIP_t* ip)
+{
+	g_bOpenAccessPointMode = 0;
+	wifi_set_opmode(WIFI_MODE_STA);
+	wifi_remove_config_all(STATION_IF);
+	wifi_remove_config_all(SOFTAP_IF);
+	wifi_add_config(STATION_IF);
+	wifi_config_ssid(STATION_IF, (unsigned char*)oob_ssid);
+	wifi_set_password(STATION_IF, (char*)connect_key);
+	wifi_config_commit(STATION_IF);
+	if(ip->localIPAddr[0] == 0)
+	{
+		g_bStaticIP = 0;
+	}
+	else
+	{
+		g_bStaticIP = 1;
+
+		IP_ADDR4(&if_ip.ip, ip->localIPAddr[0], ip->localIPAddr[1], ip->localIPAddr[2], ip->localIPAddr[3]);
+		IP_ADDR4(&if_ip.gw, ip->gatewayIPAddr[0], ip->gatewayIPAddr[1], ip->gatewayIPAddr[2], ip->gatewayIPAddr[3]);
+		IP_ADDR4(&if_ip.netmask, ip->netMask[0], ip->netMask[1], ip->netMask[2], ip->netMask[3]);
+		IP_ADDR4(&if_ip.dns1, ip->dnsServerIpAddr[0], ip->dnsServerIpAddr[1], ip->dnsServerIpAddr[2], ip->dnsServerIpAddr[3]);
+		set_sta_ipconfig(&if_ip);
+	}
+	wifi_set_status(STATION_IF, STA_STATUS_START);
+	struct netif* nif = NULL;
+	nif = get_netif_by_index(STATION_IF);
+	netif_set_hostname(nif, CFG_GetDeviceName());
+}
+
+void HAL_DisconnectFromWifi()
+{
+	wifi_disconnect();
+}
+
+int HAL_SetupWiFiOpenAccessPoint(const char* ssid)
+{
+	wifi_set_opmode(WIFI_MODE_AP_STA);
+	int channel = 1, ret;
+	wifi_config_u config;
+
+	memset(&config, 0, sizeof(config));
+	strlcpy((char*)config.ap.ssid, ssid, sizeof(config.ap.ssid));
+	config.ap.channel = channel;
+	config.ap.authmode = AUTH_OPEN;
+
+	while(!wifi_is_ready())
+	{
+		system_printf("wifi not ready!\n");
+		delay_ms(10);
+	}
+
+	ret = wifi_start_softap(&config);
+	if(SYS_OK != ret)
+	{
+		system_printf("HAL_SetupWiFiOpenAccessPoint failed, err: %d\n", ret);
+		if(g_wifiStatusCallback != NULL)
+		{
+			g_wifiStatusCallback(WIFI_AP_FAILED);
+		}
+		return ret;
+	}
+	memset(&if_ip, 0, sizeof(if_ip));
+	IP_ADDR4(&if_ip.ip, 192, 168, 4, 1);
+	IP_ADDR4(&if_ip.gw, 192, 168, 4, 1);
+	IP_ADDR4(&if_ip.netmask, 255, 255, 255, 0);
+	set_softap_ipconfig(&if_ip);
+
+	struct dhcps_lease dhcp_cfg_info;
+	dhcp_cfg_info.enable = true;
+	IP_ADDR4(&dhcp_cfg_info.start_ip, 192, 168, 4, 100);
+	IP_ADDR4(&dhcp_cfg_info.end_ip, 192, 168, 4, 150);
+
+	wifi_softap_set_dhcps_lease(&dhcp_cfg_info);
+	return 0;
+}
+
+#endif // PLATFORM_ECR6600
diff --git a/src/hal/generic/hal_pins_generic.c b/src/hal/generic/hal_pins_generic.c
index e09dc3dd2..2be202a39 100644
--- a/src/hal/generic/hal_pins_generic.c
+++ b/src/hal/generic/hal_pins_generic.c
@@ -54,7 +54,7 @@ void __attribute__((weak)) HAL_PIN_PWM_Stop(int index)
 	return;
 }
 
-void __attribute__((weak)) HAL_PIN_PWM_Start(int index)
+void __attribute__((weak)) HAL_PIN_PWM_Start(int index, int freq)
 {
 	return;
 }
diff --git a/src/httpserver/http_fns.c b/src/httpserver/http_fns.c
index 3cbca27f9..6f920ca0e 100644
--- a/src/httpserver/http_fns.c
+++ b/src/httpserver/http_fns.c
@@ -3121,6 +3121,13 @@ void OTA_RequestDownloadFromHTTP(const char* s) {
 #elif PLATFORM_ESPIDF
 #elif PLATFORM_TR6260
 #elif PLATFORM_REALTEK
+#elif PLATFORM_ECR6600
+	extern int http_client_download_file(const char* url, unsigned int len);
+	extern int ota_done(bool reset);
+	delay_ms(100);
+	int ret = http_client_download_file(s, strlen(s));
+	if(ret != -1) ota_done(1);
+	else ota_done(0);
 #elif PLATFORM_W600 || PLATFORM_W800
 	t_http_fwup(s);
 #elif PLATFORM_XR809
diff --git a/src/httpserver/new_tcp_server.c b/src/httpserver/new_tcp_server.c
index 8ec9f99bf..72d89d2ec 100644
--- a/src/httpserver/new_tcp_server.c
+++ b/src/httpserver/new_tcp_server.c
@@ -237,10 +237,12 @@ static void tcp_server_thread(beken_thread_arg_t arg)
 		{
 			sock[new_idx].fd = accept(listen_sock, (struct sockaddr*)&source_addr, &addr_len);
 
+#if LWIP_SO_RCVTIMEO && !PLATFORM_ECR6600
 			struct timeval tv;
 			tv.tv_sec = 30;
 			tv.tv_usec = 0;
 			setsockopt(sock[new_idx].fd, SOL_SOCKET, SO_RCVTIMEO, (const char*)&tv, sizeof(tv));
+#endif
 
 			if(sock[new_idx].fd < 0)
 			{
diff --git a/src/httpserver/rest_interface.c b/src/httpserver/rest_interface.c
index 94d3769c2..f302e4aee 100644
--- a/src/httpserver/rest_interface.c
+++ b/src/httpserver/rest_interface.c
@@ -103,6 +103,10 @@ extern uint32_t current_fw_idx;
 
 #endif
 
+#elif PLATFORM_ECR6600
+
+#include "flash.h"
+
 #else
 
 extern UINT32 flash_read(char* user_buf, UINT32 count, UINT32 address);
@@ -303,6 +307,8 @@ static int http_rest_post(http_request_t* request) {
 		return http_rest_post_flash(request, -1, -1);
 #elif PLATFORM_REALTEK
 		return http_rest_post_flash(request, 0, -1);
+#elif PLATFORM_ECR6600
+		return http_rest_post_flash(request, -1, -1);
 #else
 		// TODO
 		ADDLOG_DEBUG(LOG_FEATURE_API, "No OTA");
@@ -2865,6 +2871,66 @@ update_ota_exit:
 		return http_rest_error(request, ret, "error");
 	}
 
+#elif PLATFORM_ECR6600
+
+	extern int ota_init(void);
+	extern int ota_write(unsigned char* data, unsigned int len);
+	extern int ota_done(bool reset);
+	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;
+	}
+
+	if(ota_init() != 0)
+	{
+		ret = -1;
+		goto update_ota_exit;
+	}
+
+	do
+	{
+		if(ota_write((unsigned char*)writebuf, writelen) != 0)
+		{
+			ret = -1;
+			goto update_ota_exit;
+		}
+		delay_ms(10);
+		ADDLOG_DEBUG(LOG_FEATURE_OTA, "Writelen %i at %i", writelen, total);
+		total += writelen;
+		startaddr += writelen;
+		towrite -= writelen;
+		if(towrite > 0)
+		{
+			writebuf = request->received;
+			writelen = recv(request->fd, writebuf, request->receivedLenmax, 0);
+			if(writelen < 0)
+			{
+				ADDLOG_DEBUG(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");
+		ota_done(0);
+	}
+	else
+	{
+		ADDLOG_ERROR(LOG_FEATURE_OTA, "OTA failed. Reboot to retry");
+		return http_rest_error(request, ret, "error");
+	}
+
 #else
 
 	init_ota(startaddr);
@@ -2967,10 +3033,13 @@ static int http_rest_get_flash(http_request_t* request, int startaddr, int len)
 #elif PLATFORM_W600 || PLATFORM_W800
 		res = 0;
 #elif PLATFORM_LN882H
-		// TODO:LN882H flash read?
 		res = hal_flash_read(startaddr, readlen, (uint8_t *)buffer);
-#elif PLATFORM_ESPIDF || PLATFORM_TR6260
+#elif PLATFORM_ESPIDF
 		res = 0;
+#elif PLATFORM_TR6260
+		res = hal_spiflash_read(startaddr, (uint8_t*)buffer, readlen);
+#elif PLATFORM_ECR6600
+		res = drv_spiflash_read(startaddr, (uint8_t*)buffer, readlen);
 #elif PLATFORM_REALTEK
 		device_mutex_lock(RT_DEV_LOCK_FLASH);
 		flash_stream_read(&flash, startaddr, readlen, (uint8_t*)buffer);
diff --git a/src/littlefs/our_lfs.c b/src/littlefs/our_lfs.c
index 4c183d11e..f98d599f4 100644
--- a/src/littlefs/our_lfs.c
+++ b/src/littlefs/our_lfs.c
@@ -40,6 +40,10 @@ esp_partition_t* esplfs = NULL;
 #include "flash_api.h"
 #include "device_lock.h"
 
+#elif PLATFORM_ECR6600
+
+#include "flash.h"
+
 #endif
 
 
@@ -777,6 +781,52 @@ static int lfs_erase(const struct lfs_config* c, lfs_block_t block)
     return LFS_ERR_OK;
 }
 
+#elif PLATFORM_ECR6600
+
+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;
+
+    res = drv_spiflash_read(startAddr, (unsigned char*)buffer, size);
+    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;
+
+    res = drv_spiflash_write(startAddr, (unsigned char*)buffer, size);
+    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;
+
+    res = drv_spiflash_erase(startAddr, LFS_BLOCK_SIZE);
+    return res;
+}
+
 #endif 
 
 // Sync the state of the underlying block device. Negative error codes
diff --git a/src/littlefs/our_lfs.h b/src/littlefs/our_lfs.h
index bde392264..edc553076 100644
--- a/src/littlefs/our_lfs.h
+++ b/src/littlefs/our_lfs.h
@@ -98,6 +98,12 @@
 #define LFS_BLOCKS_START_MIN 0x3C6000
 #define LFS_BLOCKS_END 0x400000
 
+#elif PLATFORM_ECR6600
+
+#define LFS_BLOCKS_START 0x1D5000
+#define LFS_BLOCKS_START_MIN 0x1D5000
+#define LFS_BLOCKS_END 0x1D5000 + 0x22000
+
 #else
 // TODO
 // start 0x1000 after OTA addr
diff --git a/src/mqtt/new_mqtt.c b/src/mqtt/new_mqtt.c
index 8b30b620b..47e90ae4b 100644
--- a/src/mqtt/new_mqtt.c
+++ b/src/mqtt/new_mqtt.c
@@ -1753,7 +1753,7 @@ static BENCHMARK_TEST_INFO* info = NULL;
 #if WINDOWS
 
 #elif PLATFORM_BL602 || PLATFORM_W600 || PLATFORM_W800 || PLATFORM_ESPIDF || PLATFORM_TR6260 \
-	|| PLATFORM_REALTEK
+	|| PLATFORM_REALTEK || PLATFORM_ECR6600
 static void mqtt_timer_thread(void* param)
 {
 	while (1)
@@ -1794,7 +1794,7 @@ commandResult_t MQTT_StartMQTTTestThread(const void* context, const char* cmd, c
 #if WINDOWS
 
 #elif PLATFORM_BL602 || PLATFORM_W600 || PLATFORM_W800 || PLATFORM_ESPIDF || PLATFORM_TR6260 \
-	|| PLATFORM_REALTEK
+	|| PLATFORM_REALTEK || PLATFORM_ECR6600
 	xTaskCreate(mqtt_timer_thread, "mqtt", 1024, (void*)info, 15, NULL);
 #elif PLATFORM_XR809 || PLATFORM_LN882H
 	OS_TimerSetInvalid(&timer);
diff --git a/src/new_common.c b/src/new_common.c
index bc5ec9005..ea4bc5bf9 100644
--- a/src/new_common.c
+++ b/src/new_common.c
@@ -112,7 +112,7 @@ const char* strcasestr(const char* str1, const char* str2)
 // where is buffer with [64] bytes?
 // 2022-11-02 update: It was also causing crash on OpenBL602. Original strdup was crashing while my strdup works.
 // Let's just rename test_strdup to strdup and let it be our main correct strdup
-#if !defined(PLATFORM_W600) && !defined(PLATFORM_W800) && !defined(WINDOWS)
+#if !defined(PLATFORM_W600) && !defined(PLATFORM_W800) && !defined(WINDOWS) && !defined(PLATFORM_ECR6600)
 // W600 and W800 already seem to have a strdup?
 char *strdup(const char *s)
 {
diff --git a/src/new_common.h b/src/new_common.h
index c28bbcbca..e9fcdb650 100644
--- a/src/new_common.h
+++ b/src/new_common.h
@@ -135,6 +135,11 @@ typedef long BaseType_t;
 #define DEVICENAME_PREFIX_SHORT "rtl8720d"
 #define PLATFORM_MCU_NAME "RTL8720D"
 #define MANUFACTURER "Realtek"
+#elif PLATFORM_ECR6600
+#define DEVICENAME_PREFIX_FULL "OpenECR6600"
+#define DEVICENAME_PREFIX_SHORT "ecr6600"
+#define PLATFORM_MCU_NAME "ECR6600"
+#define MANUFACTURER "ESWIN"
 #else
 #error "You must define a platform.."
 This platform is not supported, error!
@@ -174,6 +179,8 @@ This platform is not supported, error!
 #define USER_SW_VER "RTL8720D_Test"
 #elif defined(PLATFORM_BK7238)
 #define USER_SW_VER "BK7238_Test"
+#elif PLATFORM_ECR6600
+#define USER_SW_VER "ECR6600_Test"
 #else
 #define USER_SW_VER "unknown"
 #endif
@@ -617,6 +624,62 @@ OSStatus rtos_suspend_thread(beken_thread_t* thread);
 #define GLOBAL_INT_DISABLE()		;
 #define GLOBAL_INT_RESTORE()		;
 
+#elif PLATFORM_ECR6600
+
+#include "FreeRTOS.h"
+#include "task.h"
+#include "semphr.h"
+#include "queue.h"
+#include "event_groups.h"
+
+#include "lwip/err.h"
+#include "lwip/sockets.h"
+#include "lwip/sys.h"
+#include "lwip/netdb.h"
+#include "lwip/dns.h"
+#include <stdbool.h>
+#include "os/oshal.h"
+
+typedef unsigned int UINT32;
+
+#define ASSERT
+#undef os_malloc
+#undef os_free
+#define os_malloc	pvPortMalloc
+#define os_free		vPortFree
+#define malloc		os_malloc
+#define free		os_free
+#define calloc		os_calloc
+#define realloc		os_realloc
+#define memmove		os_memmove
+#define os_strcpy	strcpy
+
+#define bk_printf printf
+
+extern void sys_delay_ms(uint32_t ms);
+// OS_MSleep?
+#define rtos_delay_milliseconds sys_delay_ms
+#define delay_ms sys_delay_ms
+
+#define kNoErr                      0       //! No error occurred.
+typedef void* beken_thread_arg_t;
+typedef void* beken_thread_t;
+typedef void (*beken_thread_function_t)(beken_thread_arg_t arg);
+typedef int OSStatus;
+
+#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
 
@@ -674,6 +737,7 @@ typedef unsigned char byte;
 #else
 
 int wal_stricmp(const char *a, const char *b) ;
+#undef stricmp
 #define stricmp wal_stricmp
 char *strdup(const char *s);
 
@@ -689,7 +753,7 @@ int strcpy_safe_checkForChanges(char *tg, const char *src, int tgMaxLen);
 void urldecode2_safe(char *dst, const char *srcin, int maxDstLen);
 int strIsInteger(const char *s);
 
-#if !defined(PLATFORM_ESPIDF) && !defined(PLATFORM_TR6260)
+#if !defined(PLATFORM_ESPIDF) && !defined(PLATFORM_TR6260) && !defined(PLATFORM_ECR6600)
 const char* strcasestr(const char* str1, const char* str2);
 #endif
 
@@ -746,7 +810,7 @@ typedef enum
     EXCELLENT,
 } WIFI_RSSI_LEVEL;
 
-#if PLATFORM_LN882H || PLATFORM_REALTEK
+#if PLATFORM_LN882H || PLATFORM_REALTEK || PLATFORM_ECR6600
 #define IP_STRING_FORMAT	"%u.%u.%u.%u"
 #else
 #define IP_STRING_FORMAT	"%hhu.%hhu.%hhu.%hhu"
diff --git a/src/new_pins.h b/src/new_pins.h
index 3e3621e8c..b7990c8a7 100644
--- a/src/new_pins.h
+++ b/src/new_pins.h
@@ -1040,6 +1040,8 @@ typedef enum channelType_e {
 #define PLATFORM_GPIO_MAX 20
 #elif PLATFORM_RTL8720D
 #define PLATFORM_GPIO_MAX 64
+#elif PLATFORM_ECR6600
+#define PLATFORM_GPIO_MAX 27
 #else
 #define PLATFORM_GPIO_MAX 29
 #endif
diff --git a/src/obk_config.h b/src/obk_config.h
index ef31ea524..94b44f00c 100644
--- a/src/obk_config.h
+++ b/src/obk_config.h
@@ -358,6 +358,33 @@
 #define ENABLE_ADVANCED_CHANNELTYPES_DISCOVERY	1
 #define ENABLE_DRIVER_SSDP						1
 
+#elif PLATFORM_ECR6600
+
+#define	ENABLE_HA_DISCOVERY						1
+#define ENABLE_MQTT								1
+#define ENABLE_LITTLEFS							1
+#define NEW_TCP_SERVER							1
+#define ENABLE_EXPAND_CONSTANT					1
+#define ENABLE_I2C								1
+#define ENABLE_DRIVER_AHT2X						1
+#define ENABLE_DRIVER_BMPI2C					1
+#define ENABLE_DRIVER_DS1820					1
+#define ENABLE_DRIVER_DHT						1
+#define ENABLE_DRIVER_LED 						1
+#define ENABLE_DRIVER_WEMO						1
+#define ENABLE_DRIVER_SSDP						1
+#define ENABLE_OBK_SCRIPTING					1
+#define ENABLE_ADVANCED_CHANNELTYPES_DISCOVERY	1
+#define ENABLE_DRIVER_SSDP						1
+#define ENABLE_TASMOTA_JSON						1
+#define ENABLE_TASMOTADEVICEGROUPS				1
+#define ENABLE_NTP								1
+#define ENABLE_CALENDAR_EVENTS					1
+#define ENABLE_DRIVER_TUYAMCU					1
+#define ENABLE_DRIVER_BL0942					1
+
+#define OBK_OTA_EXTENSION 						".img"
+
 #else
 
 //#error "Platform not defined"
diff --git a/src/user_main.c b/src/user_main.c
index 6223807c4..846aa1ba2 100644
--- a/src/user_main.c
+++ b/src/user_main.c
@@ -61,6 +61,8 @@ void bg_register_irda_check_func(FUNCPTR func);
 #include "hal/hal_gpio.h"
 #elif PLATFORM_ESPIDF
 #include "esp_timer.h"
+#elif PLATFORM_ECR6600
+#include "hal_adc.h"
 #endif
 
 int g_secondsElapsed = 0;
@@ -216,7 +218,7 @@ int LWIP_GetActiveSockets() {
 #endif
 
 #if defined(PLATFORM_BL602) || defined(PLATFORM_W800) || defined(PLATFORM_W600) || defined(PLATFORM_LN882H) \
-	|| defined(PLATFORM_ESPIDF) || defined(PLATFORM_TR6260) || defined(PLATFORM_REALTEK)
+	|| defined(PLATFORM_ESPIDF) || defined(PLATFORM_TR6260) || defined(PLATFORM_REALTEK) || defined(PLATFORM_ECR6600)
 
 OSStatus rtos_create_thread(beken_thread_t* thread,
 	uint8_t priority, const char* name,
@@ -601,6 +603,8 @@ void Main_OnEverySecond()
 		// this is set externally, I am just leaving comment here
 #elif PLATFORM_W800 || PLATFORM_W600
 		g_wifi_temperature = HAL_ADC_Temp();
+#elif PLATFORM_ECR6600
+		g_wifi_temperature = hal_adc_tempsensor();
 #endif
 	}
 
@@ -1026,7 +1030,7 @@ void QuickTick(void* param)
 // this is the bit which runs the quick tick timer
 #if WINDOWS
 
-#elif PLATFORM_BL602 || PLATFORM_W600 || PLATFORM_W800 || PLATFORM_TR6260 || defined(PLATFORM_REALTEK)
+#elif PLATFORM_BL602 || PLATFORM_W600 || PLATFORM_W800 || PLATFORM_TR6260 || defined(PLATFORM_REALTEK) || PLATFORM_ECR6600
 void quick_timer_thread(void* param)
 {
 	while (1) {
@@ -1045,7 +1049,7 @@ void QuickTick_StartThread(void)
 {
 #if WINDOWS
 
-#elif PLATFORM_BL602 || PLATFORM_W600 || PLATFORM_W800 || PLATFORM_TR6260 || defined(PLATFORM_REALTEK)
+#elif PLATFORM_BL602 || PLATFORM_W600 || PLATFORM_W800 || PLATFORM_TR6260 || defined(PLATFORM_REALTEK) || PLATFORM_ECR6600
 	xTaskCreate(quick_timer_thread, "quick", 1024, NULL, 15, NULL);
 #elif PLATFORM_ESPIDF
 	const esp_timer_create_args_t g_quick_timer_args =