www.pudn.com > seria1.rar > user_define_func.c,v


head	1.13;
access;
symbols;
locks; strict;
comment	@ * @;


1.13
date	2004.12.17.03.36.49;	author yr;	state Exp;
branches;
next	1.12;
deltatype	text;
permissions	644;
commitid	89441c2544d562b;
kopt	kv;
filename	@user_define_func.c@;

1.12
date	2004.12.16.09.13.47;	author yr;	state Exp;
branches;
next	1.11;
deltatype	text;
permissions	644;
commitid	60441c151c409e6;
kopt	kv;
filename	@user_define_func.c@;

1.11
date	2004.12.14.08.14.36;	author yr;	state Exp;
branches;
next	1.10;
deltatype	text;
permissions	644;
commitid	1ba841bea0e84060;
kopt	kv;
filename	@user_define_func.c@;

1.10
date	2004.12.14.07.55.08;	author yr;	state Exp;
branches;
next	1.9;
deltatype	text;
permissions	644;
commitid	1b4c41be9c573176;
kopt	kv;
filename	@user_define_func.c@;

1.9
date	2004.12.13.02.33.02;	author yr;	state Exp;
branches;
next	1.8;
deltatype	text;
permissions	644;
commitid	85041bcff596cce;
kopt	kv;
filename	@user_define_func.c@;

1.8
date	2004.12.07.11.27.11;	author laj;	state Exp;
branches;
next	1.7;
deltatype	text;
permissions	644;
commitid	96441b593733089;
kopt	kv;
filename	@user_define_func.c@;

1.7
date	2004.12.07.10.15.35;	author laj;	state Exp;
branches;
next	1.6;
deltatype	text;
permissions	644;
commitid	7ac41b582727902;
kopt	kv;
filename	@user_define_func.c@;

1.6
date	2004.12.06.13.42.25;	author yr;	state Exp;
branches;
next	1.5;
deltatype	text;
permissions	644;
commitid	8e441b46185497f;
kopt	kv;
filename	@user_define_func.c@;

1.5
date	2004.11.30.08.26.02;	author tarbit;	state Exp;
branches;
next	1.4;
deltatype	text;
permissions	644;
commitid	cb041ac2e890319;
kopt	kv;
filename	@user_define_func.c@;

1.4
date	2004.11.30.07.56.24;	author tarbit;	state Exp;
branches;
next	1.3;
deltatype	text;
permissions	644;
commitid	d3c41ac27976c6b;
kopt	kv;
filename	@user_define_func.c@;

1.3
date	2004.11.30.02.43.39;	author yr;	state Exp;
branches;
next	1.2;
deltatype	text;
permissions	644;
commitid	c3c41abde567d33;
kopt	kv;
filename	@user_define_func.c@;

1.2
date	2004.11.30.01.59.15;	author yr;	state Exp;
branches;
next	1.1;
deltatype	text;
permissions	644;
commitid	ce041abd3ee5b38;
kopt	kv;
filename	@user_define_func.c@;

1.1
date	2004.11.01.05.19.55;	author yr;	state Exp;
branches;
next	;
deltatype	text;
permissions	644;
commitid	d404185c7771af5;
kopt	kv;
filename	@user_define_func.c@;


desc
@@


1.13
log
@change mtype of regist, REG_SERIALSERV
@
text
@#include       /*标准输入输出定义*/
#include      /*标准函数库定义*/
#include      /*Unix 标准函数定义*/
#include 
#include 
#include 
#include 
#include       /*文件控制定义*/
#include     /*PPSIX 终端控制定义*/
#include       /*错误号定义*/
#include 
#include    
#include 
#include 
#include 
#include 
#include 
/**
*@@brief  设置串口通信速率
*@@param  fd     类型 int  打开串口的文件句柄
*@@param  speed  类型 int  串口速度
*@@return  void
*/

extern  char    alarm_set[3];
extern 	char	alarm_bit[3];
extern 	char 	alarm_num;
extern	char 	alarm_kind;
int speed_arr[] = { B38400, B19200, B9600, B4800, B2400, B1200, B300,
					B38400, B19200, B9600, B4800, B2400, B1200, B300, };
int name_arr[] = {38400,  19200,  9600,  4800,  2400,  1200,  300, 38400,  
					19200,  9600, 4800, 2400, 1200,  300, };

void set_speed(int fd, int speed){
	int   i; 
	int   status; 
	struct termios   Opt;

	tcgetattr(fd, &Opt); 

	for ( i= 0;  i < sizeof(speed_arr) / sizeof(int);  i++) { 

		if  (speed == name_arr[i]) {     
			tcflush(fd, TCIOFLUSH);     
			cfsetispeed(&Opt, speed_arr[i]);  
			cfsetospeed(&Opt, speed_arr[i]);   
			status = tcsetattr(fd, TCSANOW, &Opt);  

			if  (status != 0) {        
				perror("tcsetattr fd1");  
				return;     
			}    
			tcflush(fd,TCIOFLUSH);   
		}  
	}
}

