Beispiel #1
0
int make_ack_get_temp_status(u8*ackbuf)
{
	u16 hum=0;
	u16 temp=0;
	
	char am2301_buf[AM2301_DATA_CNT];
	get_sensor(am2301_buf);
	printf_hex(am2301_buf,AM2301_DATA_CNT);

	/*change ascii to num*/
	hum = (am2301_buf[INDEX_H100]-0x30)*100 + (am2301_buf[INDEX_H10]-0x30)*10 + (am2301_buf[INDEX_H1]-0x30);
	temp = (am2301_buf[INDEX_T100]-0x30)*100 + (am2301_buf[INDEX_T10]-0x30)*10 + (am2301_buf[INDEX_T1]-0x30);

	make_ack_head( ackbuf, PROTOCOL_ACK_GET_TEMP_STATUS);
	ackbuf[4] = TEMP_NUM;
	ackbuf[5] = TEMP_NUM;

	ackbuf[6] = hum/0x100;
	ackbuf[7] = hum%0x100;
	ackbuf[8] = temp/0x100;
	ackbuf[9] = temp%0x100;
	
	ackbuf[10]=make_crc_num(ackbuf, 10);
	return 11;
}
Beispiel #2
0
int get_one_sensor_buf(CONFIG_SENSOR * pcs, u8 * _buf)
{
   u8 i=0,j=0;

   if (pcs == NULL || _buf == NULL){
      sys_log(FUNC, LOG_ERR , "CONFIG_SENSOR pointer is %p, u8 pointer is %p", pcs, _buf);
      return -1;
   }
   _buf[0] = pcs->type;
   _buf[1] = pcs->num;

   if (pcs->num == 0){
      _buf[2] = 0;
      _buf[3] = 0;
      sys_log(FUNC, LOG_ERR, "CONFIG_SENSOR %d,  num is %d", pcs->type, pcs->num);
      return 4;
   }
   
   for (i = 0, j = 0; j < pcs->num; i += 2,j++){
         _buf[2+i] = pcs->seq_num[j];
         _buf[3+i] = pcs->attr[j];
   }
	printf_hex(_buf, 2 + 2*pcs->num);
   sys_log(FUNC, LOG_DBG, "CONFIG_SENSOR %d,  num is %d", pcs->type, pcs->num);
   return (2 + 2*pcs->num);
}
Beispiel #3
0
 void  Protocol_SendComDataToNet_IntMode(int id, void *data, int len)
{	
	int num_to_send, ret;
	Protocol_SendComDataToNet_PollMode(id, data, len);
	num_to_send = make_ack_query_uart_recv_data(buf_send);
	
	ret = write(g_sockfd_client, buf_send, num_to_send);
	if(ret != num_to_send) 
		printf("write socket error!\n");
	sys_log(FUNC, LOG_DBG, "send %d bytes", num_to_send);
	printf_hex(buf_send, num_to_send);
	
}
Beispiel #4
0
int  FLASH_read(char* argv){
	uint32_t  i=0,len =32,data=0;
	char buffer[buffer_sz];
	char* pHead,*pEnd;
	uint32_t  address =  0x08000800;
	if (*argv){
		pHead = argv;
		pEnd = strchr(pHead,SEP_FIELD);
		if (pEnd) {
			*pEnd = '\0';
			address = atoi(pHead);
			if (address < 0x08000000 && address >0x0800ffff) // for 64kBytes flash MCU
				return 4; //4,  超出命令范围 in uart.c
			pHead = pEnd +1;
			if (*pHead)
				len = atoi(pHead);
			if (len<0 && len > 1024)
				return 4; //4,  超出命令范围 in uart.c
		}
	}
	printf_("\r\n");
	printf_hex((char*)address,(int) len);
	return 0;
}
Beispiel #5
0
void client_process(void)
{
	fd_set readfds;		
	int ret;
	int num_read_from_socket;
	int num_to_send;	
	int res = -1;
	struct timeval tv;

	sys_log(FUNC, LOG_MSG, "start");
	while (1)
	{			
		heartbeat_timeout ++;
		sys_log(FUNC, LOG_DBG, "heartbeat_timeout = %d heartbeat_s=%d",heartbeat_timeout, heartbeat_s);
		if (heartbeat_timeout > heartbeat_s){
			sys_log(FUNC, LOG_ERR, "heartbeat timeout  --> reconnect");
			set_heartbeat(HEARTBEAT_OFFLINE,  HEARTBEAT_TIMEOUT);			
		}
		sleep(1);		
		if (g_reconnect_flag == RECONNECT_ON || g_reconnect_flag == HEARTBEAT_OFFLINE){
			if (SUCCESS == client_reconnect()){
				g_reconnect_flag = RECONNECT_OFF;	
			}			
		}
		if (g_sockfd_client <=0){
			//sys_log(FUNC, LOG_WARN, "g_sockfd_client");
			g_reconnect_flag = RECONNECT_ON;
			continue;
		}	
		
		FD_ZERO(&readfds);
		FD_SET(g_sockfd_client, &readfds);
		tv.tv_sec = 0;
		tv.tv_usec = 1000;		

		res = select(g_sockfd_client + 1, &readfds, NULL, NULL, &tv);
		if (res < 0){
			continue;
		}else if (res > 0){
			if (FD_ISSET(g_sockfd_client, &readfds))
				num_read_from_socket = read(g_sockfd_client, buf, 100);
		}else{
			continue;
		}
		
		if(num_read_from_socket <= 0){
			continue;
		}
		sys_log(FUNC, LOG_WARN, "recv %d bytes!\n",num_read_from_socket);
		printf_hex(buf,num_read_from_socket);		

		if (check_head(buf) == -1 ){
			continue;
		}		

		g_sockfd_client_status = SOCKFD_CLIENT_OK;
		
		switch (buf[2]){
			case PROTOCOL_GET_DEVICE_ATTR:
				sys_log(FUNC, LOG_DBG, "PROTOCOL_GET_DEVICE_ATTR");
				
				if(!check_for_get_device_attr(buf,num_read_from_socket))
				{
					num_to_send = make_ack_get_device_attr(buf_send);
					ret = write(g_sockfd_client, buf_send, num_to_send);
					if(ret != num_to_send)
						printf("write socket error!\n");
					sys_log(FUNC, LOG_DBG, "send %d bytes", num_to_send);
					printf_hex(buf_send, num_to_send);
				}
				break;
			case PROTOCOL_SET_DEVICE_ATTR:
				sys_log(FUNC, LOG_DBG, "PROTOCOL_SET_DEVICE_ATTR");
				if(!check_for_set_device_attr(buf,num_read_from_socket))
				{
					/*todo set device attr
						传感器有好几类,此处只处理报警传感器
					*/
					set_alarmin_device_attr(buf);
				
					num_to_send = make_ack_set_device_attr(buf_send);
					ret = write(g_sockfd_client, buf_send, num_to_send);
					if(ret != num_to_send)
						printf("write socket error!\n");
					sys_log(FUNC, LOG_DBG, "send %d bytes", num_to_send);
					printf_hex(buf_send, num_to_send);
				}
				break;
			case PROTOCOL_GET_ALARM_STATUS:
				sys_log(FUNC, LOG_DBG, "PROTOCOL_GET_ALARM_STATUS");
				if(!check_for_get_alarm_status(buf,num_read_from_socket))
				{					
					/*alarmin*/
					
					num_to_send = make_ack_get_alarm_status(buf_send, g_alarm_in);
					ret = write(g_sockfd_client, buf_send, num_to_send);
					if(ret != num_to_send) 
						printf("write socket error!\n");
					sys_log(FUNC, LOG_DBG, "send %d bytes", num_to_send);
					printf_hex(buf_send, num_to_send);
				}
				break;
			case PROTOCOL_GET_TIME:
				sys_log(FUNC, LOG_DBG, "PROTOCOL_GET_TIME");
				/*TODO ?*/
				
				break;
			case PROTOCOL_SET_TIME:
				sys_log(FUNC, LOG_DBG, "PROTOCOL_SET_TIME");				
				if(!check_for_set_time(buf,num_read_from_socket))
				{
					/* TODO */
					/*set time*/
				
					num_to_send = make_ack_set_time(buf_send);
					ret = write(g_sockfd_client, buf_send, num_to_send);
					if(ret != num_to_send)
						printf("write socket error!\n");
					sys_log(FUNC, LOG_DBG, "send %d bytes", num_to_send);
					printf_hex(buf_send, num_to_send);
				}
				break;
			case PROTOCOL_SET_HEARTBEAT:
				sys_log(FUNC, LOG_DBG, "PROTOCOL_SET_HEARTBEAT");
				if(!check_for_set_heartbeat(buf,num_read_from_socket))
				{
					num_to_send = make_ack_set_heartbeat(buf_send,heartbeat_s);
					ret = write(g_sockfd_client, buf_send, num_to_send);
					if(ret != num_to_send)
						printf("write socket error!\n");
					sys_log(FUNC, LOG_DBG, "send %d bytes", num_to_send);
					printf_hex(buf_send, num_to_send);

					set_heartbeat(HEARTBEAT_ONLINE, buf[4]);	
					led_ctrl(LED_D3_ALARM_SERVER_STATUS, LED_ON);
				}
				break;
			case PROTOCOL_GET_UART_QTY:
				sys_log(FUNC, LOG_DBG, "PROTOCOL_GET_UART_QTY");
				if(!check_for_get_uart_qty(buf,num_read_from_socket))
				{					
					num_to_send = make_ack_get_uart_qty(buf_send);
					ret = write(g_sockfd_client, buf_send, num_to_send);
					if(ret != num_to_send) 
						printf("write socket error!\n");
					sys_log(FUNC, LOG_DBG, "send %d bytes", num_to_send);
					printf_hex(buf_send, num_to_send);
				}

				break;
			case PROTOCOL_GET_UART_ATTR:
				sys_log(FUNC, LOG_DBG, "PROTOCOL_GET_UART_ATTR");
				if (!check_for_get_uart_attr(buf, num_read_from_socket)){
					num_to_send = make_ack_get_uart_attr(buf_send, buf);
					ret = write(g_sockfd_client, buf_send, num_to_send);
					if(ret != num_to_send) 
						printf("write socket error!\n");
					sys_log(FUNC, LOG_DBG, "send %d bytes", num_to_send);
					printf_hex(buf_send, num_to_send);
				}
				
				break;
			case PROTOCOL_SET_UART_ATTR:
				sys_log(FUNC, LOG_DBG, "PROTOCOL_SET_UART_ATTR");
				if (!check_for_set_uart_attr(buf, num_read_from_socket)){
					num_to_send=make_ack_set_uart_attr(buf_send,buf);
					ret = write(g_sockfd_client, buf_send, num_to_send);
					if(ret != num_to_send) 
						printf("write socket error!\n");
					sys_log(FUNC, LOG_DBG, "send %d bytes", num_to_send);
					printf_hex(buf_send, num_to_send);
				}
				break;
			case PROTOCOL_QUERY_UART_SENDBUF:
				sys_log(FUNC, LOG_DBG, "PROTOCOL_QUERY_UART_SENDBUF");
				if (!check_for_query_uart_sendbuf(buf, num_read_from_socket)){
					num_to_send = make_ack_query_uart_sendbuf(buf_send);

					/*TODO :buf*/

					ret = write(g_sockfd_client, buf_send, num_to_send);
					if(ret != num_to_send) 
						printf("write socket error!\n");
					sys_log(FUNC, LOG_DBG, "send %d bytes", num_to_send);
					printf_hex(buf_send, num_to_send);
				}
			break;

			case PROTOCOL_UART_SEND_DATA:
				sys_log(FUNC, LOG_DBG, "PROTOCOL_UART_SEND_DATA");
				if (!check_for_uart_send_data(buf, num_read_from_socket)){
					num_to_send = make_ack_uart_send_data(buf_send);

					/*TODO*/

					ret = write(g_sockfd_client, buf_send, num_to_send);
					if(ret != num_to_send) 
						printf("write socket error!\n");
					sys_log(FUNC, LOG_DBG, "send %d bytes", num_to_send);
					printf_hex(buf_send, num_to_send);
				}
			break;
			case PROTOCOL_SET_UART_RECV_ATTR:
				sys_log(FUNC, LOG_DBG, "PROTOCOL_SET_UART_RECV_ATTR");
				if (!check_for_set_uart_recv_attr(buf, num_read_from_socket)){
					
					/*TODO*/

					
				}
			break;

			case PROTOCOL_QUERY_UART_RECV_DATA:
				sys_log(FUNC, LOG_DBG, "PROTOCOL_QUERY_UART_RECV_DATA");
				if (!check_for_query_uart_recv_data(buf, num_read_from_socket)){
					num_to_send = make_ack_query_uart_recv_data(buf_send);

					/*TODO*/

					ret = write(g_sockfd_client, buf_send, num_to_send);
					if(ret != num_to_send) 
						printf("write socket error!\n");
					sys_log(FUNC, LOG_DBG, "send %d bytes", num_to_send);
					printf_hex(buf_send, num_to_send);
				}
			break;

			case PROTOCOL_GET_IO_NUM:
				sys_log(FUNC, LOG_DBG, "PROTOCOL_GET_IO_NUM");
				if (!check_for_get_io_num(buf, num_read_from_socket)){
					num_to_send = make_ack_get_io_num(buf_send);

					/*TODO*/

					ret = write(g_sockfd_client, buf_send, num_to_send);
					if(ret != num_to_send) 
						printf("write socket error!\n");
					sys_log(FUNC, LOG_DBG, "send %d bytes", num_to_send);
					printf_hex(buf_send, num_to_send);
				}
			break;

			case PROTOCOL_SET_IO:
				sys_log(FUNC, LOG_DBG, "PROTOCOL_SET_IO");
				if (!check_for_set_io(buf, num_read_from_socket)){
					
					/*TODO*/

					set_io_out(buf);					
				}
			break;

			case PROTOCOL_GET_IO_STATUS:
				sys_log(FUNC, LOG_DBG, "PROTOCOL_GET_IO_STATUS");
				if (!check_for_get_io_status(buf, num_read_from_socket)){
								
					num_to_send = make_ack_get_io_status(buf_send, buf);


					ret = write(g_sockfd_client, buf_send, num_to_send);
					if(ret != num_to_send) 
						printf("write socket error!\n");
					sys_log(FUNC, LOG_DBG, "send %d bytes", num_to_send);
					printf_hex(buf_send, num_to_send);
				}
			break;

			case PROTOCOL_GET_TEMP_NUM:
				sys_log(FUNC, LOG_DBG, "PROTOCOL_GET_TEMP_NUM");
				if (!check_for_get_temp_num(buf, num_read_from_socket)){
								
					num_to_send = make_ack_get_temp_num(buf_send);


					ret = write(g_sockfd_client, buf_send, num_to_send);
					if(ret != num_to_send) 
						printf("write socket error!\n");
					sys_log(FUNC, LOG_DBG, "send %d bytes", num_to_send);
					printf_hex(buf_send, num_to_send);
				}
			break;

			case PROTOCOL_SET_TEMP:
				sys_log(FUNC, LOG_DBG, "PROTOCOL_SET_TEMP");

				set_temp(buf);
			
			break;

			case PROTOCOL_GET_TEMP_STATUS:
				sys_log(FUNC, LOG_DBG, "PROTOCOL_GET_TEMP_STATUS");
				if (!check_for_get_temp_status(buf, num_read_from_socket)){
								
					num_to_send = make_ack_get_temp_status(buf_send);


					ret = write(g_sockfd_client, buf_send, num_to_send);
					if(ret != num_to_send) 
						printf("write socket error!\n");
					sys_log(FUNC, LOG_DBG, "send %d bytes", num_to_send);
					printf_hex(buf_send, num_to_send);
				}
			break;

#if 0
			case PROTOCOL_GET_SENSOR_TYPE:
				sys_log(FUNC, LOG_DBG, "PROTOCOL_GET_SENSOR_TYPE");
				if (!check_for_get_sensor_type(buf, num_read_from_socket)){
					num_to_send = make_ack_get_sensor_type(buf_send);

					ret = write(g_sockfd_client, buf_send, num_to_send);
					if (ret != num_to_send){
						printf("write socket error!\n");
					}
					sys_log(FUNC, LOG_DBG, "send %d bytes", num_to_send);
					printf_hex(buf_send, num_to_send);
				}
			break;

			case PROTOCOL_GET_SENSOR_DATA:
				sys_log(FUNC, LOG_DBG, "PROTOCOL_GET_SENSOR_DATA");
				if (!check_for_get_sensor_data(buf, num_read_from_socket)){
					num_to_send = make_ack_get_sensor_data(buf_send);

					ret = write(g_sockfd_client, buf_send, num_to_send);
					if (ret != num_to_send){
						printf("write socket error!\n");
					}
					sys_log(FUNC, LOG_DBG, "send %d bytes", num_to_send);
					printf_hex(buf_send, num_to_send);
				}
			break;
#endif			
			default:
				sys_log(FUNC, LOG_ERR, "wrong cmd from server ");
				break;				
		}
		
	}	
}
Beispiel #6
0
Datei: qstr.c Projekt: husthl/qos
void printf_section_hex( const char* prompt, const char* section, int section_len ){
    printf( "%s", prompt );
	printf_hex( section, section_len );		
	printf( " (len=%u)", section_len );
    printf( "\n" );
}