wangbo
/
IntegratedCMU
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

FIX 1.升级优化;

Browse Source
main
wangbo 1 month ago
parent 12dc851e46
commit 74c69befe9
6 changed files with 135 additions and 51 deletions
Show Stats Download Patch File Download Diff File

8
app/include/dbg.h
Unescape Escape View File

@ -38,6 +38,7 @@
#define _DBG_H_ #define _DBG_H_
/* Includes ------------------------------------------------------------------*/ /* Includes ------------------------------------------------------------------*/
#include "common.h"
/* Define --------------------------------------------------------------------*/ /* Define --------------------------------------------------------------------*/
#define DBG_HELP_STR_MAX 32 #define DBG_HELP_STR_MAX 32
@ -102,9 +103,16 @@ typedef struct
do { \ do { \
if (_dbg_module[_MODULE_].stat) printh(_format_, ##_msg_); \ if (_dbg_module[_MODULE_].stat) printh(_format_, ##_msg_); \
} while(0) } while(0)
#define DBG_ARRAY(_MODULE_, _msg_...) \
do { \
if (dbg_stat_get(_MODULE_)) { \
buf_print(_msg_); \
}\
} while(0)
#else #else
#define DBG(_MODULE_, _msg_...) #define DBG(_MODULE_, _msg_...)
#define DBG(_MODULE_, _format_, _msg_...) #define DBG(_MODULE_, _format_, _msg_...)
#define DBG_ARRAY(_MODULE_, _msg_...)
#endif #endif
/* Extern global variables ---------------------------------------------------*/ /* Extern global variables ---------------------------------------------------*/

86
app/lib/a_process/pd_csg.c
Unescape Escape View File

@ -146,6 +146,18 @@ CMD(csg_show,
return CMD_SUCCESS; return CMD_SUCCESS;
} }
CMD(csg_upgrade_test,
csg_upgrade_test_cmd,
"upgrade test",
"Upgrade\n"
"Test\n")
{
pd_upg_start(PD_UPG_FROM_CSG, 1);
return CMD_SUCCESS;
}
void _print_sockaddr_in(const struct sockaddr_in *addr) void _print_sockaddr_in(const struct sockaddr_in *addr)
{ {
// 将IP地址从网络字节序转换为点分十进制格式 // 将IP地址从网络字节序转换为点分十进制格式
@ -379,9 +391,8 @@ void _csg_add_dau_recv(char *pkt)
return; return;
} }
slot--;
log_out(LOG_CSG, LOG_LVL_WARN, "_csg_add_dau_recv slot = %d\n", slot); log_out(LOG_CSG, LOG_LVL_WARN, "_csg_add_dau_recv slot = %d\n", slot);
daus[slot].state.is_insert = TRUE; daus[slot-1].state.is_insert = TRUE;
} }
void _csg_remove_dau_recv(char *pkt) void _csg_remove_dau_recv(char *pkt)
@ -394,10 +405,9 @@ void _csg_remove_dau_recv(char *pkt)
return; return;
} }
slot--;
log_out(LOG_CSG, LOG_LVL_WARN, "_csg_remove_dau_recv slot = %d\n", slot); log_out(LOG_CSG, LOG_LVL_WARN, "_csg_remove_dau_recv slot = %d\n", slot);
daus[slot].state.is_insert = FALSE; daus[slot-1].state.is_insert = FALSE;
daus[slot].state.is_connect = FALSE; daus[slot-1].state.is_connect = FALSE;
} }
@ -406,7 +416,7 @@ void _csg_heartbeat_recv(char *pkt)
{ {
uint32_t server_time = *(uint32_t*)(pkt + sizeof(csg_pkt_head_t)); uint32_t server_time = *(uint32_t*)(pkt + sizeof(csg_pkt_head_t));
//printf("server_time:%d now:%ld\n", server_time, time(NULL)); DBG(DBG_M_PD_CSG, "server_time:%d now:%ld\n", server_time, time(NULL));
if (abs(server_time - time(NULL)) > 3) if (abs(server_time - time(NULL)) > 3)
{ {
time_set(server_time); //北京时间 time_set(server_time); //北京时间
@ -421,7 +431,7 @@ int32_t _csg_reboot_recv(char *pkt)
uint8_t slot = head->slot; uint8_t slot = head->slot;
if (slot > PD_SLOTS_MAX) if (slot > PD_SLOTS_MAX)
{ {
DBG(DBG_M_PD_CSG, "slot:%d error\r\n", head->slot); DBG(DBG_M_PD_CSG_ERR, "slot:%d error\r\n", head->slot);
return E_BAD_PARAM; return E_BAD_PARAM;
} }
@ -463,7 +473,7 @@ int32_t _csg_dev_info_set_recv(char *pkt)
uint8_t slot = head->slot; uint8_t slot = head->slot;
if (slot > PD_SLOTS_MAX) if (slot > PD_SLOTS_MAX)
{ {
DBG(DBG_M_PD_CSG, "slot:%d error\r\n", head->slot); DBG(DBG_M_PD_CSG_ERR, "slot:%d error\r\n", head->slot);
return E_BAD_PARAM; return E_BAD_PARAM;
} }
@ -527,7 +537,7 @@ int32_t _csg_dev_info_get_recv(char *pkt)
uint8_t slot = head->slot; uint8_t slot = head->slot;
if (slot > PD_SLOTS_MAX) if (slot > PD_SLOTS_MAX)
{ {
DBG(DBG_M_PD_CSG, "slot:%d error\r\n", head->slot); DBG(DBG_M_PD_CSG_ERR, "slot:%d error\r\n", head->slot);
return E_BAD_PARAM; return E_BAD_PARAM;
} }
@ -580,7 +590,7 @@ int32_t _csg_config_set_recv(char *pkt)
uint8_t slot = head->slot; uint8_t slot = head->slot;
if (slot > PD_SLOTS_MAX) if (slot > PD_SLOTS_MAX)
{ {
DBG(DBG_M_PD_CSG, "slot:%d error\r\n", head->slot); DBG(DBG_M_PD_CSG_ERR, "slot:%d error\r\n", head->slot);
return E_BAD_PARAM; return E_BAD_PARAM;
} }
@ -630,10 +640,10 @@ int32_t _csg_config_get_recv(char *pkt)
{ {
csg_pkt_head_t *head = (csg_pkt_head_t*)pkt; csg_pkt_head_t *head = (csg_pkt_head_t*)pkt;
int *data = NULL; int *data = NULL;
uint8_t slot = head->slot - 1; uint8_t slot = head->slot;
if (slot > PD_SLOTS_MAX) if (slot > PD_SLOTS_MAX)
{ {
DBG(DBG_M_PD_CSG, "slot:%d error\r\n", head->slot); DBG(DBG_M_PD_CSG_ERR, "slot:%d error\r\n", head->slot);
return E_BAD_PARAM; return E_BAD_PARAM;
} }
@ -678,7 +688,7 @@ int32_t _csg_port_config_set_recv(char *pkt)
uint8_t slot = head->slot; uint8_t slot = head->slot;
if (slot > PD_SLOTS_MAX && slot != 0) if (slot > PD_SLOTS_MAX && slot != 0)
{ {
DBG(DBG_M_PD_CSG, "slot:%d error\r\n", head->slot); DBG(DBG_M_PD_CSG_ERR, "slot:%d error\r\n", head->slot);
return E_BAD_PARAM; return E_BAD_PARAM;
} }
DBG(DBG_M_PD_CSG, "_csg_port_config_set_recv slot:%d \r\n", head->slot); DBG(DBG_M_PD_CSG, "_csg_port_config_set_recv slot:%d \r\n", head->slot);
@ -707,7 +717,7 @@ int32_t _csg_port_config_get_recv(char *pkt)
uint8_t slot = head->slot; uint8_t slot = head->slot;
if (slot > PD_SLOTS_MAX && slot != 0) if (slot > PD_SLOTS_MAX && slot != 0)
{ {
DBG(DBG_M_PD_CSG, "slot:%d error\r\n", head->slot); DBG(DBG_M_PD_CSG_ERR, "slot:%d error\r\n", head->slot);
return E_BAD_PARAM; return E_BAD_PARAM;
} }
@ -735,9 +745,10 @@ int32_t _csg_real_image_recv(char *pkt)
uint8_t slot = head->slot; uint8_t slot = head->slot;
if (slot > PD_SLOTS_MAX && slot != 0) if (slot > PD_SLOTS_MAX && slot != 0)
{ {
DBG(DBG_M_PD_CSG, "slot:%d error\r\n", head->slot); DBG(DBG_M_PD_CSG_ERR, "slot:%d error\r\n", head->slot);
return E_BAD_PARAM; return E_BAD_PARAM;
} }
DBG(DBG_M_PD_CSG, "_csg_real_image_recv slot:%d \r\n", head->slot);
data = XMALLOC(MTYPE_CSG, sizeof(csg_real_image_get_t)); data = XMALLOC(MTYPE_CSG, sizeof(csg_real_image_get_t));
if (!data) if (!data)
@ -746,6 +757,7 @@ int32_t _csg_real_image_recv(char *pkt)
return E_MEM; return E_MEM;
} }
param->vport = param->vport % 8;
memcpy(data, param, sizeof(csg_real_image_get_t)); memcpy(data, param, sizeof(csg_real_image_get_t));
if (_csg_msg_send_dau(slot - 1, DAU_SEND_PRPS_GET, data) != E_NONE) if (_csg_msg_send_dau(slot - 1, DAU_SEND_PRPS_GET, data) != E_NONE)
{ {
@ -803,8 +815,8 @@ int32_t _csg_update_slot(uint8_t type)
{ {
dau = &daus[slot]; dau = &daus[slot];
if (dau->info.type_m == 0x03 && (dau->info.type_s == 0x01 if (dau->info.type_m == 0x03 && (dau->info.type_s == 0x01
|| dau->info.type_s == 0x02 || dau->info.type_s == 0x02
|| dau->info.type_s == 0x03)) || dau->info.type_s == 0x03))
{ {
data = XMALLOC(MTYPE_CSG, sizeof(csg_upate_msg_t)); data = XMALLOC(MTYPE_CSG, sizeof(csg_upate_msg_t));
if (!data) if (!data)
@ -824,13 +836,14 @@ int32_t _csg_update_slot(uint8_t type)
} }
snprintf(data->name, 128, "%s/%s", buff, PD_UPG_SOFTWARE); snprintf(data->name, 128, "%s/%s", buff, PD_UPG_SOFTWARE);
DBG(DBG_M_PD_CSG_ERR, "upgrade name:%s slot=%d\r\n", data->name, slot);
if (_csg_msg_send_dau(slot, DAU_SEND_UPDATE, data) != E_NONE) if (_csg_msg_send_dau(slot, DAU_SEND_UPDATE, data) != E_NONE)
{ {
XFREE(MTYPE_CSG, data); XFREE(MTYPE_CSG, data);
} }
} }
} }
return ENABLE_NODE; return E_NONE;
} }
/* 升级文件接收 */ /* 升级文件接收 */
@ -916,6 +929,30 @@ int32_t _csg_slot_match(uint8_t slot, uint8_t *type_m, uint8_t *type_s)
return E_NONE; return E_NONE;
} }
int32_t _csg_slot_is_valid(char *pkt, uint8_t *type_m, uint8_t *type_s)
{
csg_pkt_head_t *head = (csg_pkt_head_t *)pkt;
uint8_t slot = head->slot - 1;
uint8_t cmd = head->cmd;
dau_t *dau = &daus[slot];
// 如果相应卡槽不存在，暂时先不回复平台
if ( dau->state.is_insert == FALSE && cmd != CSG_C_ADD_DAU)
{
//char *pkt = csg.buf_send;
//csg_ack_t ack = {0};
//ack.result = FALSE;
//memcpy(pkt + sizeof(csg_pkt_head_t), (char *)&ack, sizeof(csg_ack_t));
//_csg_send_data(head->cmd_type, head->cmd, pkt, sizeof(csg_ack_t), slot + 1);
return E_ERROR;
}
*type_m = dau->info.type_m;
*type_s = dau->info.type_s;
return E_NONE;
}
int32_t _csg_recv_process(char *pkt, uint32_t len) int32_t _csg_recv_process(char *pkt, uint32_t len)
{ {
uint8_t typem, types; uint8_t typem, types;
@ -925,10 +962,13 @@ int32_t _csg_recv_process(char *pkt, uint32_t len)
LD_E_RETURN(DBG_M_PD_CSG_ERR, _csg_pkt_check(pkt)); LD_E_RETURN(DBG_M_PD_CSG_ERR, _csg_pkt_check(pkt));
csg.heartbeat_timeout_cnt = 0; csg.heartbeat_timeout_cnt = 0;
if (_csg_slot_match(head->slot - 1, &typem, &types) != E_NONE) if (head->slot > 0)
{ {
DBG(DBG_M_PD_CSG_ERR, "Invalid slot=%d typem=%d types=%d\n", head->slot, typem, types); if (_csg_slot_is_valid(pkt, &typem, &types) != E_NONE)
return E_ERROR; {
DBG(DBG_M_PD_CSG_ERR, "Invalid slot=%d\n", head->slot);
return E_ERROR;
}
} }
if (DEVICE_M_TYPE == typem && DEVICE_IR_TYPE == types if (DEVICE_M_TYPE == typem && DEVICE_IR_TYPE == types
@ -2296,7 +2336,8 @@ void *_csg_heartbeat_handle(void *arg)
if (dau->state.is_connect == TRUE if (dau->state.is_connect == TRUE
&& dau->state.is_insert != TRUE) && dau->state.is_insert != TRUE)
{ {
if (dau->info.type_m == 0x03 && dau->info.type_m == 0x04) if (dau->info.type_m == 0x03 && (dau->info.type_s == 0x04
|| dau->info.type_s == 0x05))
{ {
csg_contact_t info = {0}; csg_contact_t info = {0};
info.type_m = dau->info.type_m; info.type_m = dau->info.type_m;
@ -2365,6 +2406,7 @@ int32_t csg_handle_init(void)
cmd_install_element(CONFIG_NODE, &csg_server_set_cmd); cmd_install_element(CONFIG_NODE, &csg_server_set_cmd);
cmd_install_element(COMMON_NODE, &csg_show_cmd); cmd_install_element(COMMON_NODE, &csg_show_cmd);
cmd_install_element(COMMON_NODE, &csg_upgrade_test_cmd);
/* 注册配置保存函数 */ /* 注册配置保存函数 */
rv = cmd_config_node_config_register(CONFIG_PRI_CSG, _csg_config_save); rv = cmd_config_node_config_register(CONFIG_PRI_CSG, _csg_config_save);

2
app/lib/a_process/pd_dau.c
Unescape Escape View File

@ -492,7 +492,7 @@ void *_dau_state_handle(void *arg)
state->beat_cnt++; state->beat_cnt++;
if (state->beat_cnt > pd_config.config_slot[i].timeout * 60) if (state->beat_cnt > pd_config.config_slot[i].timeout * 60)
{ {
log_warn(LOG_DAU, "Slot %d remove!", i); log_warn(LOG_DAU, "Slot %d remove!", i + 1);
_dau_remove(&daus[i]); _dau_remove(&daus[i]);
} }
} }

45
app/lib/a_process/pd_modbus.c
Unescape Escape View File

@ -19,11 +19,11 @@ modbus_t modbus;
void _modbus_show(void) void _modbus_show(void)
{ {
card_t *pcard = NULL; card_t *pcard = NULL;
printh("ID ST \r\n"); printh("UNIT STATUS CURRENT ALARM\r\n");
for (int slot = 0; slot < PD_SLOTS_MAX; slot++) for (int slot = 0; slot < PD_SLOTS_MAX; slot++)
{ {
pcard = &modbus.card[slot]; pcard = &modbus.card[slot];
printh("%-02d %-02d \r\n", pcard->unit_id, pcard->status); printh("%-04d %3d %8d %6d\r\n", pcard->unit_id, pcard->status, pcard->current, pcard->alarm);
} }
} }
@ -71,8 +71,8 @@ int32_t _modbus_tcp_transaction(uint8_t unit_id, uint16_t start_addr, uint16_t d
return E_ERROR; return E_ERROR;
} }
//DBG(DBG_M_PD_MODBUS, "Modbus write len = %d\r\n", txlen); DBG(DBG_M_PD_MODBUS, "Modbus write len = %d\r\n", txlen);
//buf_print((char *)modbus.txbuf, txlen); DBG_ARRAY(DBG_M_PD_MODBUS, (char *)modbus.txbuf, txlen);
// 等待传输完成 // 等待传输完成
usleep(13000); // 13000 usleep(13000); // 13000
@ -83,8 +83,8 @@ int32_t _modbus_tcp_transaction(uint8_t unit_id, uint16_t start_addr, uint16_t d
{ {
uint16_t length; uint16_t length;
//DBG(DBG_M_PD_MODBUS, "Modbus read len = %d\r\n", rxlen); DBG(DBG_M_PD_MODBUS, "Modbus read len = %d\r\n", rxlen);
//buf_print((char *)modbus.rxbuf, rxlen); DBG_ARRAY(DBG_M_PD_MODBUS, (char *)modbus.rxbuf, rxlen);
length = modbus.rxbuf[POS_DATA_LEN] << 8; length = modbus.rxbuf[POS_DATA_LEN] << 8;
length += modbus.rxbuf[POS_DATA_LEN + 1]; length += modbus.rxbuf[POS_DATA_LEN + 1];
@ -142,8 +142,9 @@ int32_t _modbus_get_device_type(uint8_t unit, uint8_t *typem, uint8_t *types)
{ {
*typem = modbus.rxbuf[9]; *typem = modbus.rxbuf[9];
*types = modbus.rxbuf[10]; *types = modbus.rxbuf[10];
return E_NONE;
} }
return E_NONE; return E_ERROR;
} }
int32_t _modbus_get_current(uint8_t unit, uint16_t addr, uint16_t len, uint32_t *current) int32_t _modbus_get_current(uint8_t unit, uint16_t addr, uint16_t len, uint32_t *current)
@ -184,18 +185,27 @@ void _modbus_read_slot_stat(card_t *pcard)
ptmp = pcard; ptmp = pcard;
gpio_val_get(gpio_dau1_idx, &ptmp->status); gpio_val_get(gpio_dau1_idx, &ptmp->status);
ptmp++; ptmp++;
gpio_val_get(gpio_dau2_idx, &ptmp->status); gpio_val_get(gpio_dau2_idx, &ptmp->status);
ptmp++; ptmp++;
gpio_val_get(gpio_dau3_idx, &ptmp->status); gpio_val_get(gpio_dau3_idx, &ptmp->status);
ptmp++; ptmp++;
gpio_val_get(gpio_dau4_idx, &ptmp->status); gpio_val_get(gpio_dau4_idx, &ptmp->status);
ptmp++; ptmp++;
gpio_val_get(gpio_dau5_idx, &ptmp->status); gpio_val_get(gpio_dau5_idx, &ptmp->status);
ptmp++; ptmp++;
gpio_val_get(gpio_dau6_idx, &ptmp->status); gpio_val_get(gpio_dau6_idx, &ptmp->status);
} }
void crash() {
int *ptr = NULL;
*ptr = 42; // 故意触发段错误
}
void *_modbus_send_handle() void *_modbus_send_handle()
{ {
@ -207,12 +217,16 @@ void *_modbus_send_handle()
for (int slot = 0; slot < PD_SLOTS_MAX; slot++) for (int slot = 0; slot < PD_SLOTS_MAX; slot++)
{ {
pcard = &modbus.card[slot]; pcard = &modbus.card[slot];
dau = &daus[slot]; dau = &daus[slot];
//DBG(DBG_M_PD_MODBUS, "slot%d unit_id:%d status:%d\n", slot, pcard->unit_id, pcard->status);
if (pcard->status) if (pcard->status)
{ {
_modbus_get_device_type(pcard->unit_id, &dau->info.type_m, &dau->info.type_s); sleep(1);
//DBG(DBG_M_PD_MODBUS, "typem:%d types:%d\n", dau->info.type_m, dau->info.type_s); if (_modbus_get_device_type(pcard->unit_id, &dau->info.type_m, &dau->info.type_s) != E_NONE)
continue;
//DBG(DBG_M_PD_MODBUS, "slot%d typem:%d types:%d\n", slot, dau->info.type_m, dau->info.type_s);
if (DEVICE_IR_TYPE == dau->info.type_s && DEVICE_M_TYPE == dau->info.type_m) if (DEVICE_IR_TYPE == dau->info.type_s && DEVICE_M_TYPE == dau->info.type_m)
{ {
@ -221,11 +235,9 @@ void *_modbus_send_handle()
sleep(1); sleep(1);
_modbus_get_current(pcard->unit_id, _modbus_get_current(pcard->unit_id,
MODBUS_IR_CURRENT_ADDR, MODBUS_IR_CURRENT_LEN, &pcard->current); MODBUS_IR_CURRENT_ADDR, MODBUS_IR_CURRENT_LEN, &pcard->current);
//DBG(DBG_M_PD_MODBUS, "current:%d\n", pcard->current);
_modbus_get_alarm(pcard->unit_id, _modbus_get_alarm(pcard->unit_id,
MODBUS_IR_ALARM_ADDR, MODBUS_IR_ALARM_LEN, &pcard->alarm); MODBUS_IR_ALARM_ADDR, MODBUS_IR_ALARM_LEN, &pcard->alarm);
//DBG(DBG_M_PD_MODBUS, "alarm:%d\n", pcard->alarm);
} }
else if (DEVICE_DC_TYPE == dau->info.type_s && DEVICE_M_TYPE == dau->info.type_m) else if (DEVICE_DC_TYPE == dau->info.type_s && DEVICE_M_TYPE == dau->info.type_m)
{ {
@ -234,7 +246,16 @@ void *_modbus_send_handle()
sleep(1); sleep(1);
_modbus_get_current(pcard->unit_id, _modbus_get_current(pcard->unit_id,
MODBUS_DC_CURRENT_ADDR, MODBUS_DC_CURRENT_LEN, &pcard->current); MODBUS_DC_CURRENT_ADDR, MODBUS_DC_CURRENT_LEN, &pcard->current);
//DBG(DBG_M_PD_MODBUS, "current:%d\n", pcard->current); }
}
else
{
if (DEVICE_M_TYPE == dau->info.type_m &&
(DEVICE_IR_TYPE == dau->info.type_s || DEVICE_DC_TYPE == dau->info.type_s))
{
dau->state.beat_cnt = 0;
dau->state.is_connect = FALSE;
dau->state.is_insert = FALSE;
} }
} }
} }

37
app/lib/a_process/pd_upgrade.c
Unescape Escape View File

@ -59,7 +59,8 @@
/* Private define ------------------------------------------------------------*/ /* Private define ------------------------------------------------------------*/
#define PD_UPG_READ_SIZE (1024*1024) #define PD_UPG_READ_SIZE (1024*1024)
#define PD_UPG_HARDWARE_VERSON "GIS-cmu" #define PD_UPG_HARDWARE_CMU_VERSON "GIScmu"
#define PD_UPG_HARDWARE_GIS_VERSON "GIS7.0"
#define PD_UPG_DAU_FILE "/lib/firmware/system_wrapper.bin" #define PD_UPG_DAU_FILE "/lib/firmware/system_wrapper.bin"
/* Private macro -------------------------------------------------------------*/ /* Private macro -------------------------------------------------------------*/
@ -309,16 +310,18 @@ int32_t _pd_upg_upgrade(void)
return: E_NONE - 成功, E_XXXX - 失败 */ return: E_NONE - 成功, E_XXXX - 失败 */
int32_t _pd_upg_hardware_check(void) int32_t _pd_upg_hardware_check(void)
{ {
if (strncmp(pd_upg_ctrl.head.hard_ver, PD_UPG_HARDWARE_VERSON, strlen(PD_UPG_HARDWARE_VERSON))) if (strncmp(pd_upg_ctrl.head.hard_ver, PD_UPG_HARDWARE_CMU_VERSON, strlen(PD_UPG_HARDWARE_CMU_VERSON)) == 0)
{ {
DBG(DBG_M_PD_UPGRADE, "Hardware version(%s) not match\n", pd_upg_ctrl.head.hard_ver);
return E_ERROR;
} }
else else if (strncmp(pd_upg_ctrl.head.hard_ver, PD_UPG_HARDWARE_GIS_VERSON, strlen(PD_UPG_HARDWARE_GIS_VERSON)) == 0)
{ {
pd_upg_ctrl.upgrade_slot = _csg_update_slot; pd_upg_ctrl.upgrade_slot = _csg_update_slot;
} }
else
{
DBG(DBG_M_PD_UPGRADE, "Hardware version(%s) not match\n", pd_upg_ctrl.head.hard_ver);
return E_ERROR;
}
return E_NONE; return E_NONE;
} }
@ -426,6 +429,7 @@ void *_pd_upg_handle(void *parm)
{ {
char cmd[128] = {0}; char cmd[128] = {0};
int32_t rv = E_ERROR; int32_t rv = E_ERROR;
int32_t upgrade_flag = 0;
while(1) while(1)
{ {
@ -439,18 +443,27 @@ void *_pd_upg_handle(void *parm)
if (pd_upg_ctrl.upgrade_slot) if (pd_upg_ctrl.upgrade_slot)
{ {
pd_upg_ctrl.upgrade_slot(pd_upg_ctrl.upg_type); pd_upg_ctrl.upgrade_slot(pd_upg_ctrl.upg_type);
upgrade_flag = 1;
} }
else
/* 升级系统 */
rv = _pd_upg_upgrade();
if (rv != E_NONE)
{ {
break; /* 升级系统 */
rv = _pd_upg_upgrade();
if (rv != E_NONE)
{
break;
}
} }
break; break;
} }
if (upgrade_flag)
{
pd_upg_ctrl.is_start = FALSE;
pthread_exit(NULL);
return NULL;
}
/* 保存升级原始文件 */ /* 保存升级原始文件 */
snprintf(cmd, 128, "mv " PD_UPG_SOFTWARE " bak"); snprintf(cmd, 128, "mv " PD_UPG_SOFTWARE " bak");
_pd_upg_system(cmd); _pd_upg_system(cmd);

4
app/lib/m_management/dbg.c
Unescape Escape View File

@ -73,8 +73,8 @@ dbg_module_t _dbg_module[DBG_M_COUNT] =
{DBG_M_PD_HF, FALSE, "pd_hf"}, {DBG_M_PD_HF, FALSE, "pd_hf"},
{DBG_M_PD_HF_ERR, TRUE, "pd_hf_err"}, {DBG_M_PD_HF_ERR, TRUE, "pd_hf_err"},
{DBG_M_SERIAL, FALSE, "serial"}, {DBG_M_SERIAL, FALSE, "serial"},
{DBG_M_PD_MODBUS, TRUE, "pd_modbus"}, {DBG_M_PD_MODBUS, FALSE, "modbus"},
{DBG_M_PD_MODBUS_ERR, TRUE, "pd_modbus_err"}, {DBG_M_PD_MODBUS_ERR, FALSE, "modbus_err"},
{DBG_M_FILE_FIFO, TRUE, "file_fifo"}, {DBG_M_FILE_FIFO, TRUE, "file_fifo"},
{DBG_M_FILE_FIFO_ERR, TRUE, "file_fifo_err"}, {DBG_M_FILE_FIFO_ERR, TRUE, "file_fifo_err"},
}; };

Write Preview
Loading…
Cancel
Save