/**
*@@brief   设置串口数据位,停止位和效验位
*@@param  fd     类型  int  打开的串口文件句柄
*@@param  databits 类型  int 数据位   取值 为 7 或者8
*@@param  stopbits 类型  int 停止位   取值为 1 或者2
*@@param  parity  类型  int  效验类型 取值为N,E,O,,S
*/

int set_Parity(int fd,int databits,int stopbits,int parity)
{ 
	struct termios options; 

	if  ( tcgetattr( fd,&options)  !=  0) { 
		perror("SetupSerial 1");     
		return(0);  
	}


	options.c_cflag &= ~CSIZE; 
	switch (databits) /*设置数据位数*/
	{   
	case 7:		
		options.c_cflag |= CS7; 
		break;
	case 8:     
		options.c_cflag |= CS8;
		break;   
	default:    
		fprintf(stderr,"Unsupported data size\n"); 
		return 0;  
	}

       switch (parity) 
       {   
	case 'n':
	case 'N':    
		options.c_cflag &= ~PARENB;   /* Clear parity enable */
		options.c_iflag &= ~INPCK;     /* Enable parity checking */ 
		break;  

	case 'o':   
	case 'O':     
		options.c_cflag |= (PARODD | PARENB); /* 设置为奇效验*/  
		options.c_iflag |= INPCK;             /* Disnable parity checking */ 
		break;  

	case 'e':  
	case 'E':   
		options.c_cflag |= PARENB;     /* Enable parity */    
		options.c_cflag &= ~PARODD;   /* 转换为偶效验*/     
		options.c_iflag |= INPCK;       /* Disnable parity checking */
		break;

	case 'S': 
	case 's':  /*as no parity*/   
	    	options.c_cflag &= ~PARENB;
		options.c_cflag &= ~CSTOPB;
		break;  

	default:   
		fprintf(stderr,"Unsupported parity\n");    
		return 0;  
	}  

#if 0
	options.c_iflag &= 1;
#endif
	options.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG);
	options.c_oflag &= ~OPOST;

	/* 设置停止位*/  

        switch (stopbits)
        {   
	case 1:    
		options.c_cflag &= ~CSTOPB;  
		break;  
	case 2:    
		options.c_cflag |= CSTOPB;  
	   	break;
	default:    
		 fprintf(stderr,"Unsupported stop bits\n");  
		 return 0; 
        } 
	/* Set input parity option */ 
        if (parity != 'n')   
		options.c_iflag |= INPCK; 

        tcflush(fd,TCIFLUSH);

        options.c_cc[VTIME] = 150; /* 设置超时15 seconds*/   

        options.c_cc[VMIN] = 0; /* Update the options and do it NOW */

        if (tcsetattr(fd,TCSANOW,&options) != 0)   
        { 
		perror("SetupSerial 3");   
		return 0;  
        } 
	return 1;  
}


/**********************************************************************
代码说明:使用串口二测试的,发送的数据是字符,
但是没有发送字符串结束符号,所以接收到后,后面加上了结束符号。我测试使
用的是单片机发送数据到第二个串口,测试通过。
**********************************************************************/
#define FALSE 0 
#define TRUE  1 
/*********************************************************************/

int OpenDev(char *Dev)
{
	int	fd = open( Dev, O_RDWR );         //| O_NOCTTY | O_NDELAY	
	if (-1 == fd)	
	{ 			
		perror("Can't Open Serial Port");
		return -1;		
	}	
	else	
		return fd;
}
//------------------------------------------------------------------------------------------------------------
void handle_func()
{
        printf("End of serial!\n");
        _exit(0);
}

//------------------------------------------------------------------------------------------------------------
void func_msg_regst()
{
	//regist message!!
        MSG     sendmsg;
        key_t keyval0 = SERVMANAGE_MSGQ;
        int msgq_id0 = 0; 
        msgq_id0 = msgget(keyval0,0);                                                                                                               
        sendmsg.mtype           = REG_SERIALSERV;
        sendmsg.pid             = getpid();
        sendmsg.from_service    = SERIAL_SERVICE;
        sendmsg.data_type       = REGIST;
        sendmsg.msg_data.answer_serv=0x00;
        msgsnd(msgq_id0, &sendmsg, MSG_LEN, 0);
	
}

//------------------------------------------------------------------------------------------------------------
void func_sig_proc()
{
	//signal processor!
        struct sigaction act;
        sigset_t blockmask;
                                                                                                               
        sigemptyset(&blockmask);
        sigaddset(&blockmask, SIGINT);
        sigprocmask(SIG_BLOCK, &blockmask, NULL);
        act.sa_handler = handle_func;
        sigemptyset(&act.sa_mask);
        sigaddset(&act.sa_mask, SIGINT);
        sigaction(SIGINT, &act, NULL);
        sigprocmask(SIG_UNBLOCK,&blockmask, NULL);

}

