mirror/OpenBK7231T_App
3
0
Fork 0
mirror of https://github.com/openshwprojects/OpenBK7231T_App.git synced 2025-10-29 19:43:22 +00:00
Code Issues Packages Projects Releases Wiki Activity

TR6260 support (#1446)

Browse Source 
* TR6260 initial

* fix gh-actions

* various fixes/features

* wifi fast connect fix

* fix gpio, add i2c

* move config to obk
This commit is contained in:
NonPIayerCharacter 2024-12-12 20:55:26 +03:00 committed by GitHub
parent 2c0b3cdb39
commit 532a90313c
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
26 changed files with 1372 additions and 16 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.github/workflows/workflow.yaml vendored
View File

@ -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

4
.gitmodules vendored
View File

@ -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

18
Makefile
View File

@ -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

129
platforms/TR6260/openbeken.mk Normal file
View File

@ -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

1
sdk/OpenTR6260 Submodule

@ -0,0 +1 @@
Subproject commit 9deb1e55774c5c967c1286b2e3ea862273d97d49

4
src/cmnds/cmd_main.c
View File

@ -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) {

2
src/driver/drv_ds1820_simple.c
View File

@ -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++)
{

15
src/hal/tr6260/hal_adc_tr6260.c Normal file
View File

@ -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

18
src/hal/tr6260/hal_flashConfig_tr6260.c Normal file
View File

@ -0,0 +1,18 @@
#ifdef PLATFORM_TR6260
#include "../hal_flashConfig.h"
#include <easyflash.h>
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

178
src/hal/tr6260/hal_flashVars_tr6260.c Normal file
View File

@ -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

8
src/hal/tr6260/hal_generic_tr6260.c Normal file
View File

@ -0,0 +1,8 @@
#ifdef PLATFORM_TR6260
void HAL_RebootModule()
{
wdt_reset_chip(0);
}
#endif // PLATFORM_TR6260

7
src/hal/tr6260/hal_main_tr6260.c Normal file
View File

@ -0,0 +1,7 @@
#ifdef PLATFORM_TR6260
#include "../../new_common.h"
#include "../../logging/logging.h"
#include "../../quicktick.h"
#endif // PLATFORM_TR6260

288
src/hal/tr6260/hal_pins_tr6260.c Normal file
View File

@ -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

223
src/hal/tr6260/hal_wifi_tr6260.c Normal file
View File

@ -0,0 +1,223 @@
#ifdef PLATFORM_TR6260
#include "../hal_wifi.h"
#include "../../new_common.h"
#include <lwip/sockets.h>
#include <stdbool.h>
#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

4
src/httpserver/http_fns.c
View File

@ -39,6 +39,7 @@ static char SUBMIT_AND_END_FORM[] = "<br><input type=\"submit\" value=\"Submit\"
#include "BkDriverFlash.h"
#include "temp_detect_pub.h"
#elif defined(PLATFORM_LN882H)
#elif defined(PLATFORM_TR6260)
#elif defined(PLATFORM_ESPIDF)
#include "esp_wifi.h"
#include "esp_system.h"
@ -1305,6 +1306,8 @@ int http_fn_cfg_wifi(http_request_t* request) {
{
hprintf255(request, "[%i/%u] SSID: %s, Channel: %i, Signal %i<br>", i + 1, number, ap_info[i].ssid, ap_info[i].primary, ap_info[i].rssi);
}
#elif PLATFORM_TR6260
poststr(request, "TODO TR6260<br>");
#else
#error "Unknown platform"
poststr(request, "Unknown platform<br>");
@ -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

3
src/httpserver/http_tcp_server.c
View File

@ -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

320
src/httpserver/new_tcp_server.c Normal file
View File

@ -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

4
src/httpserver/rest_interface.c
View File

@ -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

45
src/littlefs/our_lfs.c
View File

@ -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

6
src/littlefs/our_lfs.h
View File

@ -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

4
src/mqtt/new_mqtt.c
View File

@ -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);

4
src/new_cfg.c
View File

@ -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);
}

67
src/new_common.h
View File

@ -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

2
src/new_pins.h
View File

@ -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

12
src/obk_config.h
View File

@ -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"

20
src/user_main.c
View File

@ -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