diff --git a/.github/workflows/workflow.yaml b/.github/workflows/workflow.yaml index 959a1b737..bebf5c994 100644 --- a/.github/workflows/workflow.yaml +++ b/.github/workflows/workflow.yaml @@ -110,7 +110,7 @@ jobs: strategy: fail-fast: false matrix: - platform: [OpenBK7231T, OpenBK7231N, OpenXR809, OpenBL602, OpenW800, OpenW600, OpenLN882H] + platform: [OpenBK7231T, OpenBK7231N, OpenXR809, OpenBL602, OpenW800, OpenW600, OpenLN882H, OpenTR6260] steps: - name: Source checkout uses: actions/checkout@v3 diff --git a/.gitmodules b/.gitmodules index 7bafa7abd..ea1fc5f66 100644 --- a/.gitmodules +++ b/.gitmodules @@ -29,3 +29,7 @@ path = sdk/esp-idf url = https://github.com/espressif/esp-idf.git branch = release/v5.3 +[submodule "sdk/OpenTR6260"] + path = sdk/OpenTR6260 + url = https://github.com/NonPIayerCharacter/OpenTR6260.git + branch = master diff --git a/Makefile b/Makefile index bf0577e36..53ea7dce3 100644 --- a/Makefile +++ b/Makefile @@ -74,7 +74,8 @@ sdk/OpenLN882H/project/OpenBeken/app: @mkdir -p "sdk/OpenLN882H/project/OpenBeken" ln -s "$(shell pwd)/" "sdk/OpenLN882H/project/OpenBeken/app" -.PHONY: prebuild_OpenBK7231N prebuild_OpenBK7231T prebuild_OpenBL602 prebuild_OpenLN882H prebuild_OpenW600 prebuild_OpenW800 prebuild_OpenXR809 prebuild_ESPIDF +.PHONY: prebuild_OpenBK7231N prebuild_OpenBK7231T prebuild_OpenBL602 prebuild_OpenLN882H +.PHONY: prebuild_OpenW600 prebuild_OpenW800 prebuild_OpenXR809 prebuild_ESPIDF prebuild_OpenTR6260 prebuild_OpenBK7231N: @if [ -e platforms/BK7231N/pre_build.sh ]; then \ @@ -132,6 +133,13 @@ prebuild_ESPIDF: else echo "prebuild for ESP-IDF not found ... "; \ fi +prebuild_OpenTR6260: + @if [ -e platforms/TR6260/pre_build.sh ]; then \ + echo "prebuild found for TR6260"; \ + sh platforms/TR6260/pre_build.sh; \ + else echo "prebuild for TR6260 not found ... "; \ + fi + # Build main binaries OpenBK7231T: prebuild_OpenBK7231T $(MAKE) APP_NAME=OpenBK7231T TARGET_PLATFORM=bk7231t SDK_PATH=sdk/OpenBK7231T APPS_BUILD_PATH=../bk7231t_os build-BK7231 @@ -258,6 +266,13 @@ OpenESP32S3: prebuild_ESPIDF mkdir -p output/$(APP_VERSION) esptool.py -c esp32s3 merge_bin -o output/$(APP_VERSION)/OpenESP32S3_$(APP_VERSION).factory.bin --flash_mode dio --flash_size 4MB 0x0 ./platforms/ESP-IDF/build-s3/bootloader/bootloader.bin 0x8000 ./platforms/ESP-IDF/build-s3/partition_table/partition-table.bin 0x10000 ./platforms/ESP-IDF/build-s3/OpenBeken.bin cp ./platforms/ESP-IDF/build-s3/OpenBeken.bin output/$(APP_VERSION)/OpenESP32S3_$(APP_VERSION).img + +.PHONY: OpenTR6260 +OpenTR6260: prebuild_OpenTR6260 + if [ ! -e sdk/OpenTR6260/toolchain/nds32le-elf-mculib-v3 ]; then cd sdk/OpenTR6260/toolchain && xz -d < nds32le-elf-mculib-v3.txz | tar xvf - > /dev/null; fi + cd sdk/OpenTR6260/scripts && APP_VERSION=$(APP_VERSION) bash build_tr6260s1.sh + mkdir -p output/$(APP_VERSION) + cp sdk/OpenTR6260/out/tr6260s1/standalone/tr6260s1_0x007000.bin output/$(APP_VERSION)/OpenTR6260_$(APP_VERSION).bin # clean .o files and output directory .PHONY: clean @@ -268,6 +283,7 @@ clean: $(MAKE) -C sdk/OpenXR809/project/oxr_sharedApp/gcc clean $(MAKE) -C sdk/OpenW800 clean $(MAKE) -C sdk/OpenW600 clean + $(MAKE) -C sdk/OpenTR6260/scripts tr6260s1_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 diff --git a/platforms/TR6260/openbeken.mk b/platforms/TR6260/openbeken.mk new file mode 100644 index 000000000..1160d5488 --- /dev/null +++ b/platforms/TR6260/openbeken.mk @@ -0,0 +1,129 @@ +VPATH += $(OBK_PATH) +DEFINE += -DUSER_SW_VER='"$(APP_VERSION)"' +DEFINE += -DPLATFORM_TR6260 + +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/tr6260/hal_adc_tr6260.c +CSRCS += hal/tr6260/hal_flashConfig_tr6260.c +CSRCS += hal/tr6260/hal_flashVars_tr6260.c +CSRCS += hal/tr6260/hal_generic_tr6260.c +CSRCS += hal/tr6260/hal_main_tr6260.c +CSRCS += hal/tr6260/hal_pins_tr6260.c +CSRCS += hal/tr6260/hal_wifi_tr6260.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 += 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/sdk/OpenTR6260 b/sdk/OpenTR6260 new file mode 160000 index 000000000..9deb1e557 --- /dev/null +++ b/sdk/OpenTR6260 @@ -0,0 +1 @@ +Subproject commit 9deb1e55774c5c967c1286b2e3ea862273d97d49 diff --git a/src/cmnds/cmd_main.c b/src/cmnds/cmd_main.c index 5429785b4..df08b17f3 100644 --- a/src/cmnds/cmd_main.c +++ b/src/cmnds/cmd_main.c @@ -293,7 +293,7 @@ static commandResult_t CMD_ClearAll(const void* context, const char* cmd, const CHANNEL_ClearAllChannels(); CMD_ClearAllHandlers(0, 0, 0, 0); RepeatingEvents_Cmd_ClearRepeatingEvents(0, 0, 0, 0); -#if defined(WINDOWS) || defined(PLATFORM_BL602) || defined(PLATFORM_BEKEN) || defined(PLATFORM_LN882H) +#if defined(WINDOWS) || defined(PLATFORM_BL602) || defined(PLATFORM_BEKEN) || defined(PLATFORM_LN882H) || defined(PLATFORM_TR6260) CMD_resetSVM(0, 0, 0, 0); #endif @@ -855,7 +855,7 @@ void CMD_Init_Early() { CMD_RegisterCommand("IndexRefreshInterval", CMD_IndexRefreshInterval, NULL); -#if (defined WINDOWS) || (defined PLATFORM_BEKEN) || (defined PLATFORM_BL602) || (defined PLATFORM_LN882H) || (defined PLATFORM_ESPIDF) +#if (defined WINDOWS) || (defined PLATFORM_BEKEN) || (defined PLATFORM_BL602) || (defined PLATFORM_LN882H) || (defined PLATFORM_ESPIDF) || defined(PLATFORM_TR6260) CMD_InitScripting(); #endif if (!bSafeMode) { diff --git a/src/driver/drv_ds1820_simple.c b/src/driver/drv_ds1820_simple.c index ea33465df..547684e68 100644 --- a/src/driver/drv_ds1820_simple.c +++ b/src/driver/drv_ds1820_simple.c @@ -87,6 +87,8 @@ void usleepds(int r) usleep(5 * r); // "5" seems o.k #elif PLATFORM_ESPIDF usleep(r); +#elif PLATFORM_TR6260 + usdelay(r); #else for(volatile int i = 0; i < r; i++) { diff --git a/src/hal/tr6260/hal_adc_tr6260.c b/src/hal/tr6260/hal_adc_tr6260.c new file mode 100644 index 000000000..8fbe8b12f --- /dev/null +++ b/src/hal/tr6260/hal_adc_tr6260.c @@ -0,0 +1,15 @@ +#ifdef PLATFORM_TR6260 + +#include "../hal_adc.h" + +void HAL_ADC_Init(int pinNumber) +{ + +} + +int HAL_ADC_Read(int pinNumber) +{ + +} + +#endif // PLATFORM_TR6260 diff --git a/src/hal/tr6260/hal_flashConfig_tr6260.c b/src/hal/tr6260/hal_flashConfig_tr6260.c new file mode 100644 index 000000000..20ae7acaa --- /dev/null +++ b/src/hal/tr6260/hal_flashConfig_tr6260.c @@ -0,0 +1,18 @@ +#ifdef PLATFORM_TR6260 + +#include "../hal_flashConfig.h" +#include + +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_TR6260 diff --git a/src/hal/tr6260/hal_flashVars_tr6260.c b/src/hal/tr6260/hal_flashVars_tr6260.c new file mode 100644 index 000000000..6899ef8d3 --- /dev/null +++ b/src/hal/tr6260/hal_flashVars_tr6260.c @@ -0,0 +1,178 @@ +#ifdef PLATFORM_TR6260 + +#include "../../new_common.h" +#include "../hal_flashVars.h" +#include "../../logging/logging.h" + +FLASH_VARS_STRUCTURE flash_vars; +static int flash_vars_init_flag = 0; +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++; \ + } + +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_TR6260 + diff --git a/src/hal/tr6260/hal_generic_tr6260.c b/src/hal/tr6260/hal_generic_tr6260.c new file mode 100644 index 000000000..a3c547c1e --- /dev/null +++ b/src/hal/tr6260/hal_generic_tr6260.c @@ -0,0 +1,8 @@ +#ifdef PLATFORM_TR6260 + +void HAL_RebootModule() +{ + wdt_reset_chip(0); +} + +#endif // PLATFORM_TR6260 \ No newline at end of file diff --git a/src/hal/tr6260/hal_main_tr6260.c b/src/hal/tr6260/hal_main_tr6260.c new file mode 100644 index 000000000..bfdcd2925 --- /dev/null +++ b/src/hal/tr6260/hal_main_tr6260.c @@ -0,0 +1,7 @@ +#ifdef PLATFORM_TR6260 + +#include "../../new_common.h" +#include "../../logging/logging.h" +#include "../../quicktick.h" + +#endif // PLATFORM_TR6260 \ No newline at end of file diff --git a/src/hal/tr6260/hal_pins_tr6260.c b/src/hal/tr6260/hal_pins_tr6260.c new file mode 100644 index 000000000..388211ef4 --- /dev/null +++ b/src/hal/tr6260/hal_pins_tr6260.c @@ -0,0 +1,288 @@ +#ifdef PLATFORM_TR6260 + +#include "../../new_common.h" +#include "../../logging/logging.h" +#include "../../new_cfg.h" +#include "../../new_pins.h" +#include "drv_gpio.h" +#include "drv_pwm.h" +#include "soc_pin_mux.h" + +extern int g_pwmFrequency; + +typedef struct trPinMapping_s +{ + const char* name; + DRV_GPIO_PIN_NAME pin; +} trPinMapping_t; + +trPinMapping_t g_pins[] = { + { "GPIO0", DRV_GPIO_0 }, + { "GPIO1", DRV_GPIO_1 }, + { "GPIO2", DRV_GPIO_2 }, + { "GPIO3", DRV_GPIO_3 }, + { "GPIO4", DRV_GPIO_4 }, + { "GPIO5 (RX0)", DRV_GPIO_5 }, + { "GPIO6 (TX0)", DRV_GPIO_6 }, + { "GPIO7", DRV_GPIO_7 }, + { "GPIO8", DRV_GPIO_8 }, + { "GPIO9", DRV_GPIO_9 }, + { "GPIO10", DRV_GPIO_10 }, + { "GPIO11", DRV_GPIO_11 }, + { "GPIO12", DRV_GPIO_12 }, + { "GPIO13 (PWM5)", DRV_GPIO_13 }, + { "GPIO14", DRV_GPIO_14 }, + { "GPIO15", DRV_GPIO_15 }, + { "GPIO16", DRV_GPIO_16 }, + { "GPIO17", DRV_GPIO_17 }, + { "GPIO18", DRV_GPIO_18 }, + { "GPIO19", DRV_GPIO_19 }, + { "GPIO20 (PWM0)", DRV_GPIO_20 }, + { "GPIO21 (PWM1)", DRV_GPIO_21 }, + { "GPIO22 (PWM2)", DRV_GPIO_22 }, +#if defined (_USR_TR6260) + { "GPIO23 (PWM3)", DRV_GPIO_23 }, + { "GPIO24 (PWM4)", DRV_GPIO_24 }, +#else + { "GPIO23", DRV_GPIO_23 }, + { "GPIO24", DRV_GPIO_24 }, +#endif +}; + +static int g_numPins = sizeof(g_pins) / sizeof(g_pins[0]); + +int PIN_GetPWMIndexForPinIndex(int pin) +{ + switch(pin) + { + case 13: return PMW_CHANNEL_5; + case 20: return PMW_CHANNEL_0; + case 21: return PMW_CHANNEL_1; + case 22: return PMW_CHANNEL_2; +#if defined (_USR_TR6260) + case 23: return PMW_CHANNEL_3; + case 24: return PMW_CHANNEL_4; +#endif + default: return -1; + } +} + +void HAL_PIN_Set_As_GPIO(DRV_GPIO_PIN_NAME pin) +{ + switch(pin) + { + case DRV_GPIO_0: + PIN_FUNC_SET(IO_MUX0_GPIO0, FUNC_GPIO0_GPIO0); + break; + case DRV_GPIO_1: + PIN_FUNC_SET(IO_MUX0_GPIO1, FUNC_GPIO1_GPIO1); + break; + case DRV_GPIO_2: + PIN_FUNC_SET(IO_MUX0_GPIO2, FUNC_GPIO2_GPIO2); + break; + case DRV_GPIO_3: + PIN_FUNC_SET(IO_MUX0_GPIO3, FUNC_GPIO3_GPIO3); + break; + case DRV_GPIO_4: + PIN_FUNC_SET(IO_MUX0_GPIO4, FUNC_GPIO4_GPIO4); + break; + case DRV_GPIO_5: + PIN_FUNC_SET(IO_MUX0_GPIO5, FUNC_GPIO5_GPIO5); + break; + case DRV_GPIO_6: + PIN_FUNC_SET(IO_MUX0_GPIO6, FUNC_GPIO6_GPIO6); + break; + case DRV_GPIO_7: +#ifndef _USR_TR6260S1 + PIN_FUNC_SET(IO_MUX0_GPIO7, FUNC_GPIO7_GPIO7); + break; + case DRV_GPIO_8: + PIN_FUNC_SET(IO_MUX0_GPIO8, FUNC_GPIO8_GPIO8); + break; + case DRV_GPIO_9: + PIN_FUNC_SET(IO_MUX0_GPIO9, FUNC_GPIO9_GPIO9); + break; + case DRV_GPIO_10: + PIN_FUNC_SET(IO_MUX0_GPIO10, FUNC_GPIO10_GPIO10); + break; + case DRV_GPIO_11: + PIN_FUNC_SET(IO_MUX0_GPIO11, FUNC_GPIO11_GPIO11); + break; + case DRV_GPIO_12: + PIN_FUNC_SET(IO_MUX0_GPIO12, FUNC_GPIO12_GPIO12); +#endif + break; + case DRV_GPIO_13: /*don't use in gpio mode*/ + //PIN_FUNC_SET(IO_MUX0_GPIO13, FUNC_GPIO13_GPIO13); + break; + case DRV_GPIO_14: + PIN_FUNC_SET(IO_MUX0_GPIO14, FUNC_GPIO14_GPIO14); + break; + case DRV_GPIO_15: + PIN_FUNC_SET(IO_MUX0_GPIO15, FUNC_GPIO15_GPIO15); + break; + case DRV_GPIO_16: /*don't use in gpio mode*/ + break; + case DRV_GPIO_17: /*don't use in gpio mode*/ + break; +#ifndef _USR_TR6260S1 + case DRV_GPIO_18: + PIN_FUNC_SET(IO_MUX0_GPIO18, FUNC_GPIO18_GPIO18); + break; + case DRV_GPIO_19: + PIN_FUNC_SET(IO_MUX0_GPIO19, FUNC_GPIO19_GPIO19); +#endif + break; + case DRV_GPIO_20: + PIN_FUNC_SET(IO_MUX0_GPIO20, FUNC_GPIO20_GPIO20); + break; + case DRV_GPIO_21: + PIN_FUNC_SET(IO_MUX0_GPIO21, FUNC_GPIO21_GPIO21); + break; + case DRV_GPIO_22: + PIN_FUNC_SET(IO_MUX0_GPIO22, FUNC_GPIO22_GPIO22); + break; + case DRV_GPIO_23: +#ifndef _USR_TR6260S1 + PIN_FUNC_SET(IO_MUX0_GPIO23, FUNC_GPIO23_GPIO23); + break; + case DRV_GPIO_24: + PIN_FUNC_SET(IO_MUX0_GPIO24, FUNC_GPIO24_GPIO24); +#endif + break; + default: + break; + } +} + +const char* HAL_PIN_GetPinNameAlias(int index) +{ + if(index >= g_numPins) + 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; + trPinMapping_t* pin = g_pins + index; + gpio_write(pin->pin, iVal); +} + +int HAL_PIN_ReadDigitalInput(int index) +{ + if(index >= g_numPins) + return 0; + trPinMapping_t* pin = g_pins + index; + //return gpio_read_level(pin->pin); + int value = -1; + gpio_read(pin->pin, &value); + return value; +} + +void HAL_PIN_Setup_Input_Pullup(int index) +{ + if(index >= g_numPins) + return; + trPinMapping_t* pin = g_pins + index; + HAL_PIN_Set_As_GPIO(pin->pin); + DRV_GPIO_CONFIG gpioCfg; + gpioCfg.GPIO_Pin = pin->pin; + gpioCfg.GPIO_PullEn = DRV_GPIO_PULL_EN; + gpioCfg.GPIO_Dir = DRV_GPIO_DIR_INPUT; + gpioCfg.GPIO_PullType = DRV_GPIO_PULL_TYPE_UP; + gpio_config(&gpioCfg); + //gpio_set_dir(pin->pin, DRV_GPIO_DIR_INPUT); +} + +void HAL_PIN_Setup_Input_Pulldown(int index) +{ + if(index >= g_numPins) + return; + trPinMapping_t* pin = g_pins + index; + HAL_PIN_Set_As_GPIO(pin->pin); + DRV_GPIO_CONFIG gpioCfg; + gpioCfg.GPIO_Pin = pin->pin; + gpioCfg.GPIO_PullEn = DRV_GPIO_PULL_EN; + gpioCfg.GPIO_Dir = DRV_GPIO_DIR_INPUT; + gpioCfg.GPIO_PullType = DRV_GPIO_PULL_TYPE_DOWN; + gpio_config(&gpioCfg); + //gpio_set_dir(pin->pin, DRV_GPIO_DIR_INPUT); +} + +void HAL_PIN_Setup_Input(int index) +{ + if(index >= g_numPins) + return; + trPinMapping_t* pin = g_pins + index; + HAL_PIN_Set_As_GPIO(pin->pin); + DRV_GPIO_CONFIG gpioCfg; + gpioCfg.GPIO_Pin = pin->pin; + gpioCfg.GPIO_PullEn = DRV_GPIO_PULL_DIS; + gpioCfg.GPIO_Dir = DRV_GPIO_DIR_INPUT; + gpio_config(&gpioCfg); + //gpio_set_dir(pin->pin, DRV_GPIO_DIR_INPUT); +} + +void HAL_PIN_Setup_Output(int index) +{ + if(index >= g_numPins) + return; + trPinMapping_t* pin = g_pins + index; + HAL_PIN_Set_As_GPIO(pin->pin); + DRV_GPIO_CONFIG gpioCfg; + gpioCfg.GPIO_Pin = pin->pin; + gpioCfg.GPIO_PullEn = DRV_GPIO_PULL_EN; + gpioCfg.GPIO_Dir = DRV_GPIO_DIR_OUTPUT; + gpioCfg.GPIO_PullType = DRV_GPIO_PULL_TYPE_UP; + gpio_config(&gpioCfg); + //gpio_set_dir(pin->pin, DRV_GPIO_DIR_OUTPUT); +} + +void HAL_PIN_PWM_Stop(int index) +{ + if(index >= g_numPins) + return; + int ch = PIN_GetPWMIndexForPinIndex(index); + if(ch < 0) return; + pwm_stop(ch); + pwm_deinit(ch); +} + +void HAL_PIN_PWM_Start(int index) +{ + if(index >= g_numPins) + return; + int ch = PIN_GetPWMIndexForPinIndex(index); + if(ch < 0) return; + pwm_init(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; + pwm_config(ch, g_pwmFrequency, (uint32_t)(value * 10)); + pwm_start(ch); +} + +unsigned int HAL_GetGPIOPin(int index) +{ + return index; +} + +#endif // PLATFORM_TR6260 diff --git a/src/hal/tr6260/hal_wifi_tr6260.c b/src/hal/tr6260/hal_wifi_tr6260.c new file mode 100644 index 000000000..255934dbd --- /dev/null +++ b/src/hal/tr6260/hal_wifi_tr6260.c @@ -0,0 +1,223 @@ +#ifdef PLATFORM_TR6260 + +#include "../hal_wifi.h" +#include "../../new_common.h" +#include +#include +#include "system_event.h" +#include "system_wifi.h" +#include "system_wifi_def.h" + +static void (*g_wifiStatusCallback)(int code) = NULL; +extern system_event_cb_t s_event_handler_cb; + +bool g_STA_static_IP = 0; + +static struct ip_info if_ip; +static int g_bOpenAccessPointMode = 0; + +const char* HAL_GetMyIPString() +{ + return ipaddr_ntoa(&if_ip.ip); +} + +const char* HAL_GetMyGatewayString() +{ + return ipaddr_ntoa(&if_ip.gw); +} + +const char* HAL_GetMyDNSString() +{ + return ipaddr_ntoa(&if_ip.dns1); +} + +const char* HAL_GetMyMaskString() +{ + return ipaddr_ntoa(&if_ip.netmask); +} + +int WiFI_SetMacAddress(char* mac) +{ + printf("WiFI_SetMacAddress"); + return 0; // error +} + +void WiFI_GetMacAddress(char* mac) +{ + get_netif_mac(STATION_IF, mac); +} + +const char* HAL_GetMACStr(char* macstr) +{ + printf("HAL_GetMACStr"); + unsigned char mac[6]; + get_netif_mac(STATION_IF, mac); + sprintf(macstr, MACSTR, MAC2STR(mac)); + return macstr; +} + +void HAL_PrintNetworkInfo() +{ + uint8_t mac[6]; + WiFI_GetMacAddress(mac); + bk_printf("+--------------- net device info ------------+\r\n"); + bk_printf("|netif type : %-16s |\r\n", g_bOpenAccessPointMode == 0 ? "STA" : "AP"); + bk_printf("|netif ip = %-16s |\r\n", HAL_GetMyIPString()); + bk_printf("|netif mask = %-16s |\r\n", HAL_GetMyMaskString()); + bk_printf("|netif gateway = %-16s |\r\n", HAL_GetMyGatewayString()); + bk_printf("|netif mac : [%02X:%02X:%02X:%02X:%02X:%02X] %-7s |\r\n", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5], ""); + bk_printf("+--------------------------------------------+\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) +{ + int vif; + + vif = event->vif; + switch(event->event_id) + { + case SYSTEM_EVENT_STA_START: + { + if(g_wifiStatusCallback != NULL) + { + g_wifiStatusCallback(WIFI_STA_CONNECTING); + } + } + case SYSTEM_EVENT_STA_GOT_IP: + { + if(g_wifiStatusCallback != NULL) + { + g_wifiStatusCallback(WIFI_STA_CONNECTED); + } + wifi_get_ip_info(STATION_IF, &if_ip); + 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_ASSOC_REJECT: + 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; + unsigned int sta_ip = 0, count = 0; + printf("HAL_ConnectToWiFi"); + 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, connect_key); + wifi_config_commit(STATION_IF); + 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() +{ + printf("HAL_DisconnectFromWifi"); + wifi_disconnect(); +} + +int HAL_SetupWiFiOpenAccessPoint(const char* ssid) +{ + wifi_set_opmode(WIFI_MODE_AP_STA); + int channel = 1, ret; + ip_info_t ip_info; + wifi_config_u config; + uint8_t mac[6] = { 0 }, ip_part2, ip_part3; + + wifi_get_mac_addr(SOFTAP_IF, mac); + ip_part2 = mac[4]; + ip_part3 = mac[5]; + + 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(&ip_info, 0, sizeof(ip_info)); + ip_info.ip.addr = ipaddr_addr((const char*)"192.168.4.1"); + ip_info.gw.addr = ipaddr_addr((const char*)"192.168.4.1"); + ip_info.netmask.addr = ipaddr_addr((const char*)"255.255.255.0"); + set_softap_ipconfig(&ip_info); + + struct dhcps_lease dhcp_cfg_info; + dhcp_cfg_info.enable = true; + dhcp_cfg_info.start_ip.addr = ipaddr_addr((const char*)"192.168.4.100"); + dhcp_cfg_info.end_ip.addr = ipaddr_addr((const char*)"192.168.4.150"); + + wifi_softap_set_dhcps_lease(&dhcp_cfg_info); + wifi_get_ip_info(SOFTAP_IF, &if_ip); + if(g_wifiStatusCallback != NULL) + { + g_wifiStatusCallback(WIFI_AP_CONNECTED); + } + return 0; +} + +#endif // PLATFORM_TR6260 diff --git a/src/httpserver/http_fns.c b/src/httpserver/http_fns.c index 42e803982..a8889acac 100644 --- a/src/httpserver/http_fns.c +++ b/src/httpserver/http_fns.c @@ -39,6 +39,7 @@ static char SUBMIT_AND_END_FORM[] = "
", i + 1, number, ap_info[i].ssid, ap_info[i].primary, ap_info[i].rssi); } +#elif PLATFORM_TR6260 + poststr(request, "TODO TR6260
"); #else #error "Unknown platform" poststr(request, "Unknown platform
"); @@ -2979,6 +2982,7 @@ void OTA_RequestDownloadFromHTTP(const char* s) { #elif PLATFORM_LN882H #elif PLATFORM_ESPIDF +#elif PLATFORM_TR6260 #elif PLATFORM_W600 || PLATFORM_W800 t_http_fwup(s); #elif PLATFORM_XR809 diff --git a/src/httpserver/http_tcp_server.c b/src/httpserver/http_tcp_server.c index fcdd3c04c..f0eed244a 100644 --- a/src/httpserver/http_tcp_server.c +++ b/src/httpserver/http_tcp_server.c @@ -6,6 +6,7 @@ #include "../logging/logging.h" #include "new_http.h" +#if !NEW_TCP_SERVER #define HTTP_SERVER_PORT 80 #define REPLY_BUFFER_SIZE 2048 #define INCOMING_BUFFER_SIZE 1024 @@ -365,4 +366,4 @@ void HTTPServer_Start() #endif - +#endif diff --git a/src/httpserver/new_tcp_server.c b/src/httpserver/new_tcp_server.c new file mode 100644 index 000000000..beda03985 --- /dev/null +++ b/src/httpserver/new_tcp_server.c @@ -0,0 +1,320 @@ +#include "../new_common.h" +#include "../obk_config.h" + +#if NEW_TCP_SERVER + +#include "lwip/sockets.h" +#include "lwip/ip_addr.h" +#include "lwip/inet.h" +#include "../logging/logging.h" +#include "new_http.h" + +#ifndef MAX_SOCKETS_TCP +#define MAX_SOCKETS_TCP MEMP_NUM_TCP_PCB +#endif + +void HTTPServer_Start(); + +#define HTTP_SERVER_PORT 80 +#define REPLY_BUFFER_SIZE 2048 +#define INCOMING_BUFFER_SIZE 1024 +#define INVALID_SOCK -1 +#define HTTP_CLIENT_STACK_SIZE 8192 + +typedef struct +{ + int fd; + TaskHandle_t thread; + bool isCompleted; +} tcp_thread_t; + +static xTaskHandle g_http_thread = NULL; +static int listen_sock = INVALID_SOCK; +static tcp_thread_t sock[MAX_SOCKETS_TCP - 1] = +{ + [0 ... MAX_SOCKETS_TCP - 2] = { -1, NULL, false }, +}; + +static void tcp_client_thread(tcp_thread_t* arg) +{ + int fd = arg->fd; + char* buf = NULL; + char* reply = NULL; + int replyBufferSize = REPLY_BUFFER_SIZE; + + GLOBAL_INT_DECLARATION(); + GLOBAL_INT_DISABLE(); + reply = (char*)os_malloc(replyBufferSize); + buf = (char*)os_malloc(INCOMING_BUFFER_SIZE); + GLOBAL_INT_RESTORE(); + + if(buf == 0 || reply == 0) + { + ADDLOG_ERROR(LOG_FEATURE_HTTP, "TCP Client failed to malloc buffer"); + goto exit; + } + http_request_t request; + os_memset(&request, 0, sizeof(request)); + + request.fd = fd; + request.received = buf; + request.receivedLenmax = INCOMING_BUFFER_SIZE - 2; + request.responseCode = HTTP_RESPONSE_OK; + request.receivedLen = 0; + while(1) + { + int remaining = request.receivedLenmax - request.receivedLen; + int received = recv(fd, request.received + request.receivedLen, remaining, 0); + if(received <= 0) + { + break; + } + request.receivedLen += received; + if(received < remaining) + { + break; + } + // grow by 1024 + request.receivedLenmax += 1024; + GLOBAL_INT_DISABLE(); + request.received = (char*)realloc(request.received, request.receivedLenmax + 2); + GLOBAL_INT_RESTORE(); + if(request.received == NULL) + { + // no memory + goto exit; + } + } + request.received[request.receivedLen] = 0; + + request.reply = reply; + request.replylen = 0; + reply[0] = '\0'; + + request.replymaxlen = replyBufferSize - 1; + + if(request.receivedLen <= 0) + { + ADDLOG_ERROR(LOG_FEATURE_HTTP, "TCP Client is disconnected, fd: %d", fd); + goto exit; + } + + //addLog( "TCP received string %s\n",buf ); + // returns length to be sent if any + // ADDLOG_DEBUG(LOG_FEATURE_HTTP, "TCP will process packet of len %i\n", request.receivedLen ); + int lenret = HTTP_ProcessPacket(&request); + if(lenret > 0) + { + ADDLOG_DEBUG(LOG_FEATURE_HTTP, "TCP sending reply len %i\n", lenret); + send(fd, reply, lenret, 0); + } + +exit: + GLOBAL_INT_DISABLE(); + if(buf != NULL) + os_free(buf); + if(reply != NULL) + os_free(reply); + GLOBAL_INT_RESTORE(); + + lwip_close(fd); + arg->isCompleted = true; + rtos_suspend_thread(NULL); +} + +static inline char* get_clientaddr(struct sockaddr_storage* source_addr) +{ + static char address_str[128]; + char* res = NULL; + // Convert ip address to string + if(source_addr->ss_family == PF_INET) + { + res = inet_ntoa_r(((struct sockaddr_in*)source_addr)->sin_addr, address_str, sizeof(address_str) - 1); + } +#if LWIP_IPV6 + else if(source_addr->ss_family == PF_INET6) + { + res = inet6_ntoa_r(((struct sockaddr_in6*)source_addr)->sin6_addr, address_str, sizeof(address_str) - 1); + } +#endif + if(!res) + { + address_str[0] = '\0'; + } + return address_str; +} + +void restart_tcp_server(void* arg) +{ + HTTPServer_Start(); + vTaskDelete(NULL); +} + +static void tcp_server_thread(beken_thread_arg_t arg) +{ + OSStatus err = kNoErr; + int reuse = 1; + const size_t max_socks = MAX_SOCKETS_TCP - 1; + + struct sockaddr_in server_addr = + { + .sin_family = AF_INET, + .sin_addr = + { + .s_addr = INADDR_ANY, + }, + .sin_port = htons(HTTP_SERVER_PORT), + }; + + if(listen_sock != INVALID_SOCK) close(listen_sock); + + for(int i = 0; i < max_socks; ++i) + { + if(sock[i].fd != INVALID_SOCK) + { + close(sock[i].fd); + } + if(sock[i].thread != NULL) + { + rtos_delete_thread(&sock[i].thread); + } + sock[i].fd = INVALID_SOCK; + sock[i].thread = NULL; + sock[i].isCompleted = false; + } + + listen_sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); + if(listen_sock < 0) + { + ADDLOG_ERROR(LOG_FEATURE_HTTP, "Unable to create socket"); + goto error; + } + + setsockopt(listen_sock, SOL_SOCKET, SO_REUSEADDR, (const char*)&reuse, sizeof(reuse)); + + err = bind(listen_sock, (struct sockaddr*)&server_addr, sizeof(server_addr)); + if(err != 0) + { + ADDLOG_ERROR(LOG_FEATURE_HTTP, "Socket unable to bind"); + goto error; + } + ADDLOG_EXTRADEBUG(LOG_FEATURE_HTTP, "Socket bound on 0.0.0.0:%i", HTTP_SERVER_PORT); + + err = listen(listen_sock, 0); + if(err != 0) + { + ADDLOG_ERROR(LOG_FEATURE_HTTP, "Error occurred during listen"); + goto error; + } + ADDLOG_INFO(LOG_FEATURE_HTTP, "TCP server listening"); + while(true) + { + struct sockaddr_storage source_addr; + socklen_t addr_len = sizeof(source_addr); + + int new_idx = 0; + for(new_idx = 0; new_idx < max_socks; ++new_idx) + { + if(sock[new_idx].isCompleted) + { + if(sock[new_idx].thread != NULL) + { + rtos_delete_thread(&sock[new_idx].thread); + sock[new_idx].thread = NULL; + } + sock[new_idx].isCompleted = false; + sock[new_idx].fd = INVALID_SOCK; + } + if(sock[new_idx].fd == INVALID_SOCK) + { + break; + } + } + if(new_idx < max_socks) + { + sock[new_idx].fd = accept(listen_sock, (struct sockaddr*)&source_addr, &addr_len); + + if(sock[new_idx].fd < 0) + { + switch(errno) + { + //case EAGAIN: + case EWOULDBLOCK: break; + case EBADF: goto error; + default: + ADDLOG_ERROR(LOG_FEATURE_HTTP, "[sock=%d]: Error when accepting connection, err: %i", sock[new_idx].fd, errno); + break; + } + } + else + { + //ADDLOG_EXTRADEBUG(LOG_FEATURE_HTTP, "[sock=%d]: Connection accepted from IP:%s", sock[new_idx].fd, get_clientaddr(&source_addr)); + + rtos_delay_milliseconds(20); + if(kNoErr != rtos_create_thread(&sock[new_idx].thread, + BEKEN_APPLICATION_PRIORITY, + "HTTP Client", + (beken_thread_function_t)tcp_client_thread, + HTTP_CLIENT_STACK_SIZE, + (beken_thread_arg_t)&sock[new_idx])) + { + ADDLOG_ERROR(LOG_FEATURE_HTTP, "[sock=%d]: TCP Client thread creation failed!", sock[new_idx].fd); + lwip_close(sock[new_idx].fd); + sock[new_idx].fd = INVALID_SOCK; + goto error; + } + } + } + vTaskDelay(pdMS_TO_TICKS(10)); + } + +error: + ADDLOG_ERROR(LOG_FEATURE_HTTP, "TCP Server Error"); + if(listen_sock != INVALID_SOCK) + { + close(listen_sock); + } + + for(int i = 0; i < max_socks; ++i) + { + if(sock[i].thread != NULL) + { + rtos_delete_thread(&sock[i].thread); + sock[i].thread = NULL; + } + if(sock[i].fd != INVALID_SOCK) + { + close(sock[i].fd); + sock[i].fd = INVALID_SOCK; + } + } + xTaskCreate( + (TaskFunction_t)restart_tcp_server, + "TCP Restart", + 2048 / sizeof(StackType_t), + NULL, + BEKEN_APPLICATION_PRIORITY, + NULL); +} + +void HTTPServer_Start() +{ + OSStatus err = kNoErr; + + if(g_http_thread != NULL) + { + rtos_delete_thread(&g_http_thread); + } + + err = rtos_create_thread(&g_http_thread, BEKEN_APPLICATION_PRIORITY, + "TCP_server", + (beken_thread_function_t)tcp_server_thread, + 0x800, + (beken_thread_arg_t)0); + if(err != kNoErr) + { + ADDLOG_ERROR(LOG_FEATURE_HTTP, "create \"TCP_server\" thread failed with %i!\r\n", err); + } +} + +#endif diff --git a/src/httpserver/rest_interface.c b/src/httpserver/rest_interface.c index 9ce1666e1..54f593965 100644 --- a/src/httpserver/rest_interface.c +++ b/src/httpserver/rest_interface.c @@ -1421,7 +1421,7 @@ static int ota_verify_download(void) static int http_rest_post_flash(http_request_t* request, int startaddr, int maxaddr) { -#if PLATFORM_XR809 || PLATFORM_W800 +#if PLATFORM_XR809 || PLATFORM_W800 || PLATFORM_TR6260 return 0; //Operation not supported yet #endif @@ -2015,7 +2015,7 @@ static int http_rest_get_flash(http_request_t* request, int startaddr, int len) res = bl_flash_read(startaddr, (uint8_t *)buffer, readlen); #elif PLATFORM_W600 || PLATFORM_W800 res = 0; -#elif PLATFORM_LN882H || PLATFORM_ESPIDF +#elif PLATFORM_LN882H || PLATFORM_ESPIDF || PLATFORM_TR6260 // TODO:LN882H flash read? res = 0; #else diff --git a/src/littlefs/our_lfs.c b/src/littlefs/our_lfs.c index 088202e47..2cc44c24a 100644 --- a/src/littlefs/our_lfs.c +++ b/src/littlefs/our_lfs.c @@ -678,6 +678,51 @@ static int lfs_erase(const struct lfs_config* c, lfs_block_t block) return res; } +#elif PLATFORM_TR6260 + +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 = hal_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 = hal_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 = hal_spiflash_erase(startAddr, LFS_BLOCK_SIZE); + return res; +} #endif diff --git a/src/littlefs/our_lfs.h b/src/littlefs/our_lfs.h index ed4d88a33..031a3ec73 100644 --- a/src/littlefs/our_lfs.h +++ b/src/littlefs/our_lfs.h @@ -68,6 +68,12 @@ #define LFS_BLOCKS_START_MIN 0x0 #define LFS_BLOCKS_END 0x50000 +#elif PLATFORM_TR6260 + +#define LFS_BLOCKS_START PARTION_LMA_LFS +#define LFS_BLOCKS_START_MIN PARTION_LMA_LFS +#define LFS_BLOCKS_END PARTION_LMA_LFS + 0x20000 + #else // TODO // start 0x1000 after OTA addr diff --git a/src/mqtt/new_mqtt.c b/src/mqtt/new_mqtt.c index 78a3e5568..663bc7c22 100644 --- a/src/mqtt/new_mqtt.c +++ b/src/mqtt/new_mqtt.c @@ -1634,7 +1634,7 @@ static BENCHMARK_TEST_INFO* info = NULL; #if WINDOWS -#elif PLATFORM_BL602 || PLATFORM_W600 || PLATFORM_W800 || PLATFORM_ESPIDF +#elif PLATFORM_BL602 || PLATFORM_W600 || PLATFORM_W800 || PLATFORM_ESPIDF || PLATFORM_TR6260 static void mqtt_timer_thread(void* param) { while (1) @@ -1674,7 +1674,7 @@ commandResult_t MQTT_StartMQTTTestThread(const void* context, const char* cmd, c #if WINDOWS -#elif PLATFORM_BL602 || PLATFORM_W600 || PLATFORM_W800 || PLATFORM_ESPIDF +#elif PLATFORM_BL602 || PLATFORM_W600 || PLATFORM_W800 || PLATFORM_ESPIDF || PLATFORM_TR6260 xTaskCreate(mqtt_timer_thread, "mqtt", 1024, (void*)info, 15, NULL); #elif PLATFORM_XR809 || PLATFORM_LN882H OS_TimerSetInvalid(&timer); diff --git a/src/new_cfg.c b/src/new_cfg.c index f5b3b0683..71e4e7b8b 100644 --- a/src/new_cfg.c +++ b/src/new_cfg.c @@ -149,6 +149,8 @@ void CFG_SetDefaultConfig() { strcpy_safe(g_cfg.mqtt_group, "bl602s", sizeof(g_cfg.mqtt_group)); #elif PLATFORM_ESPIDF strcpy_safe(g_cfg.mqtt_group, "esp", sizeof(g_cfg.mqtt_group)); +#elif PLATFORM_TR6260 + strcpy_safe(g_cfg.mqtt_group, "tr6260", sizeof(g_cfg.mqtt_group)); #elif WINDOWS strcpy_safe(g_cfg.mqtt_group, "bekens", sizeof(g_cfg.mqtt_group)); #else @@ -720,7 +722,7 @@ void CFG_InitAndLoad() { // mark as changed g_cfg_pendingChanges ++; } else { -#if defined(PLATFORM_XR809) || defined(PLATFORM_BL602) || defined(PLATFORM_ESPIDF) +#if defined(PLATFORM_XR809) || defined(PLATFORM_BL602) || defined(PLATFORM_ESPIDF) || defined(PLATFORM_TR6260) if (g_cfg.mac[0] == 0 && g_cfg.mac[1] == 0 && g_cfg.mac[2] == 0 && g_cfg.mac[3] == 0 && g_cfg.mac[4] == 0 && g_cfg.mac[5] == 0) { WiFI_GetMacAddress((char*)g_cfg.mac); } diff --git a/src/new_common.h b/src/new_common.h index 6f4f72ea6..2b3475f54 100644 --- a/src/new_common.h +++ b/src/new_common.h @@ -100,6 +100,11 @@ typedef long BaseType_t; #define PLATFORM_MCU_NAME MANUFACTURER #endif #define DEVICENAME_PREFIX_FULL "Open" PLATFORM_MCU_NAME +#elif PLATFORM_TR6260 +#define DEVICENAME_PREFIX_FULL "OpenTR6260" +#define DEVICENAME_PREFIX_SHORT "tr6260" +#define PLATFORM_MCU_NAME "TR6260" +#define MANUFACTURER "Transa Semi" #else #error "You must define a platform.." This platform is not supported, error! @@ -127,6 +132,8 @@ This platform is not supported, error! #define USER_SW_VER "LN882H_Test" #elif defined(PLATFORM_ESPIDF) #define USER_SW_VER PLATFORM_MCU_NAME "_Test" +#elif defined(PLATFORM_TR6260) +#define USER_SW_VER "TR6260_Test" #else #define USER_SW_VER "unknown" #endif @@ -422,6 +429,64 @@ OSStatus rtos_create_thread(beken_thread_t* thread, #define delay_ms sys_delay_ms #define UINT32 uint32_t +#elif PLATFORM_TR6260 + +#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" + +typedef unsigned int UINT32; + +#define ASSERT +#define free os_free +#define malloc os_malloc +#define realloc os_realloc +#define strlen os_strlen +#define memset os_memset +#define memcpy os_memcpy +#define strstr os_strstr +#define strncpy os_strncpy +#define strchr os_strchr +#define strcmp os_strcmp +#define memmove os_memmove +//#define strcat os_strcat +#define os_strcpy strcpy + +#define close lwip_close +#define bk_printf system_printf +#define printf system_printf + +// 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); + +#define GLOBAL_INT_DECLARATION() ; +#define GLOBAL_INT_DISABLE() ; +#define GLOBAL_INT_RESTORE() ; + #else #include "gw_intf.h" @@ -493,7 +558,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); -#ifndef PLATFORM_ESPIDF +#if !defined(PLATFORM_ESPIDF) && !defined(PLATFORM_TR6260) const char* strcasestr(const char* str1, const char* str2); #endif diff --git a/src/new_pins.h b/src/new_pins.h index d07037f4d..b8e4bf5ab 100644 --- a/src/new_pins.h +++ b/src/new_pins.h @@ -1016,6 +1016,8 @@ typedef enum channelType_e { #else #define PLATFORM_GPIO_MAX 0 #endif +#elif PLATFORM_TR6260 +#define PLATFORM_GPIO_MAX 25 #else #define PLATFORM_GPIO_MAX 29 #endif diff --git a/src/obk_config.h b/src/obk_config.h index 013bfa946..b26445123 100644 --- a/src/obk_config.h +++ b/src/obk_config.h @@ -196,6 +196,18 @@ #define ENABLE_DRIVER_SSDP 1 #define ENABLE_DRIVER_CHT83XX 1 +#elif PLATFORM_TR6260 + +#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_LED 1 +#define ENABLE_DRIVER_WEMO 1 + #else #error "Platform not defined" diff --git a/src/user_main.c b/src/user_main.c index 0c58ef100..ee7a873a1 100644 --- a/src/user_main.c +++ b/src/user_main.c @@ -212,7 +212,7 @@ int LWIP_GetActiveSockets() { } #endif -#if defined(PLATFORM_BL602) || defined(PLATFORM_W800) || defined(PLATFORM_W600)|| defined(PLATFORM_LN882H) || defined(PLATFORM_ESPIDF) +#if defined(PLATFORM_BL602) || defined(PLATFORM_W800) || defined(PLATFORM_W600) || defined(PLATFORM_LN882H) || defined(PLATFORM_ESPIDF) || defined(PLATFORM_TR6260) OSStatus rtos_create_thread(beken_thread_t* thread, uint8_t priority, const char* name, @@ -246,10 +246,20 @@ OSStatus rtos_create_thread(beken_thread_t* thread, } OSStatus rtos_delete_thread(beken_thread_t* thread) { - vTaskDelete(thread); + if(thread == NULL) vTaskDelete(thread); + else vTaskDelete(*thread); return kNoErr; } + +OSStatus rtos_suspend_thread(beken_thread_t* thread) +{ + if(thread == NULL) vTaskSuspend(thread); + else vTaskSuspend(*thread); + return kNoErr; +} + #endif + void MAIN_ScheduleUnsafeInit(int delSeconds) { g_doUnsafeInitIn = delSeconds; } @@ -930,7 +940,7 @@ void QuickTick(void* param) g_last_time = g_time; -#if (defined WINDOWS) || (defined PLATFORM_BEKEN) || (defined PLATFORM_BL602) || (defined PLATFORM_LN882H) || (defined PLATFORM_ESPIDF) +#if (defined WINDOWS) || (defined PLATFORM_BEKEN) || (defined PLATFORM_BL602) || (defined PLATFORM_LN882H) || (defined PLATFORM_ESPIDF) || (defined PLATFORM_TR6260) SVM_RunThreads(g_deltaTimeMS); #endif RepeatingEvents_RunUpdate(g_deltaTimeMS * 0.001f); @@ -981,7 +991,7 @@ void QuickTick(void* param) // this is the bit which runs the quick tick timer #if WINDOWS -#elif PLATFORM_BL602 || PLATFORM_W600 || PLATFORM_W800 +#elif PLATFORM_BL602 || PLATFORM_W600 || PLATFORM_W800 || PLATFORM_TR6260 void quick_timer_thread(void* param) { while (1) { @@ -1000,7 +1010,7 @@ void QuickTick_StartThread(void) { #if WINDOWS -#elif PLATFORM_BL602 || PLATFORM_W600 || PLATFORM_W800 +#elif PLATFORM_BL602 || PLATFORM_W600 || PLATFORM_W800 || PLATFORM_TR6260 xTaskCreate(quick_timer_thread, "quick", 1024, NULL, 15, NULL); #elif PLATFORM_ESPIDF