//------------------------------------------------------------------------------------------------------------
void func_sign_nack()
{
	printf("The 485 is disconnected!\n");
}
//------------------------------------------------------------------------------------------------------------
void func_sigalarm_proc()
{
	struct sigaction act;
        sigset_t blockmask;
                                                                                                               
        sigemptyset(&blockmask);
        sigaddset(&blockmask, SIGALRM);
        sigprocmask(SIG_BLOCK, &blockmask, NULL);
        act.sa_handler = func_sign_nack;
        sigemptyset(&act.sa_mask);
        sigaddset(&act.sa_mask, SIGALRM);
        sigaction(SIGALRM, &act, NULL);
        sigprocmask(SIG_UNBLOCK,&blockmask, NULL);
}
//------------------------------------------------------------------------------------------------------------
void func_set_timer()
{
	struct itimerval new;
        new.it_interval.tv_sec = 7200;
        new.it_interval.tv_usec = 0;
        new.it_value.tv_sec = 7200;
        new.it_value.tv_usec = 0;
                                                                                                               
        setitimer(ITIMER_REAL, &new, NULL);
	
}
//------------------------------------------------------------------------------------------------------------
void fn_oprt_msg()
{
	MSG     rcvmsg_alarm;
	MSG	rcvmsg_serial;
	int     status;
        int     msgid_serial;
	
	//set up MSGQ_SERIAL                                                        
        if((msgid_serial = msgget(SERIAL_MSGQ, IPC_CREAT)) == -1)
        {
                printf("SERIAL_MSGQ get error!\n");
                exit(1);
        }
//        printf("msgid_serial = %d\n",msgid_serial);

	while (1)
	{
	        //to judge "the SERIAL_MSGQ has a message !"
        	struct msqid_ds *msgq_buf;
	        msgq_buf =  (struct msqid_ds *)malloc(sizeof(struct msqid_ds));
        	do
	        {
        	        msgctl(msgid_serial, IPC_STAT, msgq_buf);
                	usleep(1000);
	        }while(msgq_buf->msg_cbytes == 0);
        	free(msgq_buf);
       		
//		printf("in the pthread!\n"); 
		//receive the message
		if(msgrcv(msgid_serial, (MSG *)&rcvmsg_serial, 80, 0, 0) == -1)
        	{
                	printf("rcvmsg_alarm rcv error!\n");
	                exit(1);
        	}
		
		//以后,这里可以用switch,对不同的data_type作不同的处理;
		if (rcvmsg_serial.data_type == 7)
		{
			alarm_set[0] = rcvmsg_serial.msg_data.alarm[0];
			alarm_set[1] = rcvmsg_serial.msg_data.alarm[1];
			alarm_set[2] = rcvmsg_serial.msg_data.alarm[2];

//			printf("In the serial!\n");
//			printf("The message from SERIAL_MSGQ data_type:%x\n",rcvmsg_serial.data_type);
//	        	printf("The message from SERIAL_MSGQ alarm[0]:%x\n",rcvmsg_serial.msg_data.alarm[0]);
//	        	printf("The message from SERIAL_MSGQ alarm[1]:%x\n",rcvmsg_serial.msg_data.alarm[1]);
//			printf("The msssage from SERIAL_MSGQ alarm[2]:%x\n",rcvmsg_serial.msg_data.alarm[2]);
        	} 
        }                                                                                                   
}

//-----------------------------------------------------------------------------------------------------------
void func_read_alarm_set()
{
	int	i;
	FILE	*fp2;	
	if((fp2 = fopen("./temp/set_record", "r")) == NULL)
        {
                printf("can't open file fp2!\n");
                exit(1);
        }                                                                                            
        fread(alarm_set, 1, 3, fp2);
        fclose(fp2);
}
//-----------------------------------------------------------------------------------------------------------

void fn_read_port(int fdcom, unsigned char *buffer)
{
	int     readlen, fs_sel;
	int	i;
        unsigned char    sign_1 = 0xf6;
        unsigned char    sign_2 = 0xf9;
	unsigned char	sign_err_1 = 0xfa;
	unsigned char	sign_err_2 = 0xf7;
	unsigned char	sign_ack = 0xf8;
	unsigned char	sign;
        fd_set  fs_read;
        
while(1)
{	
        FD_ZERO(&fs_read);
        FD_SET(fdcom, &fs_read);
        fs_sel = select(fdcom+1, &fs_read, NULL, NULL, NULL);
	
        if(FD_ISSET(fdcom, &fs_read))
	{
               if(read(fdcom, &sign, 1) > 0){                                                          
        	if(sign == 0xf5){
                	write(fdcom, &sign_1, 1);
			printf("0xf5 successful!\n");
			break;
		}
		else if(sign == sign_ack){
			printf("sign_ack received, The 485 is ok!\n");
			func_set_timer();
		}
		else{
			write(fdcom, &sign_err_1, 1);
			printf("0xf5 failed!\n");
                }
		}
        }
}

while(1)
{
	FD_ZERO(&fs_read);
        FD_SET(fdcom, &fs_read);
        fs_sel = select(fdcom+1, &fs_read, NULL, NULL, NULL);
        if(fs_sel)
	{	
                readlen = read(fdcom, buffer, 6);
	}


	if(readlen == 6){
		write(fdcom, &sign_2, 1);
		printf("readlen == 6 successful!\n");
		for(i = 0; i<6; i++)
		{
			printf("the data is:%x\n",buffer[i]);
		}
		break;
	}	
        else{   
		printf("readlen != 6\n");
		write(fdcom, &sign_err_2, 1);
        }
}	
}


