void cmd_set_real_time(char *par)
{
/*
exemplo "SET 100.........!" //Configura apenas a porcentagem do dimmer 0
exemplo "SET ...100......!" //Configura apenas a porcentagem do dimmer 1
exemplo "SET ......100...!" //Configura apenas a porcentagem do dimmer 2
exemplo "SET .........1..!" //Configura apenas o rele 0 (Liga)
exemplo "SET .........0..!" //Configura apenas o rele 0 (Desliga)
exemplo "SET ..........1.!" //Configura apenas o rele 1 (Liga)
exemplo "SET ..........0.!" //Configura apenas o rele 1 (Desliga)
exemplo "SET ...........1!" //Configura apenas o rele 2 (Liga)
exemplo "SET ...........0!" //Configura apenas o rele 2 (Desliga)
*/
char str[30],i;
memset(str,0,sizeof(str));
strcat(str,"SET ");
strcat(str,par);
for(i=0;i<sizeof(str);i++)
if(str[i] == '\r' || str[i] == '\n' || str[i] == '!')
str[i] = 0;
uart_putString(UART_LINK_LPC,str);
uart_putString(UART_LINK_LPC,"!\0");
sprintf(buf_tx,"OK");
}
void cmd_type_dim(char *par)
{
char str[20], cfg = __FALSE;
memset(str,0,sizeof(str));
switch(par[0])
{ /*TDI 00 (Dimmer 0 On/Off) ou TDI 01 (Dimmer 0 Dimerizável)*/
case '0': strcpy(str, par[1] == '1' ? "1\0" : "0\0");
fwrite_line(str, FILE_CFG_CFG, LINE_TYPE_DIM0);
strcpy(type_dim0,str);
strcpy(str, par[1] == '1' ? "TDI 01\0" : "TDI 00\0");
cfg = __TRUE;
break;
/*TDI 10 (Dimmer 1 On/Off) ou TDI 11 (Dimmer 1 Dimerizável)*/
case '1': strcpy(str, par[1] == '1' ? "1\0" : "0\0");
fwrite_line(str, FILE_CFG_CFG, LINE_TYPE_DIM1);
strcpy(type_dim1,str);
strcpy(str, par[1] == '1' ? "TDI 11\0" : "TDI 10\0");
cfg = __TRUE;
break;
/*TDI 20 (Dimmer 2 On/Off) ou TDI 21 (Dimmer 2 Dimerizável)*/
case '2': strcpy(str, par[1] == '1' ? "1\0" : "0\0");
fwrite_line(str, FILE_CFG_CFG, LINE_TYPE_DIM2);
strcpy(type_dim2,str);
strcpy(str, par[1] == '1' ? "TDI 21\0" : "TDI 20\0");
cfg = __TRUE;
break;
case '?': sprintf(buf_tx,"TDI %u %u %u", atoi(type_dim0), atoi(type_dim1), atoi(type_dim2));
if(rcv_cmd == RCV_CMD_UART_2)
{
uart_putString(UART_LINK_LPC,buf_tx);
uart_putString(UART_LINK_LPC,"!\0");
}
break;
default: sprintf(buf_tx,"ERROR %u",ERROR_PARAMETER);
return;
}
if(cfg)
{
uart_putString(UART_LINK_LPC,str);
uart_putString(UART_LINK_LPC,"!\0");
sprintf(buf_tx,"OK");
}
printf("[Type Dimmer's config: 0:%s..1:%s..2:%s]\r",atoi(type_dim0) ? "DIMMER":"ONOFF",
atoi(type_dim1) ? "DIMMER":"ONOFF",
atoi(type_dim2) ? "DIMMER":"ONOFF");
fflush(stdout);
}
/*****************************************************************************
Função que ativa manualmente os rele´s da placa do dimmer
*****************************************************************************/
void cmd_rel(char *par)
{
/*
exemplo "SET .........1..!" //Configura apenas o rele 0 (Liga)
exemplo "SET .........0..!" //Configura apenas o rele 0 (Desliga)
exemplo "SET ..........1.!" //Configura apenas o rele 1 (Liga)
exemplo "SET ..........0.!" //Configura apenas o rele 1 (Desliga)
exemplo "SET ...........1!" //Configura apenas o rele 2 (Liga)
exemplo "SET ...........0!" //Configura apenas o rele 2 (Desliga)
*/
switch(par[0])
{
case '0': /*Rele 0*/
sprintf(buf_tx,"SET .........%c..!",(par[1] == '0') ? '0':'1');
break;
case '1': /*Rele 1*/
sprintf(buf_tx,"SET ..........%c.!",(par[1] == '0') ? '0':'1');
break;
case '2': /*Rele 2*/
sprintf(buf_tx,"SET ...........%c!",(par[1] == '0') ? '0':'1');
break;
default:
sprintf(buf_tx,"ERROR %u",ERROR_PARAMETER);
return;
}
printf("%s\r",buf_tx);
fflush(stdout);
uart_putString(UART_LINK_LPC,buf_tx);
sprintf(buf_tx,"OK");
}
/*****************************************************************************
Envia o mesmo IR repetidamente
*****************************************************************************/
void repeat_IR(char *str_IdIr, char qtd_interval_100ms, char time_start_100ms)
{
char i, cont=0, start=0;
memset(buf_rx,0,sizeof(buf_rx));
NVIC_EnableIRQ(UART2_IRQn); /*Habilita a interrupção serial para receber a tecla despressionada (TOU 000)*/
while(1)
{
/*Sai do laço caso a tecla deixe de ser pressionada ou aconteça algum erro ao enviar o IR*/
if(strstr(buf_rx,"TOU 000") || buf_tx[0] == 'E')
break;
else
cmd_ir_send(str_IdIr); /*Envia o IR localizado no endereço recebido pela função*/
wdt_feed();
if(!start) /*Apenas na inicialização*/
{
if(time_start_100ms) /*Existe tempo de start para o IR*/
{
while(1) /*Loop para da um tempo minimo para o primeiro IR enviado*/
{
/*Contagem de tempo para comparação com o tempo de Start*/
timer_poll();
if(tick)
if(++cont >= time_start_100ms)break;
}
}
start = 1;
}
/*Continua no laço caso não tenha intervalo de repetição*/
if(!qtd_interval_100ms)
continue;
/*Contagem de tempo para comparação com o intervalo de repetição*/
cont=0;
while(1)
{
wdt_feed();
timer_poll();
if(tick)
if(++cont >= qtd_interval_100ms) /*No primeiro IR demora um pouco mais*/
break;
}
}
NVIC_DisableIRQ(UART2_IRQn); /*Desabilita novamente a interrupção serial*/
memset(buf_rx,0,sizeof(buf_rx));
for(i=TOUCH_0;i<=TOUCH_15;i++) /*Loop para desligar todos os leds 4x4*/
out_leds &= ~(1<<i);
touch_led_press = TOUCH_NONE;
if(buf_tx[0] == 'E') /*Houve algum erro ao enviar o IR?*/
{
beep(BEEP_ERROR);
strcat(buf_tx,"\r\r\0");
uart_putString(0,buf_tx); /*String de erro*/
}
}
/*****************************************************************************
Função que arma a cena recebida pela função
*****************************************************************************/
void cmd_run_scene(char *par)
{
char addr;
addr = atoi(par);
if(addr >= NUM_SCENE) /*Endereço da cena incorreto?*/
sprintf(buf_tx,"ERROR %u",ERROR_PARAMETER);
else
{
/*Envia imediatamente para o LPC1113 a cena de endereço 'addr' */
uart_putString(UART_LINK_LPC,scene[addr]);
uart_putString(UART_LINK_LPC,"!\0");
strcpy(current_scene,scene[addr]); /*Copia para a cena atual*/
current_id_scene = addr;
sprintf(buf_tx,"%s%u",scene[addr],current_id_scene);
}
}
static ER DbgSys_MsgReceive(CHAR* pMsg)
{
UINT32 nCnt;
CHAR* pDst;
CHAR* pSrc = pMsg;
tMSDCVENDOR_CTRL* pCtrl = MsdcVendorNvt_GetCtrl();
tMSDCVENDOR_HOST_INFO* pHost = &pCtrl->tHostInfo;
tMSDCVENDOR_DBGSYS_CTRL* pDbgSys = &pCtrl->tDbgSys;
UINT32 nMaxLen = pDbgSys->PayloadSize-1;
pDst = (CHAR*)pDbgSys->Queue[pDbgSys->iMsgIn].pMsg;
nCnt = 0;
while((*pMsg)!=0 && nMaxLen--)
{
*(pDst++) = *(pMsg++);
nCnt++;
}
*pDst = 0;
nCnt++;
DbgSys_Lock();
pDbgSys->Queue[pDbgSys->iMsgIn].nUsedBytes = nCnt;
pDbgSys->iMsgIn = (pDbgSys->iMsgIn+1)&pDbgSys->MsgCntMask;
DbgSys_UnLock();
if(!pDbgSys->bNoOutputUart)
uart_putString(pSrc);
//Check Next Payload is Empty
nCnt = pDbgSys->Queue[pDbgSys->iMsgIn].nUsedBytes;
if(pDbgSys->iMsgIn==pDbgSys->iMsgOut && nCnt!=0)
{
INT32 nRetry = 200; //Retry 2 sec for Crash Detect
//Wait to Free Payload by PC Getting
while(pDbgSys->iMsgIn==pDbgSys->iMsgOut && nRetry--)
TimerDelayMs(10);
if(nRetry<0)
{
DbgSys_Close((tDBGSYS_RESPONSE*)pHost->pPoolMem);
debug_err(("^RDbgSys_MsgReceive Closed, due to buffer not empty,pDbgSys->iMsgIn=%d\r\n",pDbgSys->iMsgIn));
return E_OK;
}
}
return E_OK;
}
/*****************************************************************************
Função que configura as cenas contidas no cartão sd
*****************************************************************************/
void cmd_scene(char *par)
{
char i,addr,erro = __FALSE, str[30];
if(par[0] == '?') /*Solicitando a alguma cena?*/
{
if(par[1] >= '0' && par[1] <= '3') /*Cenas de 0 a 3?*/
{
if(read_scene(par[1]-48,FILE_DIMMER_SCENE))
sprintf(buf_tx,"%s%u",aux_scene,par[1]-48);
else
sprintf(buf_tx,"ERROR %u",ERROR_SD);
}else
{
sprintf(buf_tx,"%s%u", (current_scene[0]==0) ? "SET 0000000000007" : current_scene, current_id_scene);
if(strcmp(current_scene,scene[current_id_scene])/*strlen(current_scene) < 15*/)
sprintf(current_scene,"%s%u",scene[current_id_scene], current_id_scene);
}
return;
}
memset(str,0,sizeof(str));
strncpy(str,par,17); /*Cena ex: 0SET 020020020000*/
addr = str[0]-48;
for(i=0;i<20;i++) /*Loop para eliminar o id da cena da string...Ex: SET 020020020000*/
str[i] = str[i+1];
for(i=4;i<16;i++) /*Loop para verificar possiveis erros de parâmetro*/
{
if(str[i] < '0' || str[i] > '9' || addr > 7)
erro = __TRUE;
if(str[i] == '\r' || str[i] == '\n') /*Elimina caracteres indesejados da cena*/
str[i] = 0;
}
//printf("str:%s\r",str);
//fflush(stdout);
if(strlen(str) != 16 || !strstr(str,"SET") || erro) /*Há erro?*/
sprintf(buf_tx,"ERROR %u",ERROR_PARAMETER);
else
{
if(save_scene(str,addr)) /*A cena foi salva no cartão sd?*/
{
init_scene(addr); /*Lê a cena para se certificar que foi escrita no sd*/
sprintf(buf_tx,"%s%u",scene[addr],addr);
if(rcv_cmd == RCV_CMD_UART_0)
{
/*Envia imediatamente para o LPC1113 a alteração da cena 'addr' */
uart_putString(UART_LINK_LPC,scene[addr]);
uart_putString(UART_LINK_LPC,"!\0");
strcpy(current_scene,scene[addr]); /*Copia para a cena atual*/
current_id_scene = addr;
}else
{
printf("Cena %u configurada: %s\r",addr,str);
fflush(stdout);
}
}else
sprintf(buf_tx,"ERROR %u",ERROR_SD); /*Error permitido para cartão SD*/
}
}
/*****************************************************************************
Função que recebe o touch pressionado do capacitivo 4x4
*****************************************************************************/
void cmd_rcv_touch(char *par)
{
char i,touch,str_IdIr[4],str_aux[50],flag_send_ir = __TRUE;
memset(str_IdIr,0,sizeof(str_IdIr));
memset(str_aux,0,sizeof(str_aux));
str_IdIr[0] = par[1];
str_IdIr[1] = par[2];
touch = atoi(str_IdIr);
if(!(touchEnaDis & (1<<touch)))
return;
NVIC_DisableIRQ(UART2_IRQn);
NVIC_DisableIRQ(UART0_IRQn);
if(touch > 23 && (par[0]-48))
{
sprintf(buf_tx,"ERROR %u",ERROR_PARAMETER);
return;
}
if(par[0] - 48) /*Transforma em inteiro*/
{
/*Desliga led anterior (IRs) caso ainda esteja ligado*/
for(i=TOUCH_0;i<=TOUCH_23;i++)
{
if(i == TOUCH_11 && !ir_state.bit.PwrPainel)
out_leds |= (1<<TOUCH_11);
else
out_leds &= ~(1 << i);
}
touch_led_press = touch;
out_leds |= (1 << touch_led_press);
atualiza_saidas();
if(rcv_cmd != RCV_CMD_TCP_CLIENT && rcv_cmd != RCV_CMD_TCP_SERVER)
beep(BEEP_PULSO);
/*(TV)->ID0:Source...ID1:CH-...ID2:CH+...ID3:ON...ID4:OFF...ID5:Vol-...ID6:Vol+*/
/*(HOME)->ID7:Source...ID8:VOL-...ID9:VOL+...ID10:ON...ID11:OFF...ID12:PLAY...ID13:PAUSE...ID14:BACK...ID15:NEXT*/
/*ID16: Cursor Left...ID17: Cursor Righ...ID18: Cursor Down*/
/*(AR)->ID19:16°...ID20:17°............ID33:30°...ID34:ON...ID35:OFF..ID36:SWING ON..ID37:SWING OFF*/
if(touch == TOUCH_0) /*Touch referente ao Power da TV*/
{
if(!ir_state.bit.PwrTv)strcpy(str_IdIr,ADDR_TV_ON); /*IR power tv on*/
else strcpy(str_IdIr,ADDR_TV_OFF); /*IR power tv off*/
ir_state.bit.PwrTv = !ir_state.bit.PwrTv;
sprintf(str_aux,"[Touch (%u) POWER %s TV]\r",touch,(ir_state.bit.PwrTv) ? "ON":"OFF"); /*String para debug*/
}else
if(touch == TOUCH_1) /*Touch referente ao Source da TV*/
{
strcpy(str_IdIr,ADDR_TV_SCR); /*IR source tv*/
sprintf(str_aux,"[SOURCE TV]\r"); /*String para debug*/
}else
if(touch == TOUCH_2) /*Touch referente ao CH- da TV*/
{
strcpy(str_IdIr,ADDR_TV_CH_DOWN); /*IR ch- tv*/
sprintf(str_aux,"[CH- TV]\r"); /*String para debug*/
}else
if(touch == TOUCH_3) /*Touch referente ao CH+ da TV*/
{
strcpy(str_IdIr,ADDR_TV_CH_UP); /*IR ch+ tv*/
sprintf(str_aux,"[CH+ TV]\r"); /*String para debug*/
}else
if(touch == TOUCH_4) /*Touch referente ao Power Home*/
{
if(!ir_state.bit.PwrHome)strcpy(str_IdIr,ADDR_HOME_ON); /*IR Power home on*/
else strcpy(str_IdIr,ADDR_HOME_OFF); /*IR Power home off*/
ir_state.bit.PwrHome = !ir_state.bit.PwrHome;
sprintf(str_aux,"[POWER %s HOME]\r",(ir_state.bit.PwrHome) ? "ON":"OFF"); /*String para debug*/
}else
if(touch == TOUCH_5) /*Touch referente ao Source do Home*/
{
strcpy(str_IdIr,ADDR_HOME_SCR); /*IR source home*/
sprintf(str_aux,"[SOURCE HOME]\r"); /*String para debug*/
}else
if(touch == TOUCH_6) /*Touch referente ao Volume- da Tv*/
{
strcpy(str_IdIr,ADDR_TV_VOL_DOWN); /*IR vol- tv*/
sprintf(str_aux,"[VOL- TV]\r"); /*String para debug*/
/*Envia repetidamente o IR apenas se pressionar no teclado. Pelo software executa o IR apenas uma vez*/
if(rcv_cmd == RCV_CMD_UART_2)
{
repeat_IR(str_IdIr,0,5); /*ID, Intervalo de repetição(n*100ms) e Intervalo start(ms)*/
flag_send_ir = __FALSE;
}
}else
if(touch == TOUCH_7) /*Touch referente ao Volume+ da Tv*/
{
strcpy(str_IdIr,ADDR_TV_VOL_UP); /*IR vol+ tv*/
sprintf(str_aux,"[VOL+ TV]\r"); /*String para debug*/
/*Envia repetidamente o IR apenas se pressionar no teclado. Pelo software executa o IR apenas uma vez*/
if(rcv_cmd == RCV_CMD_UART_2)
{
repeat_IR(str_IdIr,0,5); /*ID, Intervalo de repetição(n*100ms) e Intervalo start(ms)*/
flag_send_ir = __FALSE;
}
}else
if(touch == TOUCH_8) /*Touch referente ao cursor Left do Home*/
{
strcpy(str_IdIr,ADDR_HOME_LEFT); /*IR left home*/
sprintf(str_aux,"[LEFT HOME]\r"); /*String para debug*/
/*Envia repetidamente o IR apenas se pressionar no teclado. Pelo software executa o IR apenas uma vez*/
if(rcv_cmd == RCV_CMD_UART_2)
{
repeat_IR(str_IdIr,0,5); /*ID, Intervalo de repetição(n*100ms) e Intervalo start(ms)*/
flag_send_ir = __FALSE;
}
ir_state.bit.PlayPause = __FALSE; /*Deixa a tecla Play/Pause preparada para enviar o play caso pressionada*/
}else
if(touch == TOUCH_9) /*Touch referente ao cursor Righ do Home*/
{
strcpy(str_IdIr,ADDR_HOME_RIGH); /*IR righ home*/
sprintf(str_aux,"[RIGH HOME]\r"); /*String para debug*/
/*Envia repetidamente o IR apenas se pressionar no teclado. Pelo software executa o IR apenas uma vez*/
if(rcv_cmd == RCV_CMD_UART_2)
{
repeat_IR(str_IdIr,0,5); /*ID, Intervalo de repetição(n*100ms) e Intervalo start(ms)*/
flag_send_ir = __FALSE;
}
ir_state.bit.PlayPause = __FALSE; /*Deixa a tecla Play/Pause preparada para enviar o play caso pressionada*/
}else
if(touch == TOUCH_10) /*Touch referente ao Volume- do Home*/
{
strcpy(str_IdIr,ADDR_HOME_VOL_DOWN); /*IR vol- home*/
sprintf(str_aux,"[VOL- HOME]\r"); /*String para debug*/
/*Envia repetidamente o IR apenas se pressionar no teclado. Pelo software executa o IR apenas uma vez*/
if(rcv_cmd == RCV_CMD_UART_2)
{
repeat_IR(str_IdIr,0,5); /*ID, Intervalo de repetição(n*100ms) e Intervalo start(ms)*/
flag_send_ir = __FALSE;
}
}else
if(touch == TOUCH_11) /*Touch referente ao Volume+ do Home*/
{
strcpy(str_IdIr,ADDR_HOME_VOL_UP); /*IR vol+ home*/
sprintf(str_aux,"[VOL+ HOME]\r"); /*String para debug*/
/*Envia repetidamente o IR apenas se pressionar no teclado. Pelo software executa o IR apenas uma vez*/
if(rcv_cmd == RCV_CMD_UART_2)
{
repeat_IR(str_IdIr,0,5); /*ID, Intervalo de repetição(n*100ms) e Intervalo start(ms)*/
flag_send_ir = __FALSE;
}
}else
if(touch == TOUCH_12) /*Touch referente ao cursor Down do home*/
{
strcpy(str_IdIr,ADDR_HOME_DOWN); /*IR down home*/
sprintf(str_aux,"[DOWN HOME]\r"); /*String para debug*/
/*Envia repetidamente o IR apenas se pressionar no teclado. Pelo software executa o IR apenas uma vez*/
if(rcv_cmd == RCV_CMD_UART_2)
{
repeat_IR(str_IdIr,0,5); /*ID, Intervalo de repetição(n*100ms) e Intervalo start(ms)*/
flag_send_ir = __FALSE;
}
ir_state.bit.PlayPause = __FALSE; /*Deixa a tecla Play/Pause preparada para enviar o play caso pressionada*/
}else
if(touch == TOUCH_13) /*Touch referente ao Play/Pause do Home*/
{
if(!ir_state.bit.PlayPause)strcpy(str_IdIr,ADDR_HOME_PLAY); /*IR play*/
else strcpy(str_IdIr,ADDR_HOME_PAUSE); /*IR pause*/
ir_state.bit.PlayPause = !ir_state.bit.PlayPause;
sprintf(str_aux,"[%s HOME]\r",(ir_state.bit.PlayPause)? "PLAY":"PAUSE"); /*String para debug*/
}else
if(touch == TOUCH_14) /*Touch referente ao Back do home*/
{
strcpy(str_IdIr,ADDR_HOME_BACK); /*IR back home*/
sprintf(str_aux,"[BACK HOME]\r"); /*String para debug*/
}else
if(touch == TOUCH_15) /*Touch referente ao Next do Home*/
{
strcpy(str_IdIr,ADDR_HOME_NEXT); /*IR next home*/
sprintf(str_aux,"[NEXT HOME]\r"); /*String para debug*/
}else
if(touch == TOUCH_17) /*Touch referente ao Power do AR*/
{
if(!ir_state.bit.PwrAr)strcpy(str_IdIr,ADDR_AR_PWR_ON); /*IR power ar on*/
else strcpy(str_IdIr,ADDR_AR_PWR_OFF); /*IR power ar off*/
ir_state.bit.PwrAr = !ir_state.bit.PwrAr;
sprintf(str_aux,"[%s] [SWING %s] [IR ID:%s] [POWER %s AR]\r",(atoi(cfg.file.mode_func_ar))? "IN":"OUT",
(ir_state.bit.ArSwing)? "ON":"OFF", str_IdIr, (ir_state.bit.PwrAr) ? "ON":"OFF"); /*String para debug*/
}else
if(touch == TOUCH_19 || touch == TOUCH_21 || touch == TOUCH_23)
{
if(touch == TOUCH_19)
{
if(temp_ar < TEMPERATURA_MAX)
temp_ar++;
sprintf(str_IdIr,"%u\0",temp_ar + 3); /*IR temp*/
}else
if(touch == TOUCH_21)
{
if(temp_ar > TEMPERATURA_MIN)
temp_ar--;
sprintf(str_IdIr,"%u\0",temp_ar + 3); /*IR temp*/
}else
if(touch == TOUCH_23)
{
ir_state.bit.ArSwing = !ir_state.bit.ArSwing; /*IR swing ar*/
if(atoi(cfg.file.mode_func_ar)) /*Swing In (Função swing embutida na temperatura)?*/
sprintf(str_IdIr,"%u\0",temp_ar + 3);
else
{
if(!ir_state.bit.ArSwing)strcpy(str_IdIr,ADDR_AR_SWING_ON); /*Endereço Swing On*/
else strcpy(str_IdIr,ADDR_AR_SWING_OFF); /*Endereço Swing Off*/
}
}
sprintf(str_aux,"[%s] [SWING %s] [IR ID:%s] [TEMP %u°]\r",(atoi(cfg.file.mode_func_ar))? "IN":"OUT",
(ir_state.bit.ArSwing)? "ON":"OFF", str_IdIr, temp_ar); /*String para debug*/
}else
{
/*nenhuma função para o touch recebido*/
return;
}
if(flag_send_ir) /*Precisa enviar IR?*/
{
cmd_ir_send(str_IdIr); /*Chama função que envia o ir cujo id do ir é pasado como parâmetro*/
if(buf_tx[0] == 'E') /*Houve algum erro ao enviar o IR?*/
{
beep(BEEP_ERROR);
strcat(buf_tx,"\r\r\0");
uart_putString(0,buf_tx);
}else
{ /*Sem erros*/
//strcat(str_aux,"\r\0");
//uart_putString(0,str_aux);
//printf("[Touch:%u] [IR ID:%s] %s\r",touch, str_IdIr, str_aux);
//fflush(stdout);
sprintf(buf_tx,"OK %u",touch);
}
printf("[Touch:%u] [IR ID:%s] %s\r",touch, str_IdIr, str_aux);
fflush(stdout);
}else
{
// strcat(str_aux,"\r\0");
// uart_putString(0,str_aux);
printf("[Touch:%u] [IR ID:%s] %s\r",touch, str_IdIr, str_aux);
fflush(stdout);
}
}else
{
for(i=TOUCH_0;i<=TOUCH_23;i++) /*Loop para desligar todos os leds 4x4*/
out_leds &= ~(1<<i);
touch_led_press = TOUCH_NONE;
}
}
void cmd_task(void)
{
static char rst = 0;
char *sp,*cp,*next; //,str[4];
long i=0;
if(rcv_cmd)
{
rcv = 0;
wdt_feed();
sp = get_entry (&buf_rx[0], &next);
if(*sp == 0)
{
if(rst++ >= 10)
{
printf ("[FAIL CMD..restart now]\r");
fflush(stdout);
LPC_WDT->WDTC = 0x003FFFF; /*0.5s*/
wdt_feed();
while(1);
}
sprintf(buf_tx,"ERROR %u",ERROR_COMMAND);
}else
{
for (cp = sp; *cp && *cp != ' '; cp++)
*cp = toupper (*cp);
for (i = 0; i < CMD_COUNT; i++)
{
if (strcmp (sp, (const char *)&cmd[i].val))
continue;
cmd[i].func (next);
rst = 0;
break;
}
}
if(i == CMD_COUNT)
sprintf(buf_tx,"ERROR %u",ERROR_COMMAND);
if(i!=6 && rcv_cmd == RCV_CMD_UART_0) /*i=6 (Rcv Touch lpc1113)*/
{
if(buf_tx[0] == 'E')
beep(BEEP_ERROR);
else
beep(BEEP_CFG);
}else
/*Função IR learn, IR learn Scene, Detect Swing e IR learn app via TCP?*/
if((i == 0 || i == 12 || i == 13 || i == 17) && (rcv_cmd == RCV_CMD_TCP_SERVER || rcv_cmd == RCV_CMD_TCP_CLIENT))
{
if(buf_tx[0] == 'E')
beep(BEEP_ERROR);
else
beep(BEEP_CFG);
}
strcat(buf_tx,"\r\n\0");
if(rcv_cmd == RCV_CMD_UART_2)
{
// uart_putString(2,buf_tx);
}else
if(rcv_cmd == RCV_CMD_UART_0)
uart_putString(0,buf_tx);
#if USE_TCP_CLIENT /*Comunicação TCP CLIENT será usada?*/
else
if((rcv_cmd == RCV_CMD_TCP_CLIENT))
{
tcpSend (buf_tx, strlen(buf_tx), last_soc_client,CMD_SEND_TO_CLIENT);
uart_putString(0,buf_tx);
}
#endif
#if USE_TCP_SERVER /*Comunicação TCP SERVER será usada?*/
else
if((rcv_cmd == RCV_CMD_TCP_SERVER))
{
tcpSend (buf_tx, strlen(buf_tx), tcp_server_soc,CMD_SEND_TO_SERVER);
uart_putString(0,buf_tx);
}
#endif
memset(buf_rx,0,sizeof(buf_rx));
memset(buf_tx,0,sizeof(buf_tx));
if(!rcv)
rcv_cmd = __FALSE;
cntUART2 = 0;
cntUART0 = 0;
NVIC_EnableIRQ(UART2_IRQn);
NVIC_EnableIRQ(UART0_IRQn);
}
}
