Exemple #1
0
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"); 
}
Exemple #2
0
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);
}
Exemple #3
0
/*****************************************************************************
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");
}
Exemple #4
0
/*****************************************************************************
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*/
	}
}
Exemple #5
0
/*****************************************************************************
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;
}
Exemple #7
0
/*****************************************************************************
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*/		
	}
}
Exemple #8
0
/*****************************************************************************
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;
	}
}
Exemple #9
0
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);
	}
}