//------------------------------------------------------------------------------------------------------------

void fn_operation(char * buffer)
{
//	char	alarm_bit[3];	
	switch (buffer[0])
	{
		case 0xd2: 	alarm_bit[0] = alarm_set[0] & 0x01; 
				alarm_num = RESCUE_ONE; alarm_kind = 1; break;
		case 0xe8: 	alarm_bit[0] = alarm_set[0] & 0x02; 
				alarm_num = RESCUE_TWO; alarm_kind = 1; break;
		case 0xd3: 	alarm_bit[0] = alarm_set[0] & 0x04; 
				alarm_num = SMOKE_ONE; alarm_kind = 2; break;
		case 0xdb: 	alarm_bit[0] = alarm_set[0] & 0x08; 
				alarm_num = SMOKE_TWO; alarm_kind = 2; break;
		case 0xe9: 	alarm_bit[0] = alarm_set[0] & 0x10; 
				alarm_num = SMOKE_THREE; alarm_kind = 2; break;
		case 0xd5: 	alarm_bit[0] = alarm_set[0] & 0x20; 
				alarm_num = GAS_ONE; alarm_kind = 3;break;
		case 0xea: 	alarm_bit[0] = alarm_set[0] & 0x40; 
				alarm_num = GAS_TWO; alarm_kind = 3;break;
		//无0x80 
		
		case 0xd8: 	alarm_bit[1] = alarm_set[1] & 0x01; 
				alarm_num = DOOR_MAG_ONE; alarm_kind = 4;break;
		case 0xed: 	alarm_bit[1] = alarm_set[1] & 0x02; 
				alarm_num = DOOR_MAG_TWO; alarm_kind = 4;break;
		case 0xd9: 	alarm_bit[1] = alarm_set[1] & 0x04; 
				alarm_num = WIN_MAG_ONE; alarm_kind = 5;break;
		case 0xde: 	alarm_bit[1] = alarm_set[1] & 0x08; 
				alarm_num = WIN_MAG_TWO; alarm_kind = 5;break;
		case 0xee: 	alarm_bit[1] = alarm_set[1] & 0x10; 
				alarm_num = WIN_MAG_THREE; alarm_kind = 5;break;
		case 0xd6: 	alarm_bit[1] = alarm_set[1] & 0x20; 
				alarm_num = INFRARED_ONE; alarm_kind = 6;break;
		case 0xdc: 	alarm_bit[1] = alarm_set[1] & 0x40; 
				alarm_num = INFRARED_TWO; alarm_kind = 6;break;
		case 0xeb: 	alarm_bit[1] = alarm_set[1] & 0x80; 
				alarm_num = INFRARED_THREE; alarm_kind = 6;break;


		case 0xd7: 	alarm_bit[2] = alarm_set[2] & 0x01; 
				alarm_num = CURTAIN_ONE; alarm_kind = 7;break;
		case 0xdd: 	alarm_bit[2] = alarm_set[2] & 0x02; 
				alarm_num = CURTAIN_TWO; alarm_kind = 7;break;
		case 0xec: 	alarm_bit[2] = alarm_set[2] & 0x04; 
				alarm_num = CURTAIN_THREE; alarm_kind = 7;break;
		case 0xda: 	alarm_bit[2] = alarm_set[2] & 0x08; 	
				alarm_num = QUAKE_ONE; alarm_kind = 8;break;
		case 0xef: 	alarm_bit[2] = alarm_set[2] & 0x10; 
				alarm_num = QUAKE_TWO; alarm_kind = 8;break;
		//无0x20,0x40
		case 0xdf: 	alarm_bit[2] = alarm_set[2] & 0x80; 
				alarm_num = AROUND_PROTECT; alarm_kind = 9;break;

	}	
//	return alarm_bit;

}

