#include "hal_bsp.h"
#include "hal_uart.h"
#include "hal_gpio.h"
#include "hal_wdt.h"
#include "queue.h"
#include "log.h"
#include "subg_port.h"
#include "subg_link.h"
#include "device.h"
#include "tty.h"
#include <stdio.h>
#define read_low_power_pin hal_gpio_readpin(LP_TEST)
#define PACKET_HEAD (0XFE)
#define START_INDEX 0
#define LENGTH_INDEX 1
#define CMD_INDEX 2
#define STATUS_INDEX 3
#define DATA_INDEX 4
enum TEST_CMD
{
CMD_CONNECT =0X01 ,//data:?
CMD_CONNECT_RSP , //data:?
CMD_GET_HW_ID , //data:?
CMD_GET_HW_ID_RSP , //data:status + HW ID
CMD_SET_DEV_ID ,//data:DEVICE ID??????,???40
CMD_SET_DEV_ID_RSP , //data:status:1 byte,0 == success
CMD_GET_DEV_ID , //data:?
CMD_GET_DEV_ID_RSP , //data:status + DEVICE ID
CMD_SET_MAC , //data:MAC??,??6
CMD_SET_MAC_RSP , //data:status:1 byte,0 == success
CMD_GET_MAC , //data:?
CMD_GET_MAC_RSP , //data:status + MAC
CMD_SET_KEY , //data:KEY,??16
CMD_SET_KEY_RSP , //data:status:1 byte,0 == success
CMD_GET_KEY , //data:?
CMD_GET_KEY_RSP , //data:status + KEY
CMD_SET_ENC_KEY , //data:????KEY,??16
CMD_SET_ENC_KEY_RSP , //data:status:1 byte,0 == success
CMD_GET_ENC_KEY , //data:?
CMD_GET_ENC_KEY_RSP , //data:status + ENC KEY
CMD_ENTER_LOW_POWER_MODE , //data:?
CMD_ENTER_LOW_POWER_MODE_RSP , //data:?
CMD_SUB1G_RX_MODE,
CMD_SUB1G_RX_MODE_RSP,
CMD_SUB1G_TX_MODE,
CMD_SUB1G_TX_MODE_RSP,
CMD_RELAY_CONTROL,
CMD_RELAY_CONTROL_RSP,
CMD_SET_MODEL_CONF,
CMD_SET_MODEL_CONF_RSP,
CMD_GET_MODEL_CONF,
CMD_GET_MODEL_CONF_RSP,
CMD_END,
};
struct tty_pro
{
struct v_timer timer;
};
static struct tty_pro tty_pro;
struct queue *tty_rx_queue;
u32 rev_cmd_time_out;
u8 tty_low_power=0;
struct pt debug_pt;
void hal_tty_init();
void hal_tty_stop();
void hal_tty_send(u8 *buffer,u8 length);
static int cal_packet_crc(u8 * buffer,u8 length)
{
u8 pkt_crc[2];
sub1g_ll_calc_crc(pkt_crc, buffer , length);
if(sub1g_memcmp(pkt_crc, &buffer[length], 2)){
return 1;
}else{
return 0;
}
}
u8 tty_low_power_status()
{
return tty_low_power;
}
static void tty_cmd_append_crc(u8 *buffer,u8 length)
{
sub1g_ll_calc_crc(&buffer[length],buffer,length);
}
static void tty_send_packet(u8 *buffer,u8 length)
{
hal_tty_send(buffer,length);
}
static void deal_tty_cmd(u8 cmd,u8 *cmd_buffer,u8 cmd_length)
{
u8 data_length;
u8 rsp_packet[MAX_CMD_LENGTH];
u8 rsp;
u8 status;
u8 low_power,cnt;
rsp=1;
rsp_packet[START_INDEX]=PACKET_HEAD;
rsp_packet[CMD_INDEX]=cmd+1;
data_length=1;
status=0;
low_power=0;
switch(cmd){
case CMD_CONNECT:
if(rev_cmd_time_out<1000){
rev_cmd_time_out=ONE_MINUTE*5;
}
break;
case CMD_GET_HW_ID:
sub1g_memcpy(&rsp_packet[DATA_INDEX],g_hw_id,PARAM_HW_ID_LEN);
data_length+=(PARAM_HW_ID_LEN+1);
break;
case CMD_SET_DEV_ID:
status=log_save(DEVICE_ID_ENTRY_NAME,cmd_buffer,PARAM_DEVICE_ID_LEN);
data_length++;
break;
case CMD_GET_DEV_ID:
status=log_read(DEVICE_ID_ENTRY_NAME,&rsp_packet[DATA_INDEX]);
data_length+=(PARAM_DEVICE_ID_LEN+1);
break;
case CMD_SET_MAC:
status=log_save(DEVICE_MAC_ENTRY_NAME,cmd_buffer,SHIP_SUB1G_ADDR_LEN);
data_length++;
break;
case CMD_GET_MAC:
status=log_read(DEVICE_MAC_ENTRY_NAME,&rsp_packet[DATA_INDEX]);
if(status){
status=0;
for(cnt=0;cnt<SHIP_SUB1G_ADDR_LEN;cnt++){
rsp_packet[DATA_INDEX+cnt]=0;
}
}
data_length+=(SHIP_SUB1G_ADDR_LEN+1);
break;
case CMD_SET_KEY:
status=log_save(MASTER_KEY_ENTRY_NAME,cmd_buffer,PARAM_ENCRYPT_MASTER_KEY_LEN);
data_length++;
break;
case CMD_GET_KEY:
status=log_read(MASTER_KEY_ENTRY_NAME,&rsp_packet[DATA_INDEX]);
data_length+=(PARAM_ENCRYPT_MASTER_KEY_LEN+1);
break;
case CMD_SET_ENC_KEY:
status=log_save(MASTER_ENC_KEY_ENTRY_NAME,cmd_buffer,PARAM_ENCRYPT_MASTER_KEY_LEN);
data_length++;
break;
case CMD_GET_ENC_KEY:
status=log_read(MASTER_ENC_KEY_ENTRY_NAME,&rsp_packet[DATA_INDEX]);
data_length+=(PARAM_ENCRYPT_MASTER_KEY_LEN+1);
break;
case CMD_ENTER_LOW_POWER_MODE:
low_power=1;
break;
case CMD_SUB1G_RX_MODE:
low_power=2;
break;
case CMD_SUB1G_TX_MODE:
low_power=3;
break;
#ifdef SUPPORT_MODEL_CONFIG
case CMD_SET_MODEL_CONF:
device_set_model_conf(cmd_buffer,cmd_length);
status=device_get_model_conf();
data_length++;
break;
case CMD_GET_MODEL_CONF:
status=device_get_model_conf();
data_length++;
break;
#endif
default:
rsp=0;
break;
}
if(rsp){
rsp_packet[LENGTH_INDEX]=data_length+2;
if(data_length>1){
rsp_packet[STATUS_INDEX]=status;
}
tty_cmd_append_crc(&rsp_packet[LENGTH_INDEX],data_length+1);
tty_send_packet(rsp_packet,rsp_packet[LENGTH_INDEX]+2);
}
if(low_power==1){
hal_tty_stop();
subg_sleep();
tty_low_power=1;
while(1){
hal_sys_sleep(1);
}
}else if(low_power==2){
subg_rx();
}else if(low_power==3){
}
}
/*! ********************************************************
* @name deal_tty_packet
* @desc deal the input cmd
* *********************************************************/
static void deal_tty_packet(u8 packet_data)
{
static u8 cmd_status=0;
static u8 cmd_length;
static u8 cmd_buffer[MAX_CMD_LENGTH];
static u8 cmd_index;
switch(cmd_status){
case 0:
if(packet_data==PACKET_HEAD){
cmd_status=1;
}
break;
case 1:
cmd_length=packet_data;
if(cmd_length<3||cmd_length>MAX_CMD_LENGTH){
cmd_status=0;
}else{
cmd_status=2;
cmd_index=1;
cmd_buffer[0]=cmd_length;
}
break;
case 2:
if(cmd_index<=cmd_length){
cmd_buffer[cmd_index]=packet_data;
cmd_index++;
if(cmd_index==cmd_length+1){
if(cal_packet_crc(cmd_buffer,cmd_length-1)==0){
deal_tty_cmd(cmd_buffer[1],&cmd_buffer[2],cmd_length-3);
}
cmd_status=0;
}
}
break;
default:
break;
}
}
/*! ********************************************************
* @name tty_thread
* @desc tty_thread
* *********************************************************/
#define INVALID_U32 (123456789)
#define MAX_CMD_LENGTH 64
#define CMD_END_CHAR ('\r')
#define BACK_CHAR (0X08)
#define DELETE_CHAR (0X7F)
#define MAX_SUPPORT_CMD_HISTORY (10)
#define PRODUCT_CODE "DEMO"
#define $PS1 "root:"PRODUCT_CODE" "
#define HAL_OK (0)
#define HAL_POINTER_ERROR (2)
#define HAL_LENGTH_ERROR (3)
#define HAL_PARA_ERROR (4)
#define HAL_MIS_ERROR (5)
#define HAL_TIME_OUT_ERROR (6)
#define HAL_LIMIT_ERROR (7)
#define HAL_NO_MEM_ERROR (8)
#define HAL_NO_CMD_ERROR (9)
#define HAL_PACKET_ERROR (10)
#define HAL_SY_EVENT_STOP (11)
#define HAL_NO_SUPPORT_ERROR (12)
#define HAL_DEV_ERROR (13)
#define HAL_STATUS_REPEAT (14)
#define HAL_NOT_FIND_ERROR (15)
#define HAL_IPC_ADD_UNREACH (16)
#define HAL_NO_EXIST (-158)
#ifdef DEBUG_NO_PASSWD
int debug_auth;
#else
int debug_auth;
#endif
LIST_HEAD(cmd_list);
static int cmd_number;
//struct wake_lock_t debug_wake_lock;
//struct queue* tty_rx_queue;
static const u8* tty_password="admin";
static u8 g_cmd_buffer[MAX_CMD_LENGTH+1];
static const u8 history_direct[4][3]={
{0X1B,0x5B,0x41},//up
{0X1B,0x5B,0x42},//down
{0X1B,0x5B,0x44},//left
{0X1B,0x5B,0x43}//right
};
struct cmd_info cmd_queue[MAX_SUPPORT_CMD_HISTORY];
int cmd_queue_index,cmd_queue_number,cmd_history_index;
int g_cmd_cursor_index,cmd_move,g_cmd_index,g_fresh_cmd_line;
static int deal_root(const u8 * name,u8 *cmd,int length);
int debug_log_level;
static void debug_task();
void assert_failed(u8* file, u32 line)
{
printf("Wrong parameters value: file %s on line %d\r\n", file, line);
while(1);
}
static void debug_rx_data(u8 data,int id)
{
write_queue(tty_rx_queue,&data);
//schedule_work(&debug_work);
}
static void my_cp_str(u8 *dest,const u8 *source,u8 length)
{
int cnt;
for(cnt=0;cnt<length;cnt++){
dest[cnt]=source[cnt];
}
}
static int my_com_str(const u8 *source,const u8 *dest,u8 length)
{
int result;
int cnt;
result=0;
for(cnt=0;cnt<length;cnt++){
if(*source!=*dest){
result=1;
break;
}
source++;
dest++;
}
return result;
}
static int my_com_str1(const u8 *source,const u8 *dest)
{
int result;
int cnt;
result=0;
while(1){
if(*source==0||*dest==0){
break;
}
if(*source!=*dest){
result=1;
break;
}
source++;
dest++;
}
return result;
}
static int my_com_str2(const u8 *source,const u8 *dest,u8 *length)
{
int result;
int cnt;
result=0;
cnt=0;
while(1){
if(*source==0||*dest==0){
if(*dest){
result=1;
}else{
*length=cnt;
}
break;
}
if(*source!=*dest){
result=1;
*length=cnt;
break;
}
source++;
dest++;
cnt++;
}
return result;
}
int my_convert_str_to_u32(u8 *str,u8 length)
{
u8 cnt;
u32 number;
number=0;
for(cnt=0;cnt<length;cnt++){
if('0'<=str[cnt]&&'9'>=str[cnt]){
number=number*10+(str[cnt]-'0');
}else{
return -1;
}
}
return number;
}
int my_convert_str_to_u321(u8 *str,int* start_index,u8 max_index,u8 guard)
{
int cnt;
int number;
number=0;
cnt=*start_index;
while(str[cnt]!=guard&&cnt<max_index){
if('0'<=str[cnt]&&'9'>=str[cnt]){
number=number*10+(str[cnt]-'0');
}else{
number=INVALID_U32;
break;
}
cnt++;
}
*start_index=cnt+1;
return number;
}
static int deal_cmd(u8* cmd,int length)
{
int result=HAL_NO_EXIST;
struct debug_cmd_info *tmp;
u8 cmd_index;
list_for_each_entry(tmp, &cmd_list,head) {
if(my_com_str2(cmd,tmp->cmd,&cmd_index)==0){
result=tmp->parse(tmp->cmd,&cmd[cmd_index],length-cmd_index);
break;
}
}
return result;
}
static void printf_cmd_list()
{
struct debug_cmd_info *tmp;
int cnt;
printf("Support %d cmd\r\n",cmd_number);
printf("Use help=[cmd index] to show cmd help,if it have\r\n");
cnt=0;
list_for_each_entry(tmp, &cmd_list,head) {
printf("Cmd[%d]:%s",cnt,tmp->cmd);
if(tmp->help){
printf(" (have help)\r\n");
}else{
printf("\r\n");
}
cnt++;
}
}
static void cmd_help(u8 *data,u8 len)
{
int cnt,cmd_index;
struct debug_cmd_info *tmp;
if(len==0){
printf_cmd_list();
}else{
if(len<2||data[0]!='='){
goto fromat_error ;
}
cmd_index=my_convert_str_to_u32(&data[1],len-1);
if(cmd_index==-1){
goto fromat_error ;
}
if(cmd_index>=cmd_number){
printf("Wrong index\r\n");
return;
}
cnt=0;
list_for_each_entry(tmp, &cmd_list,head) {
if(cnt==cmd_index){
if(tmp->help){
printf("Cmd:%s,%s\r\n",tmp->cmd,tmp->help);
}else{
printf("Cmd:%s,no help\r\n",tmp->cmd);
}
return;
}
cnt++;
}
fromat_error:
printf("help format error\r\n");
}
}
/*! ********************************************************
* @name parse_tty_cmd
* @desc deal the input cmd
* *********************************************************/
static int parse_tty_cmd(u8* cmd,u8 length)
{
int result=1;
u8 temp;
if(length>1){
if(my_com_str2(cmd,"help",&temp)==0){
cmd_help(&cmd[temp],length-temp);
result=0;
}else{
if(1){
result=deal_cmd(cmd,length);
if(result==HAL_NO_EXIST){
printf("Don't support this cmd,enter help to show support cmd\r\n");
}
}else{
if(my_com_str1(cmd,"root=")==0){
deal_cmd(cmd,length);
}
}
}
}
return result;
}
void enqueue_cmd(u8 *cmd,u8 length)
{
my_cp_str(&cmd_queue[cmd_queue_index].cmd,cmd,length);
cmd_queue[cmd_queue_index].cmd_index=length;
cmd_queue[cmd_queue_index].valid=1;
cmd_queue_index =(cmd_queue_index+1)%MAX_SUPPORT_CMD_HISTORY;
if(cmd_queue_number<MAX_SUPPORT_CMD_HISTORY){
cmd_queue_number++;
}
}
void move_cmd_history_index(u8 up)
{
int next_index;
if(cmd_queue_number){
if(up){
cmd_history_index=(cmd_history_index+1)%cmd_queue_number;
}else{
if(cmd_history_index>0){
cmd_history_index=cmd_history_index-1;
}else{
cmd_history_index=cmd_queue_number-1;
}
}
}
}
int retrieve_historycmd(u8 *cmd,u8 *length)
{
int result;
result=0;
if(cmd_queue_number){
if(cmd_queue[cmd_history_index].valid){
*length=cmd_queue[cmd_history_index].cmd_index;
my_cp_str(cmd,&cmd_queue[cmd_history_index].cmd,*length);
result=1;
}
}
return result;
}
void printf_current_cmd(u8 *cmd,u8 length)
{
int cnt;
for(cnt=0;cnt<length;cnt++){
putchar(cmd[cnt]);
}
}
void printf_bank(u8 length)
{
int cnt;
for(cnt=0;cnt<length;cnt++){
putchar(0X20);
}
}
void printf_delete(u8 length)
{
int cnt;
for(cnt=0;cnt<length;cnt++){
putchar(DELETE_CHAR);
}
}
void printf_back(u8 length)
{
int cnt;
for(cnt=0;cnt<length;cnt++){
putchar(0X08);
}
}
void printf_char(u8 *cmd,u8 length)
{
int cnt;
for(cnt=0;cnt<length;cnt++){
putchar(cmd[cnt]);
}
}
int deal_cmd_history(u8 input)
{
static u8 history_char_cnt;
static u8 history_char[3];
u8 temp_cnt,need_last_index,need_cur_index;
int history_index;
u32 time;
if(input==0X1B){
history_char[0]=input;
history_char_cnt=1;
}else if(input==0x5B){
if(history_char_cnt==1){
history_char[history_char_cnt]=input;
history_char_cnt++;
}else{
history_char_cnt=0;
}
}else if(input==0x41||input==0x42||input==0x43||input==0x44){
if(history_char_cnt==2){
history_char[history_char_cnt]=input;
history_char_cnt++;
}else{
history_char_cnt=0;
}
}else{
history_char_cnt=0;
}
if(history_char_cnt==3){
time= hal_get_ms_tick();
if(time%2){
need_last_index=2;
}else{
need_last_index=3;
}
if(time%10>=5){
need_cur_index=2;
}else{
need_cur_index=3;
}
for(history_index=-1;history_index<3;history_index++){
if(my_com_str(history_char,history_direct[history_index+1],3)==0){
break;
}
}
if(history_index!=3){
history_index++;
printf_char(history_char,3);
switch(history_index){
case 0:
move_cmd_history_index(0);
if(retrieve_historycmd(g_cmd_buffer,&temp_cnt)){
putchar('\n');
printf_delete(g_cmd_index+temp_cnt);
g_cmd_index=temp_cnt;
g_cmd_cursor_index=g_cmd_index;
g_fresh_cmd_line=1;
}
break;
case 1:
move_cmd_history_index(1);
if(retrieve_historycmd(g_cmd_buffer,&temp_cnt)){
printf_delete(g_cmd_index+temp_cnt);
g_cmd_index=temp_cnt;
g_cmd_cursor_index=g_cmd_index;
g_fresh_cmd_line=1;
}
break;
case 2:
if(g_cmd_cursor_index>0){
g_cmd_cursor_index--;
}
break;
case 3:
if(g_cmd_cursor_index<g_cmd_index){
g_cmd_cursor_index++;
}
break;
}
}
}
return history_char_cnt;
}
void move_cmd_buffer_right(u8 *cmd_buffer,u8 h_index,u8 cmd_tail_index)
{
int i;
for(i=cmd_tail_index-1;i>=h_index;i--){
cmd_buffer[i+1]=cmd_buffer[i];
}
}
void move_cmd_buffer_left(u8 *cmd_buffer,u8 h_index,u8 cmd_tail_index)
{
int i;
for(i=h_index;i>1&&i<cmd_tail_index;i++){
cmd_buffer[i-1]=cmd_buffer[i];
}
}
void printf_cmd(u8 *cmd_buffer,u8 length,u8 cursor_index)
{
printf_char(cmd_buffer,length);
printf_back(length-cursor_index);
}
void fresh_cmd_line()
{
printf_cmd(g_cmd_buffer,g_cmd_index,g_cmd_cursor_index);
}
int debug_regist_cmd(struct debug_cmd_info* info,int len)
{
int cnt;
for(cnt=0;cnt<len;cnt++){
list_add(&info[cnt].head,&cmd_list);
cmd_number++;
}
return cmd_number;
}
static int deal_logl(const u8 * name,u8 *cmd,int length)
{
int new_logl;
new_logl=my_convert_str_to_u32(cmd,length);
if(new_logl>=0&&new_logl<=5){
debug_log_level=new_logl;
printf("new logl=%d\r\n",debug_log_level);
}else{
printf("logl value invalid value:%d,valid value:0-5\r\n",new_logl);
}
return 0;
}
static int deal_root(const u8 * name,u8 *cmd,int length)
{
if(my_com_str(cmd,tty_password,length)==0){
printf("auth ok\r\n");
debug_auth=1;
} else{
printf("wrong passwd\r\n");
}
return 0;
}
static int deal_clear(const u8 * name,u8 *cmd,int length)
{
printf("\033[H""\033[J");
return HAL_OK;
}
static int deal_test(const u8 * name,u8 *cmd,int length)
{
printf("test success!\r\n");
return 0;
}
struct debug_cmd_info tty_cmd[]=
{
{
.cmd="test=",
.help=NULL,
.parse=deal_test,
},
};
static PT_THREAD (debug_thread(struct pt *pt))
{
u8 input;
int result;
PT_BEGIN(pt);
while(read_queue(tty_rx_queue,&input)==QUEUE_TRUE){
result=deal_cmd_history(input);
if(g_fresh_cmd_line){
g_fresh_cmd_line=0;
fresh_cmd_line();
}
if(result==0){
if(input!=CMD_END_CHAR){
if(g_cmd_index<MAX_CMD_LENGTH){
if(g_cmd_cursor_index!=g_cmd_index){
if(input==BACK_CHAR){
move_cmd_buffer_left(g_cmd_buffer,g_cmd_cursor_index,g_cmd_index);
if(g_cmd_cursor_index>0){
g_cmd_cursor_index--;
g_cmd_index--;
}
printf_bank(g_cmd_index-g_cmd_cursor_index);
printf_delete(1);
putchar('\r');
fresh_cmd_line();
}else{
move_cmd_buffer_right(g_cmd_buffer,g_cmd_cursor_index,g_cmd_index);
g_cmd_buffer[g_cmd_cursor_index]=input;
g_cmd_cursor_index++;
g_cmd_index++;
putchar('\r');
fresh_cmd_line();
}
}else{
if(input==BACK_CHAR){
printf_delete(1);
if(g_cmd_index>0){
g_cmd_index--;
g_cmd_cursor_index=g_cmd_index;
}
}else{
putchar(input);
g_cmd_buffer[g_cmd_index]=input;
g_cmd_index++;
g_cmd_cursor_index=g_cmd_index;
}
}
}else{
g_cmd_index=0;
g_cmd_cursor_index=g_cmd_index;
printf("Cmd too long\r\n");
}
}else{
//wake_lock_timeout(&debug_wake_lock,ONE_SECOND*10);
printf("\r\n");
g_cmd_buffer[g_cmd_index]=0;
cmd_move=0;
if(parse_tty_cmd(g_cmd_buffer,g_cmd_index)==0){
enqueue_cmd(g_cmd_buffer,g_cmd_index);
cmd_history_index=cmd_queue_index;
}
g_cmd_index=0;
g_cmd_cursor_index=g_cmd_index;
printf($PS1);
}
}
}
PT_END(pt);
}
static PT_THREAD (tty_thread(struct pt *pt))
{
static u8 input;
static struct v_timer count_timer;
hal_tty_init();
rev_cmd_time_out=500;
v_timer_update(&count_timer,NULL);
while(v_timer_wait_ms(&count_timer,rev_cmd_time_out,0)==0){
if(read_queue(tty_rx_queue,&input)==QUEUE_TRUE){
deal_tty_packet(input);
}
hal_wdt_feed();
}
hal_tty_stop();
}
/*! ********************************************************
* @name led_init
* @desc Init the led module;
* *********************************************************/
void tty_init()
{
hal_tty_init();
tty_rx_queue=new_queue(sizeof(u8),MAX_CMD_LENGTH*2);
debug_regist_cmd(tty_cmd,ARRAY_SIZE(tty_cmd));
if(tty_rx_queue==NULL){
log_d("tty creat queue fail\r\n");
}else{
log_d("tty creat queue success!!!!\r\n");
}
}
/*! ********************************************************
* @name led_task
* @desc led task
* *********************************************************/
void tty_task()
{
hal_wdt_feed();
PT_SCHEDULE(debug_thread(&debug_pt));
}帮我解析下这个函数,并且取名为tty.c