#include "cat1_utils.h"
#include "cat1_tcpServer.h"
#include "cat1_runtime.h"
+#include "bleInstruct.h"
+#include "broadcast_feature.h"
#ifdef __cplusplus
+
extern "C" {
+
#endif /* __cplusplus */
#include "cat1_server_hal.h"
#include "cat1_ctl.h"
#include "tcxo.h"
-#include "cat1_utils.h"
-
-
-
+#include "custom_utils.h"
#include "cmsis_os.h"
+#include "broadcast_feature.h"
static uint8_t g_skip_cat1_service_udp_transfer = 0;
+uint8_t is_need_udp_updata=0;
+
+
#define PEER_IP "172.16.1.2"
#define PEER_PORT 5001
#define SERVER_IP "172.16.1.5"
#else
#define CAT1_PY_PATH "/system/cat1ota" //存放需要升级的py文件路径
#endif
+
+
+#ifdef SINGLE_USER_PARTITION
+#define CAT1_PY_UDP_PATH "/user/system/cat1otaudp" //存放需要升级的py文件路径
+#else
+#define CAT1_PY_UDP_PATH "/system/cat1otaudp" //存放需要升级的py文件路径
+#endif
+
+
#define CAT1_REPLYA_FILE_SIZE_FUN 1 //是否需要CAT1回复文件大小一致传输完单个文件是否与SIZE大小匹配比较
static osTimerId_t file_transfer_timer=NULL;
static uint8_t timerOut_count = 0;
};
#pragma pack(pop)
+#include "cmsis_os2.h"
+extern osStatus_t osDelay(uint32_t ticks);
+#define cat1_msleep(ms) osDelay(ms) /* osDelay(1) : 1ms */
static int g_listen_sock = 0;
struct sockaddr_in filesourceAddr = {0};
{
int content_length = (int)strlen(content);
- if(content_length > MAX_TCP_MSG_BUFFER_LEN || content == NULL)
+ if(content_length > MAX_TCP_MSG_BUFFER_LEN || content == NULL)
{
printf("content data error: content_length %d %s\r\n",content_length,content);
return -1;
// printf("msg_format_type %d \n",g_msg_format_type,len);
int err = 0;
if( len > 0 ) {
+
err = sendto(g_listen_sock, tx_buffer, len, 0, (struct sockaddr *)&filesourceAddr, sizeof(filesourceAddr));
+ // err=send(g_listen_sock,tx_buffer,len,0);
+ cat1_msleep(10);
+ cat1_print_err("udp_send_response\n");
if (err < 0) {
cat1_print_err("Error occured during sending: errno %d\n", errno);
}
cat1_print_err("Error cat1 poweroff tcp skipp send data\n");
return ;
}
+ printf("ble_tcp_send_msg_toCat1 1\r\n");
+
+ cat1_api_wakeup_cat1(1);
// uart_port_register_irq(UART_BUS_0);
osal_irq_enable(UART_1_IRQN);
cat1_print_err(" g_skip_cat1_service_udp_transfer \n");
return ;
}
- char station_tx_buffer[MAX_TCP_MSG_BUFFER_LEN] = {0};
+ char *station_tx_buffer=(char*)malloc(MAX_TCP_MSG_BUFFER_LEN);
if( filesourceAddr.sin_port != 0 ) {
udp_send_response(station_tx_buffer,mode,cmd, content);
+ cat1_print_err("ble_tcp_send_msg_toCat1 2\n");
}
+ free(station_tx_buffer);
+
+ cat1_api_wakeup_cat1(0);
}
cJSON_AddNumberToObject(dataJSON,"Code",CAT1_TCP_START_SEND_FILE_DATA);
cJSON_AddStringToObject(dataJSON,"data",(char *)data); // FE 头 0012c 文件长度 + data+crc
json_format = cJSON_PrintUnformatted(dataJSON);
- // printf("start cat1_ota_send_data json_format:%s %d\r\n",data,strlen(data));
+ printf("start cat1_ota_send_data json_format:%s %d\r\n",data,strlen(data));
cJSON_Delete(dataJSON);
printf("cat1_ota_send_data two:\r\n");
ble_tcp_send_msg_toCat1(FILE_TRANSFER_CMD,0,json_format);
+ // if(json_format)
+ printf("free json_format \r\n");
cJSON_free(json_format);
break;
// case CAT1_TCP_START_OTA_FAILE: //OTA失败
}
}
if(fp != NULL){ //防止打开文件没有关闭
- printf("file is not close!\r\n");
+ printf("file is not lwip_close!\r\n");
fclose(fp);
fp = NULL;
}
+
+ cat1_api_wakeup_cat1(0);
}
static void cat1_file_Timer_CallBack(int data_tmp)
// 跳过'.'和'..'目录
if (strcmp(entry->d_name, ".") != 0 && strcmp(entry->d_name, "..") != 0) {
printf("%s\n", entry->d_name); // 输出文件名
- // std::string filename= entry->d_name;
- // //0 1 2
- // if(filename=="Cat1pyVersion.txt"
- // || filename=="main.py"
- // || filename=="main_init.py"
- // || filename=="tcpService.py")
- // {
- // printf("屏蔽升级文件 %s\n",filename.c_str());
- // continue;
- // }
+ // entry->d_name;
+ //0 1 2
+ if(strcmp("Cat1pyVersion.txt",entry->d_name)==0
+ || strcmp("main.py",entry->d_name)==0
+ || strcmp("main_init.py",entry->d_name)==0
+ || strcmp("tcpService.py",entry->d_name)==0 )
+ {
+ printf("屏蔽升级文件 %s\n",entry->d_name);
+ continue;
+ }
fileNameList[file_count] = (char *)malloc(DEFAULT_MAX_FILE_NAME_SIZE * sizeof(char));
if (fileNameList[file_count] == NULL) {
}
}
+void read_UDP_dir(void){
+
+ for (int i = 0; i < DEFAULT_MAX_FILE_COUNT; i++) { //释放内存
+ if(fileNameList[i] != NULL){
+ free(fileNameList[i]);
+ fileNameList[i] = NULL;
+ }
+ }
+
+ file_count = 0;
+
+ printf("fileNameList[file_count]\r\n");
+
+ for(int i=0;i<5;i++)
+ {
+ fileNameList[file_count] = (char *)malloc(DEFAULT_MAX_FILE_NAME_SIZE * sizeof(char));
+
+ if(i==0)
+ snprintf(fileNameList[file_count],DEFAULT_MAX_FILE_NAME_SIZE,"%s","telecom_dmp.py");
+ else if (i==1)
+ snprintf(fileNameList[file_count],DEFAULT_MAX_FILE_NAME_SIZE,"%s","china_mobile_dmp.py");
+ else if (i==2)
+ snprintf(fileNameList[file_count],DEFAULT_MAX_FILE_NAME_SIZE,"%s","cat1Service.py");
+ else if (i==3)
+ snprintf(fileNameList[file_count],DEFAULT_MAX_FILE_NAME_SIZE,"%s","tcpserver.py");
+ else
+ snprintf(fileNameList[file_count],DEFAULT_MAX_FILE_NAME_SIZE,"%s","main.py");
+
+ printf("fileNameList[file_count] %s\r\n",fileNameList[file_count]);
+ file_count+=1;
+ }
+
+ send_dir_info();
+ noreplayCount = 0;
+ uint32_t tick;
+ osStatus_t retTimer;
+ if(file_transfer_timer == NULL){
+ file_transfer_timer = osTimerNew((osTimerFunc_t)cat1_file_Timer_CallBack, osTimerPeriodic, NULL, NULL);
+ tick = 1000;// osMs2Tick(1000);
+ retTimer = osTimerStart(file_transfer_timer, tick);
+ if (retTimer != osOK && file_transfer_timer != NULL) {
+ cat1_print_err("StartCallTimer osTimerStart failed, ret = %lx!!", retTimer);
+ osTimerDelete(file_transfer_timer);
+ file_transfer_timer = NULL;
+ }
+ }
+
+}
+
+
void send_curfile_info_data(void)
{
cat1_ota_flag = CAT1_TCP_START_SEND_SINGLE_FILE_INFO;
if(strlen(fileNameList[curfilecount]) != 0 && filesize != 0){
char file_path[DEFAULT_MAX_FILE_NAME_SIZE]={0};
memset(file_path,0,DEFAULT_MAX_FILE_NAME_SIZE);
+ if(is_need_udp_updata)
+ sprintf_s(file_path,DEFAULT_MAX_FILE_NAME_SIZE,"%s/%s",CAT1_PY_UDP_PATH,fileNameList[curfilecount]);
+ else
sprintf_s(file_path,DEFAULT_MAX_FILE_NAME_SIZE,"%s/%s",CAT1_PY_PATH,fileNameList[curfilecount]);
if(fp != NULL){
fclose(fp);
struct dirent *entry;
char file_path[DEFAULT_MAX_FILE_NAME_SIZE]={0};
memset(file_path,0,DEFAULT_MAX_FILE_NAME_SIZE);
+
+ if(is_need_udp_updata)
+ sprintf_s(file_path,DEFAULT_MAX_FILE_NAME_SIZE,"%s/%s",CAT1_PY_UDP_PATH,fileNameList[curfilecount]);
+ else
sprintf_s(file_path,DEFAULT_MAX_FILE_NAME_SIZE,"%s/%s",CAT1_PY_PATH,fileNameList[curfilecount]);
count+=1;
switch (mode)
{
case READ_DIR_INFO: //读文件目录信息
+ printf("READ_DIR_INFO\r\n");
+ if(is_need_udp_updata)
+ read_UDP_dir();
+ else
read_dir();
break;
case READ_FILE_DATA_INFO://收到CAT1回复开始发送文件信息
void start_cat1_ota(void){
stop_cat1_ota();
send_data_case(READ_DIR_INFO); //开始OTA 就开始升级py文件
+
+ uint8_t TRANSMIT_DATA=START_CAT1_OTA;
+
+ CustomEventPublish(TOPIC_EVENT_BLE_TRANSMIT,&TRANSMIT_DATA,1);
+
+ cat1_api_wakeup_cat1(1);
}
void Cat1_OTA(uint8_t ota_state)
{
{
return 0;
}
+ uint8_t shutdowflag = 1;//重启
+ uint8_t TRANSMIT_DATA=OTA_UPDATA_FAIL;
+
switch (cmd)
{
case CAT1_REPLAY_CREAT_DIR_FAILE: //cat1:创建临时文件夹失败
creat_file_err+=1;
if(creat_file_err >= FAILE_COUNT){ //创建十次都出错不创建结束当前的升级
creat_file_err=0;
+ CustomEventPublish(TOPIC_EVENT_BLE_TRANSMIT,&TRANSMIT_DATA,1);
stop_cat1_ota();
break;
}
if(write_data_err >= FAILE_COUNT){
write_data_err = 0;
stop_cat1_ota();
+ CustomEventPublish(TOPIC_EVENT_BLE_TRANSMIT,&TRANSMIT_DATA,1);
break;
}
printf("CAT1_REPLAY_WRITE_FILE_ERROR! %d",cmd);
data_crc_err+=1;
if(data_crc_err >= FAILE_COUNT){ //连续十次CRC都出错就结束进程
data_crc_err = 0;
+ uint8_t TRANSMIT_DATA=OTA_UPDATA_FAIL;
+ CustomEventPublish(TOPIC_EVENT_BLE_TRANSMIT,&TRANSMIT_DATA,1);
stop_cat1_ota();
break;
}
if(creat_file_err >= FAILE_COUNT){
creat_file_err = 0;
stop_cat1_ota();
+ uint8_t TRANSMIT_DATA=OTA_UPDATA_FAIL;
+ CustomEventPublish(TOPIC_EVENT_BLE_TRANSMIT,&TRANSMIT_DATA,1);
break;
}
send_data_case(CREAT_FILE_FAILE);
break;
case CAT1_REPLAY_OTA_SUCC: //ota 成功失败与否 收到CAT1的回复就停止计时器
stop_cat1_ota();
+ //成功直接重启
+ CustomEventPublish(TOPIC_EVENT_SHUTDOWN_ANIMATIOR, &shutdowflag, sizeof(shutdowflag));
//添加GUI
break;
case CAT1_REPLAY_OTA_FALIE:
+
stop_cat1_ota();
+
break;
case CAT1_REPLAY_FILE_SIZE_OK: //文件大小发送和接收的一致
read_file_info_data();
if(file_size_err >= FAILE_COUNT){
file_size_err = 0;
stop_cat1_ota();
+ CustomEventPublish(TOPIC_EVENT_BLE_TRANSMIT,&TRANSMIT_DATA,1);
break;
}
send_curfile_info_data();
return listen_sock;
}
-#include "cmsis_os2.h"
-extern osStatus_t osDelay(uint32_t ticks);
-#define cat1_msleep(ms) osDelay(ms) /* osDelay(1) : 1ms */
+
+static int tcp_socket_file_init()
+{
+ int addr_family;
+ int ip_protocol;
+ int opt = 1;
+ struct sockaddr_in destAddr;
+ char addr_str[128];
+
+ // destAddr.sin_addr.s_addr = htonl(INADDR_ANY);
+ destAddr.sin_addr.s_addr = inet_addr(SERVER_IP);
+ destAddr.sin_family = AF_INET;
+ destAddr.sin_port = htons(PORT);
+ addr_family = AF_INET;
+ ip_protocol = IPPROTO_IP;
+ inet_ntoa_r(destAddr.sin_addr, addr_str, sizeof(addr_str) - 1);
+
+ int listen_sock = socket(addr_family, SOCK_STREAM, ip_protocol);
+ if (listen_sock < 0) {
+ cat1_print_err("Unable to create socket: errno %d\n", errno);
+ return -1;
+ }
+ // setsockopt(listen_sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
+ // setsockopt(listen_sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
+
+ filesourceAddr.sin_addr.s_addr = inet_addr(PEER_IP);
+ filesourceAddr.sin_family = AF_INET;
+ filesourceAddr.sin_port = htons(PEER_PORT);
+
+ return listen_sock;
+}
+
+
+void re_connect(void)
+{
+ // socklen_t addrLen = sizeof(filesourceAddr);
+ // lwip_close(g_listen_sock);
+ // // while (1)
+ // {
+ // int connret=connect(g_listen_sock, (struct sockaddr *)&filesourceAddr,addrLen);
+ // cat1_print_err("Unable to connect: errno %d\n", errno);
+ // if(connret=0)
+ // {
+ // cat1_print_err("connect succ\n");
+ // // break;
+ // }
+ // else
+ // {
+ // cat1_msleep(1000);
+ // cat1_print_err("connecting...\n");
+ // }
+ // }
+ remove(CAT1_PY_IS_NEED_UDP_PATH);
+ cat1_print_err("CAT1_PY_IS_NEED_UDP_PATH\n");
+}
+
+uint8_t errno_count=0;
+static uint8_t IS_need_ota=1;
+extern uint8_t g_py_ver;
+
+
void cat1_server_file_task(void *pvParameters)
{
char rx_buffer[512];
int index;
socklen_t addrLen = sizeof(filesourceAddr);
while (1) {
- if( g_listen_sock > 0 ) close(g_listen_sock);
- g_listen_sock = udp_socket_file_init();
- if( g_listen_sock < 0 ) {
- cat1_print_err("socket init fail and retry\n");
- // vTaskDelay(1000/portTICK_RATE_MS);
+ if(errno_count>10)
+ {
+ //如果失败太多次将退出循环，避免浪费系统资源
+ // return;
+ cat1_print_err("errno count %d\n",errno_count);
+ }
+ if( g_listen_sock > 0 )
+ {
+ cat1_print_err("lwip_close(g_listen_sock)\n");
+ lwip_close(g_listen_sock);
+ }
+
+ if(is_need_udp_updata==0)
+ {
+ g_listen_sock = tcp_socket_file_init();
+ if( g_listen_sock < 0 ) {
+ cat1_print_err("socket init fail and retry\n");
+ // vTaskDelay(1000/portTICK_RATE_MS);
+ errno_count++;
+ cat1_msleep(1000);
+ continue;
+ }
cat1_msleep(1000);
- continue;
+ int connret=connect(g_listen_sock, (struct sockaddr *)&filesourceAddr,addrLen);
+ if(connret>=0)
+ {
+ cat1_print_err("connect succ\n");
+ }
+ else
+ {
+ cat1_msleep(1000);
+ cat1_print_err("Unable to connect: errno %d\n", errno);
+ cat1_print_err("connecting...\n");
+ errno_count++;
+ continue;
+ }
+ }
+ else
+ {
+ g_listen_sock = udp_socket_file_init();
+ if( g_listen_sock < 0 ) {
+ cat1_print_err("socket init fail and retry\n");
+ // vTaskDelay(1000/portTICK_RATE_MS);
+ cat1_msleep(1000);
+ errno_count++;
+ continue;
+ }
+ }
+
+ errno_count=0;
+
+ if(IS_need_ota)
+ {
+ IS_need_ota=0;
+ if(g_py_ver==16)
+ {
+ uint8_t TRANSMIT_DATA=IS_NEED_CAT1_OTA;
+
+ CustomEventPublish(TOPIC_EVENT_BLE_TRANSMIT,&TRANSMIT_DATA,1);
+ }
+ else if(g_py_ver==17)
+ {
+ Cat1_OTA(CAT1_TCP_START_OTA);
+ }
+ else if(g_py_ver==18)
+ {
+ uint8_t TRANSMIT_DATA=IS_NEED_CAT1_OTA;
+
+ CustomEventPublish(TOPIC_EVENT_BLE_TRANSMIT,&TRANSMIT_DATA,1);
+ }
+ else if (g_py_ver>=19 && (uapi_dev_runtime_get_cat1_networkstat()) )
+ {
+ char * cat1_modemver = uapi_dev_runtime_get_cat1_modemver();
+
+ // star_http_ota_updata(cat1_modemver ,g_py_ver);
+
+
+ }
+
}
while (1) {
#define CAT1_SERVICE_TASK_SIZE (0x800*5)
#define CAT1_SERVICE_TASK_PRIO 5
+
+
errcode_t cat1_tcp_server_init(void)
{
cat1_print_info("cat1_tcp_server_init !\r\n");
taskcfg.attr.stack_size = CAT1_SERVICE_TASK_SIZE;
taskcfg.func = cat1_server_file_task;
taskcfg.use_mem = USE_EXTEND_MEM;
-
- errcode_t ret=cat1_create_osThread_custom(&taskcfg);
+
+ if(g_py_ver<=16)
+ {
+ is_need_udp_updata=1;
+ }
+ errcode_t ret=uapi_create_osThread_custom(&taskcfg);
+
+
if(ret != ERRCODE_SUCC)
{
cat1_print_err("create cat1_service_file failed %d!\r\n",ret);
return ERRCODE_SUCC;
}
+char* xor_encrypt_decrypt(const char* message, const char* key) {
+ if (message == NULL || key == NULL) {
+ return NULL;
+ }
+
+ size_t message_len = strlen(message);
+ size_t key_len = strlen(key);
+
+ // 分配内存用于存储结果
+ char* result = (char*)malloc(message_len + 1);
+ if (result == NULL) {
+ return NULL; // 内存分配失败
+ }
+
+ // 执行 XOR 操作
+ for (size_t i = 0; i < message_len; ++i) {
+ result[i] = message[i] ^ key[i % key_len];
+ }
+ result[message_len] = '\0'; // 确保字符串以 null 结尾
+
+ return result;
+}
+
+
+
#ifdef __cplusplus
}
projects / mirrors / FD230.git / commitdiff