//------------------------------------------------------------------------------------------------------------
void fn_msg_snd()
{
	MSG	sndmsg_sysinfo;
	MSG	sndmsg_network;
	MSG	rcvmsg_arise;
	int	msgid_sysinfo;
	int	msgid_network;
	int	i;
	FILE	*fp1;

	if(alarm_bit[0] || alarm_bit[1] || alarm_bit[2])
	{
		//send message to sys_info(indmain)!                                             
	        sndmsg_sysinfo.mtype = 1;
        	sndmsg_sysinfo.data_type = SYSINFO;
	        sndmsg_sysinfo.msg_data.sys_info = ALARM;

		if((msgid_sysinfo = msgget(SYSINFO_MSGQ, 0)) == -1)
      		{
               		printf("SYSINFO_MSGQ get error!\n");
	       	  	exit(1);
      		}
		if(msgsnd(msgid_sysinfo, (MSG *)&sndmsg_sysinfo, sizeof(MSG)-4, IPC_NOWAIT) == -1)
        	{
       	        	printf("sndmsg_sysinfo msgsnd error!\n");
	               	exit(1);
       		}
		
		//send kind message to network
                sndmsg_network.mtype = 1;
                sndmsg_network.data_type = ALARM_SEND;
                sndmsg_network.msg_data.alarm_send[0] = alarm_kind;
                sndmsg_network.msg_data.alarm_send[1] = alarm_num;
                                                                                                               
                if((msgid_network = msgget(NETWORK_MSGQ, 0)) == -1)
                {
                        printf("NETWORK_MSGQ get error!\n");
                        exit(1);
                }
                if(msgsnd(msgid_network, (MSG *)&sndmsg_network, sizeof(MSG)-4, IPC_NOWAIT) == -1)
                {
                        printf("sndmsg_network msgsnd error!\n");
                        exit(1);
                }

		//write to arise_record, which record the alarm happened!
		if((fp1 = fopen("./temp/arise_record", "w")) == NULL)
	        {
        	        printf("can't open file fp1!\n");
                	exit(1);
	        }
        	fwrite(alarm_bit, 1, 3, fp1);
		printf("write to arise_record!\n");
		fclose(fp1);
	}
	else
		printf("The device is unsetted!\n");

	alarm_num = 0;//reset the alarm_num!
	alarm_bit[0] = 0;
	alarm_bit[1] = 0;
	alarm_bit[2] = 0;	
}
//-----------------------------------------------------------------------------------------------------------

@


1.12
log
@add func_set_timer
@
text
@d196 1
a196 1
        sendmsg.mtype           = 100;
@


1.11
log
@to merge two message into one
@
text
@d14 1
d224 32
d330 1
a331 1

d333 1
a333 1
                                                                                                                             
d348 5
a352 1
		else{	
d354 2
a355 2
			printf("0xf5 failed!\n");	
                }	
@


1.10
log
@add alarm_kind & alarm_num
@
text
@d26 2
a27 2
extern 	int	alarm_num;
extern	int 	alarm_kind;
d415 1
a415 2
	MSG	sndmsg_alarm_num;
	MSG	sndmsg_alarm_kind;
d441 4
a444 3
                sndmsg_alarm_kind.mtype = 1;
                sndmsg_alarm_kind.data_type = ALARM_KIND_SEND;
                sndmsg_alarm_kind.msg_data.alarm_kind = alarm_kind;
d451 1
a451 1
                if(msgsnd(msgid_network, (MSG *)&sndmsg_alarm_kind, sizeof(MSG)-4, IPC_NOWAIT) == -1)
d453 1
a453 1
                        printf("sndmsg_alarm_kind msgsnd error!\n");
a455 12

		//send num message to network
		sndmsg_alarm_num.mtype = 1;
                sndmsg_alarm_num.data_type = ALARM_NUM_SEND;
                sndmsg_alarm_num.msg_data.alarm_num = alarm_num;

                if(msgsnd(msgid_network, (MSG *)&sndmsg_alarm_num, sizeof(MSG)-4, IPC_NOWAIT) == -1)
                {
                        printf("sndmsg_alarm_num msgsnd error!\n");
                        exit(1);
                }

@


1.9
log
@send alarm_send to network
@
text
@d27 1
a27 1

d358 14
a371 7
		case 0xd2: alarm_bit[0] = alarm_set[0] & 0x01; alarm_num = RESCUE_ONE; break;
		case 0xe8: alarm_bit[0] = alarm_set[0] & 0x02; alarm_num = RESCUE_TWO; break;
		case 0xd3: alarm_bit[0] = alarm_set[0] & 0x04; alarm_num = SMOKE_ONE; break;
		case 0xdb: alarm_bit[0] = alarm_set[0] & 0x08; alarm_num = SMOKE_TWO; break;
		case 0xe9: alarm_bit[0] = alarm_set[0] & 0x10; alarm_num = SMOKE_THREE; break;
		case 0xd5: alarm_bit[0] = alarm_set[0] & 0x20; alarm_num = GAS_ONE; break;
		case 0xea: alarm_bit[0] = alarm_set[0] & 0x40; alarm_num = GAS_TWO; break;
d374 28
a401 15
		case 0xd8: alarm_bit[1] = alarm_set[1] & 0x01; alarm_num = DOOR_MAG_ONE; break;
		case 0xed: alarm_bit[1] = alarm_set[1] & 0x02; alarm_num = DOOR_MAG_TWO; break;
		case 0xd9: alarm_bit[1] = alarm_set[1] & 0x04; alarm_num = WIN_MAG_ONE; break;
		case 0xde: alarm_bit[1] = alarm_set[1] & 0x08; alarm_num = WIN_MAG_TWO; break;
		case 0xee: alarm_bit[1] = alarm_set[1] & 0x10; alarm_num = WIN_MAG_THREE; break;
		case 0xd6: alarm_bit[1] = alarm_set[1] & 0x20; alarm_num = INFRARED_ONE; break;
		case 0xdc: alarm_bit[1] = alarm_set[1] & 0x40; alarm_num = INFRARED_TWO; break;
		case 0xeb: alarm_bit[1] = alarm_set[1] & 0x80; alarm_num = INFRARED_THREE; break;


		case 0xd7: alarm_bit[2] = alarm_set[2] & 0x01; alarm_num = CURTAIN_ONE; break;
		case 0xdd: alarm_bit[2] = alarm_set[2] & 0x02; alarm_num = CURTAIN_TWO; break;
		case 0xec: alarm_bit[2] = alarm_set[2] & 0x04; alarm_num = CURTAIN_THREE; break;
		case 0xda: alarm_bit[2] = alarm_set[2] & 0x08; alarm_num = QUAKE_ONE; break;
		case 0xef: alarm_bit[2] = alarm_set[2] & 0x10; alarm_num = QUAKE_TWO; break;
d403 2
a404 1
		case 0xdf: alarm_bit[2] = alarm_set[2] & 0x80; alarm_num = AROUND_PROTECT; break;
d415 2
a416 1
	MSG	sndmsg_network;
d440 5
a444 7

		//send message to network
		sndmsg_network.mtype = 1;
                sndmsg_network.data_type = ALARM_SEND;
                sndmsg_network.msg_data.alarm_send[0] = alarm_bit[0];
                sndmsg_network.msg_data.alarm_send[1] = alarm_bit[1];
                sndmsg_network.msg_data.alarm_send[2] = alarm_bit[2];
d451 12
a462 1
                if(msgsnd(msgid_network, (MSG *)&sndmsg_network, sizeof(MSG)-4, IPC_NOWAIT) == -1)
d464 1
a464 1
                        printf("sndmsg_network msgsnd error!\n");
@


1.8
log
@delete the alarm_upset
@
text
@d393 2
a394 1
	MSG	sndmsg_arise;
d397 1
d403 4
a406 4
		//send message!                                             
	        sndmsg_arise.mtype = 1;
        	sndmsg_arise.data_type = SYSINFO;
	        sndmsg_arise.msg_data.sys_info = ALARM;
d413 1
a413 1
		if(msgsnd(msgid_sysinfo, (MSG *)&sndmsg_arise, sizeof(MSG)-4, IPC_NOWAIT) == -1)
d415 1
a415 1
       	        	printf("sndmsg_arise msgsnd error!\n");
d418 19
@


1.7
log
@change the read and write style of arise_record
@
text
@a276 1
	char 	alarm_upset[3];
@


1.6
log
@change msgtype from SERVMANGE to SYSINFO
@
text
@d285 1
a285 1
        fread(alarm_upset, 1, 3, fp2);
a286 6
        //To set the last context of alarm_set[4]
        for(i=0; i<3; i++)
        {
                alarm_set[i] = alarm_upset[2-i];
        }

@


1.5
log
@modify
@
text
@d24 2
a25 1
extern  char    alarm_set[4];
d275 20
d360 1
a360 1
int fn_operation(char * buffer)
d362 1
a362 1
	int	alarm_bit;	
d365 7
a371 7
		case 0xd2: alarm_bit = 1; alarm_num = RESCUE_ONE; break; // alarm_bit = alarm_set[0] & 0x01;
		case 0xe8: alarm_bit = 1; alarm_num = RESCUE_TWO; break;
		case 0xd3: alarm_bit = 1; alarm_num = SMOKE_ONE; break;
		case 0xdb: alarm_bit = 1; alarm_num = SMOKE_TWO; break;
		case 0xe9: alarm_bit = 1; alarm_num = SMOKE_THREE; break;
		case 0xd5: alarm_bit = 1; alarm_num = GAS_ONE; break;
		case 0xea: alarm_bit = 1; alarm_num = GAS_TWO; break;
d374 8
a381 8
		case 0xd8: alarm_bit = alarm_set[1] & 0x01; alarm_num = DOOR_MAG_ONE; break;
		case 0xed: alarm_bit = alarm_set[1] & 0x02; alarm_num = DOOR_MAG_TWO; break;
		case 0xd9: alarm_bit = alarm_set[1] & 0x04; alarm_num = WIN_MAG_ONE; break;
		case 0xde: alarm_bit = alarm_set[1] & 0x08; alarm_num = WIN_MAG_TWO; break;
		case 0xee: alarm_bit = alarm_set[1] & 0x10; alarm_num = WIN_MAG_THREE; break;
		case 0xd6: alarm_bit = alarm_set[1] & 0x20; alarm_num = INFRARED_ONE; break;
		case 0xdc: alarm_bit = alarm_set[1] & 0x40; alarm_num = INFRARED_TWO; break;
		case 0xeb: alarm_bit = alarm_set[1] & 0x80; alarm_num = INFRARED_THREE; break;
d384 5
a388 5
		case 0xd7: alarm_bit = alarm_set[2] & 0x01; alarm_num = CURTAIN_ONE; break;
		case 0xdd: alarm_bit = alarm_set[2] & 0x02; alarm_num = CURTAIN_TWO; break;
		case 0xec: alarm_bit = alarm_set[2] & 0x04; alarm_num = CURTAIN_THREE; break;
		case 0xda: alarm_bit = alarm_set[2] & 0x08; alarm_num = QUAKE_ONE; break;
		case 0xef: alarm_bit = alarm_set[2] & 0x10; alarm_num = QUAKE_TWO; break;
d390 1
a390 1
		case 0xdf: alarm_bit = alarm_set[2] & 0x80; alarm_num = AROUND_PROTECT; break;
d393 1
a393 1
	return alarm_bit;
d398 1
a398 1
void fn_msg_snd(int alarm_bit)
d402 1
a402 1
	int	msgid_serv;
d404 1
d406 1
a406 1
	if(alarm_bit)
d410 2
a411 2
        	sndmsg_arise.data_type = ALARM_ARISE;
	        sndmsg_arise.msg_data.alarm_num = alarm_num;
d413 1
a413 1
		if((msgid_serv = msgget(SERVMANAGE_MSGQ, IPC_CREAT)) == -1)
d415 1
a415 1
               		printf("SERIAL_MSGQ get error!\n");
d418 1
a418 1
		if(msgsnd(msgid_serv, (MSG *)&sndmsg_arise, sizeof(MSG)-4, IPC_NOWAIT) == -1)
d420 1
a420 1
       	        	printf("sndmsg_alarm, msgsnd error!\n");
d423 10
d438 3
@


1.4
log
@modify
@
text
@a400 9
		//receive message for test!
		if(msgrcv(msgid_serv, (MSG *)&rcvmsg_arise, 80, 0, 0) == -1)
		{
			printf("SERV_MSGQ msgrcv error!\n");
			exit(1);
		}

		printf("The message from SERV_MSGQ data_type:%x\n",rcvmsg_arise.data_type);
	        printf("The message from SERV_MSGQ alarm_num:%x\n",rcvmsg_arise.msg_data.alarm_num);
@


1.3
log
@change %d to %x in the fn_msg_snd
@
text
@d191 3
a193 4
        key_t keyval0 = SERIAL_MSGQ;
        int msgq_id0 = 0;
        if(msgq_id0 == 0)
                msgq_id0 = msgget(keyval0,IPC_CREAT);                                                                                                               
d196 1
a196 1
        sendmsg.from_service    = ALARM_ARISE;
d199 1
a199 1
        msgsnd(msgq_id0, &sendmsg, (sizeof(MSG) - 4), 0);
a223 1
	printf("In the thread!\n");
d235 1
a235 1
        printf("msgid_serial = %d\n",msgid_serial);
d249 1
a249 1
		printf("in the pthread!\n"); 
d264 5
a268 5
			printf("In the serial!\n");
			printf("The message from SERIAL_MSGQ data_type:%x\n",rcvmsg_serial.data_type);
	        	printf("The message from SERIAL_MSGQ alarm[0]:%x\n",rcvmsg_serial.msg_data.alarm[0]);
	        	printf("The message from SERIAL_MSGQ alarm[1]:%x\n",rcvmsg_serial.msg_data.alarm[1]);
			printf("The msssage from SERIAL_MSGQ alarm[2]:%x\n",rcvmsg_serial.msg_data.alarm[2]);
@


1.2
log
@change goto to while and use the alarm_num.h
@
text
@d410 2
a411 2
		printf("The message from SERV_MSGQ data_type:%d\n",rcvmsg_arise.data_type);
	        printf("The message from SERV_MSGQ alarm_num:%d\n",rcvmsg_arise.msg_data.alarm_num);
@


1.1
log
@added
@
text
@d1 12
a12 14
#include           /*标准输入输出定义*/
#include          /*标准函数库定义*/
#include          /*Unix 标准函数定义*/
#include     
#include     
#include     
#include     
#include           /*文件控制定义*/
#include         /*PPSIX 终端控制定义*/
#include           /*错误号定义*/
#include     

#include                                                                                                                                  
//#include 
a13 3
//#include 
//#include 
                                                                                                                             
d16 1
a16 6
//#include 
//#include 
//#include 



d25 1
a25 3
extern  char    alarm_arise[4];


d179 6
d186 37
a222 1
//--------------------------------------------------------------------------------------------------------------------------
a243 1
                                                                                                                             
a247 1
                                                                                                                             
a248 1
                                                                                                                             
a272 1
        	
d275 1
a275 1
//--------------------------------------------------------------------------------------------------------------------------
d280 1
d289 2
a290 1
label_1:
a292 1
                                                                                                                             
d297 1
a297 1
               if(read(fdcom, &sign, 1) > 0){                                                                                                              
a298 1
			
d301 1
d306 1
a306 2
                	goto label_1;
		}
d309 1
d311 2
a312 2

label_2:
a314 1
                                                                                                                     
a324 1
		int i;
d329 1
d331 2
a332 2
        else{                                                                                                             
        	printf("readlen != 6\n");
d334 2
a335 3
                goto label_2;
	}
	
d339 1
a339 1
//--------------------------------------------------------------------------------------------------------------------------
d346 7
a352 7
		case 0xd2: alarm_bit = 1; alarm_arise[0] |= 0x01; break; // alarm_bit = alarm_set[0] & 0x01;
		case 0xe8: alarm_bit = 1; alarm_arise[0] |= 0x02; break;
		case 0xd3: alarm_bit = 1; alarm_arise[0] |= 0x04; break;
		case 0xdb: alarm_bit = 1; alarm_arise[0] |= 0x08; break;
		case 0xe9: alarm_bit = 1; alarm_arise[0] |= 0x10; break;
		case 0xd5: alarm_bit = 1; alarm_arise[0] |= 0x20; break;
		case 0xea: alarm_bit = 1; alarm_arise[0] |= 0x40; break;
d355 8
a362 8
		case 0xd8: alarm_bit = alarm_set[1] & 0x01; alarm_arise[1] |= 0x01; break;
		case 0xed: alarm_bit = alarm_set[1] & 0x02; alarm_arise[1] |= 0x02; break;
		case 0xd9: alarm_bit = alarm_set[1] & 0x04; alarm_arise[1] |= 0x04; break;
		case 0xde: alarm_bit = alarm_set[1] & 0x08; alarm_arise[1] |= 0x08; break;
		case 0xee: alarm_bit = alarm_set[1] & 0x10; alarm_arise[1] |= 0x10; break;
		case 0xd6: alarm_bit = alarm_set[1] & 0x20; alarm_arise[1] |= 0x20; break;
		case 0xdc: alarm_bit = alarm_set[1] & 0x40; alarm_arise[1] |= 0x40; break;
		case 0xeb: alarm_bit = alarm_set[1] & 0x80; alarm_arise[1] |= 0x80; break;
d365 5
a369 5
		case 0xd7: alarm_bit = alarm_set[2] & 0x01; alarm_arise[2] |= 0x01; break;
		case 0xdd: alarm_bit = alarm_set[2] & 0x02; alarm_arise[2] |= 0x02; break;
		case 0xec: alarm_bit = alarm_set[2] & 0x04; alarm_arise[2] |= 0x04; break;
		case 0xda: alarm_bit = alarm_set[2] & 0x08; alarm_arise[2] |= 0x08; break;
		case 0xef: alarm_bit = alarm_set[2] & 0x10; alarm_arise[2] |= 0x10; break;
d371 1
a371 1
		case 0xdf: alarm_bit = alarm_set[2] & 0x80; alarm_arise[2] |= 0x80; break;
a373 7
/*
	//unsigned int 	temp = 0x00000001;
	if(buffer[0] == 0x01)          //switch(buffer[0]),命令字
        {
		alarm_bit =*((unsigned int *)alarm_set) & (temp << ((int)buffer[1]-1));			
        }
*/
d378 2
a379 2
//-------------------------------------------------------------------------------------------------------------------------
void fn_msg_snd(int alarm_bit, char *buffer)
d384 2
d387 5
a391 7
        {
		//send message!                                                                                                                             
                sndmsg_arise.mtype = 1;
                sndmsg_arise.data_type = ALARM_ARISE;
                sndmsg_arise.msg_data.alarm[0] = alarm_arise[0];
                sndmsg_arise.msg_data.alarm[1] = alarm_arise[1];
                sndmsg_arise.msg_data.alarm[2] = alarm_arise[2];
d394 5
d400 3
a402 11
                	printf("SERIAL_MSGQ get error!\n");
              	  	exit(1);
        	}
	
		if(msgsnd(msgid_serv, (MSG *)&sndmsg_arise, sizeof(MSG)-4, IPC_NOWAIT) == -1)
	        {
        	        printf("sndmsg_alarm, msgsnd error!\n");
                	exit(1);
        	}
                                                                                                             

d411 4
a414 4
                printf("The message from SERV_MSGQ alarm[0]:%d\n",rcvmsg_arise.msg_data.alarm[0]);
                printf("The message from SERV_MSGQ alarm[1]:%d\n",rcvmsg_arise.msg_data.alarm[1]);
                printf("The message from SERV_MSGQ alarm[2]:%d\n",rcvmsg_arise.msg_data.alarm[2]);
        }
d416 1
d418 1
a418 9

//--------------------------------------------------------------------------------------------------------------------------

void handle_func()
{
	printf("End of serial!\n");
        _exit(0);
                                                                                                                             
}
@