caijiji.c

linux modbus程序

				memcpy(&msg[2],&dazo.a[i-2][0],dazo.a[i-2][0]+1);
						
			else 
				{
				if(dazo.b[i-17][0]==0)
					{
				msg[2]=0;
				msg[3]=0;
				
					}

				else  memcpy(&msg[2],&dazo.b[i-17][0],dazo.b[i-17][0]+1);
									
				}
			
			printf("read buff \n");

			return 0;
			}
			
	printf("read buff erro\n");
	return -1;			
				
}




void bus_run_wrong(int can_num,int fd)
{
	unsigned char  status_v,errcode_v,irq_value_v;
	CanStatusPar_t stat;
       ioctl(fd, STATUS, &stat);  
	sleep(0.01);
       status_v  = (unsigned char)stat.status;
       errcode_v = (unsigned char)stat.error_code;
	irq_value_v = (unsigned char)stat.irq_value;


	if(irq_value_v & 0x80 )
		printf("##[CAN %d]Bus Error!(0x%x)\n",can_num+1,errcode_v);

	else if(irq_value_v & 0x08)
		printf("##[CAN %d]Data Overrun!(0x%x)\n",can_num+1,errcode_v);

}


char can_erroflag=0;
int write_data4(char buff[],int init,int sum)      //给主机发送数据
{
	canmsg_t tx;
	int  n,i,m=0,temp;
//	int  init=0;
	char end=0;
	int framnum=0;
	n=sum;
	if(sum==0)
		n=2;
	temp=n;
	for(i=0;i < 8;i++)
        	tx.data[i] = 0;
	while(!end)
		{
		
		if(init==1)
			{
			tx.id=1540;
			for(i=0;i < n;i++,m++)
        			tx.data[i] = buff[m];
			
			end=1;
			goto ok;
			}
		if(n<=8)
			{for(i=0;i < n;i++,m++)
        			{
        			tx.data[i] = buff[m];
				tx.id=1536;
				
				}
//			temp=0;
			end=1;
			}
		else
			{
			if(temp>=6)
				for(i=1;i < 8;i++,m++)
        			{
        			tx.data[0]=framnum;
        			tx.data[i] = buff[m];
				tx.id=1539;
				temp--;
				if(!temp)
					break;
				}

			else if (temp<=5)				
				{
				if(temp==0)
						{								
							tx.data[0]=framnum;
							tx.data[1]=buff[2];
							tx.data[2]=0;
							tx.id=1538;
							end=1;
							goto ok;
						}
				else for(i=1;i<(temp+1);i++,m++)
					{	
				end=1;
				tx.data[0]=framnum;
				tx.data[1]=buff[2];
				tx.data[2]=0;
				tx.data[i+2] = buff[m];
				tx.id=1538;
					}
				}
			}
ok:
		tx.flags = 0;  
		tx.id=(tx.id&(~(unsigned long)0xf8))|(sercan_id<<3);
        	if((tx.length = sizeof(tx.data))==0)
		{
		printf("no data write\n");
		return 0;
		}
        	
        	if(write(fd_CAN0, &tx, 1) > 0)
        		{
			
    	    			printf("CAN 1 TX_frame> >:  %+2x  %+2x  %+2x  %+2x  %+2x  %+2x  %+2x  %+2x\n", \
			tx.data[7],tx.data[6],tx.data[5],tx.data[4],\
                    		tx.data[3],tx.data[2],tx.data[1],tx.data[0]);
            			bus_run_wrong(0,fd_CAN0);//####
            			for(i=0;i<8;i++)
					tx.data[i]=0;
			framnum++;
        		}
		else can_erroflag=1;
		}
	printf("can send end\n");
	return 0;

}


void *read_data0(void)    //采集机读传感器
{
	can_conf.can_ad=1;///35tetr
	canmsg_t rx;
	int i,m;
	char send_buff[BUFFERLEN];
	
   	 for(;;)
    	{
loop:
        	if(read(fd_CAN0, &rx, 1)>0 )   //
        	{

        	
        	printf("CAN 2 RX_frame< < :  %+2x  %+2x  %+2x  %+2x  %+2x  %+2x  %+2x  %+2x\n",\
                   rx.data[7],rx.data[6],rx.data[5],rx.data[4],\
                   rx.data[3],rx.data[2],rx.data[1],rx.data[0]);
		
		if(((rx.id>>3)&0x1f)==can_conf.can_ad)	
			{
				memset(send_buff,0,BUFFERLEN);
				for(i=0;i<20;i++)
  					{
  					if(rx.data[1]==cmde[i])
						break;
					if(i==19)
						{
						printf("cmd invalid\n");
						goto loop;
						}
					}
				switch(rx.data[1])
				{
				case 0x7f:
					{
					struct timeval tv;
						struct timezone tz;
						long temp=0;
						temp=rx.data[2];
						temp|=rx.data[3]<<8;
						temp|=rx.data[4]<<16;
						temp|=rx.data[5]<<24;
						gettimeofday(&tv,&tz);
						tv.tv_sec=temp;
						send_buff[0]=0;
						send_buff[1]=0x7f;
						if(settimeofday(&tv,&tz)<0)
							send_buff[2]=0;
						else send_buff[2]=1;
						send_buff[3]='\0';
						pthread_mutex_lock(&can_lock);
						write_data4(send_buff,0,3);
						pthread_mutex_unlock(&can_lock);
						break;
					}
				case 0x1e:
					{
						send_buff[0]=0;
						send_buff[1]=0x1e;
						
						for(i=0,m=0;i<8;i++)
							{
							send_buff[2+m]=erro_vari[i]&0xff;
							send_buff[3+m]=(erro_vari[i]>>8)&0xff;
							send_buff[4+m]=(erro_vari[i]>>16)&0xff;
							send_buff[5+m]=(erro_vari[i]>>24)&0xff;
							m+=4;
							}
						send_buff[34]='\0';
						pthread_mutex_lock(&can_lock);
						write_data4(send_buff,0,34);
						pthread_mutex_unlock(&can_lock);
						break;
					}
				default:
				 	{
					if(read_485buff(rx.data[1],send_buff)<0)
						my_erro("read 485 buff erro");
					pthread_mutex_lock(&can_lock);
					write_data4(send_buff,0,send_buff[2]);
					pthread_mutex_unlock(&can_lock);
					
					}
				}
				printf("can send \n");
				can_erroflag=0;
				}
        		}
		
        		
    	}
}


//============================================================================
void op_AccMask(int port)
{
int fd;
if(port==0) fd = fd_CAN0;
else        fd = fd_CAN1;
        cfg.target = CONF_ACCM;
        cfg.val1   = (unsigned long)T_accmask;
        ioctl(fd, CONFIG, &cfg);
}
//----------------------
void op_AccCode(int port)
{
int fd;
if(port==0) fd = fd_CAN0;
else        fd = fd_CAN1;
        cfg.target = CONF_ACCC;
        cfg.val1   = (unsigned long)T_acccode;
        ioctl(fd, CONFIG, &cfg);
}
//----------------------
void op_Baud(int port)
{
int fd;
if(port==0) fd = fd_CAN0;
else        fd = fd_CAN1;
        cfg.target = CONF_TIMING;
        cfg.val1   = (int)T_baud;
        ioctl(fd, CONFIG, &cfg);
}
//----------------------
void op_set_mode(int port)
{
int temp=T_mode_reg ,fd;   ////@
if(port==0) fd = fd_CAN0;
else        fd = fd_CAN1;
        cfg.target = CONF_MODE;//
        cfg.val1   = (int)temp;
        ioctl(fd, CONFIG, &cfg);  //val1=1 set; val1=0 reset
}
int PortSet(int port)
{
op_AccMask(port);
op_AccCode(port);
op_Baud   (port);
op_set_mode(port);
return 0 ;
}

int can_operation(void)
{
	int init=1;	
	int temp=T_mode_reg;
	pthread_t  CAN_RX_id0;
	char init_msg[]={0,0x11,0,0,0};
	T_baud=can_conf.can_rate=250;/////ryey
	T_accmask = 0xffffffff;
	 T_acccode = 0xffffffff;
	T_mode_reg= 0x08;
	printf("can fun\n");
	cfg.target = CONF_ACCM;
       cfg.val1   = (unsigned long)T_accmask;
       ioctl(fd_CAN0, CONFIG, &cfg);
	cfg.target = CONF_ACCC;
       cfg.val1   = (unsigned long)T_acccode;
       ioctl(fd_CAN0, CONFIG, &cfg);
	cfg.target = CONF_TIMING;
       cfg.val1   = (int)T_baud;
       ioctl(fd_CAN0, CONFIG, &cfg);
	cfg.target = CONF_MODE;
       cfg.val1   = (int)temp;
       ioctl(fd_CAN0, CONFIG, &cfg);  
	   if((fd_CAN0=open("/dev/can0",O_RDWR))<0)
		my_erro("can open erro");
	   PortSet(0);
	close(fd_CAN0);
	 
	fd_CAN0=open("/dev/can0",O_RDWR);
	   if(init==1)
	   	{
	   	pthread_mutex_lock(&can_lock);
	   	write_data4(init_msg,init,5);
		pthread_mutex_unlock(&can_lock);
	   	init=0;
		can_erroflag=0;
		}
	if (pthread_create(&CAN_RX_id0,NULL,(void *)read_data0, NULL)!= 0)

		 printf("create read_data0 fail\n"); 
              
			   
	pthread_join(CAN_RX_id0, NULL);
	close(fd_CAN0);
	return 0;
}

char net_erroflag=0;
int net_oper(void)
{	
	signal(SIGCHLD,clear_child);
	struct sockaddr_in recv_addr;
	int init=1,socklen,num,m,i;
	pid_t pid_r;
	char send_msg[BUFFERLEN],recv_msg[8];
	char init_msg[]={0,0x11,0,0,0};
	memset(&recv_addr,0,sizeof(struct sockaddr_in));
	
	int cli_sendfd,cli_recvfd,listenfd;
	printf("net fun\n");
	
	listenfd=socket(AF_INET,SOCK_STREAM,0);
	if(listenfd<0) 
		my_erro("listen erro");
	memset(&recv_addr,0,sizeof(struct sockaddr_in));
	recv_addr.sin_family=AF_INET;
	recv_addr.sin_addr.s_addr=htonl(INADDR_ANY);
	recv_addr.sin_port=htons(CRE_PORT);
	if(bind(listenfd,(struct sockaddr *)&recv_addr,sizeof(struct sockaddr_in))<0)
		{
		close(listenfd);
		my_erro("bind erro");
		}	
	listen(listenfd,2);
	socklen=sizeof(struct sockaddr_in);
	while(1){
			if(init==1)
					{
					pthread_mutex_lock(&net_lock);
					net_send(init_msg,init,5);
					pthread_mutex_unlock(&net_lock);
					init=0;
					
					}
			cli_recvfd=accept(listenfd,(struct sockaddr *)(&recv_addr),&socklen);
			if((pid_r=fork())==0) //子进程
				{ 
				printf("child fork \n");
				memset(&recv_msg,0,sizeof(recv_msg));
				memset(&send_msg,0,sizeof(send_msg));
netloop:
				if((num=recv(cli_recvfd,recv_msg,BUFFERLEN,0))<0)
					{
					close(cli_recvfd);
					net_erroflag=1;
					my_erro("net read erro");
					}
				
				else if(num>0)
					{
					net_erroflag=0;
					for(i=0;i<20;i++)
						{
						if(recv_msg[1]==cmde[i])
							break;
						else if(i>19)
							{
							printf("cmd invalid\n");
							goto netloop;
							}
						}
					printf("cmd=%x\n",recv_msg[1]);
					switch(recv_msg[1])
						{
					case 0x7f:
						{
						send_msg[0]=0;
						send_msg[1]=recv_msg[1];
						struct timeval tv;
						struct timezone tz;
						long tems=0;
						tems=recv_msg[2];
						tems|=recv_msg[3]<<8;
						tems|=recv_msg[4]<<16;
						tems|=recv_msg[5]<<24;
						gettimeofday(&tv,&tz);
						tv.tv_sec=tems;
						if(settimeofday(&tv,&tz)<0)
							send_msg[2]=0;
						else send_msg[2]=1;
						pthread_mutex_lock(&net_lock);
						net_send(send_msg,0,3);	
						pthread_mutex_unlock(&net_lock);
						break;                 
						}
					case 0x1e:
						{
						send_msg[0]=0;
						send_msg[1]=0x1e;
						for(i=0,m=0;i<8;i++)
							{
							send_msg[2+m]=erro_vari[i]&0xff;
							send_msg[3+m]=(erro_vari[i]>>8)&0xff;
							send_msg[4+m]=(erro_vari[i]>>16)&0xff;
							send_msg[5+m]=(erro_vari[i]>>24)&0xff;
							m+=4;
							}
						pthread_mutex_lock(&net_lock);
						net_send(send_msg,0,34);	
						pthread_mutex_unlock(&net_lock);
						break; 
						}
						
					default:
						{
							if(read_485buff(recv_msg[1],send_msg)!=0)
								my_erro("read 485 erro");
							pthread_mutex_lock(&net_lock);
							if((net_send(send_msg,0,send_msg[2]))!=0)
								{
								printf("net send erro\n");
								net_erroflag=1;
								}
							pthread_mutex_unlock(&net_lock);
						}
					}
					}
				close(listenfd);
				close(cli_recvfd);
				net_erroflag=0;
				printf("net send sucess!\n");
				exit(0);
				}
				
			else if(pid_r==-1)  {
					printf("send host failed\n");
					close(cli_recvfd);
					exit(1);
					}
			else  //主程序
				{
				
				close(cli_recvfd);
				}

			}
}

char servip0[20];
int net_send(char send_msg1[],int init,int sum)
{
	struct sockaddr_in send_addr;
	memset(&send_addr,0,sizeof(struct sockaddr_in));
	int i,send_num;
	send_addr.sin_family=AF_INET;
	send_addr.sin_addr.s_addr=inet_addr(servip0);
	send_addr.sin_port=htons(CSE_PORT);
	int cli_sendfd;
	char net_send0[BUFFERLEN+1];
	cli_sendfd=socket(AF_INET,SOCK_STREAM,0);
	if(cli_sendfd<0) 
		my_erro("sendfd erro");
	if(init==1)                             //网络发送第0字节说明是自主还是应答
		net_send0[0]=1;
	else net_send0[0]=0;
	if(sum==0)
		sum=4;
	send_num=sum;
	memcpy(&net_send0[1],send_msg1,send_num);
	for(i=0;i<send_num+1;i++)
		printf("data =%x ",net_send0[i]);

	if(connect(cli_sendfd,(struct sockaddr *)&send_addr,sizeof(struct sockaddr_in))<0)
		{
		printf("connect failed\n");
		return -1;
		}
	if(send(cli_sendfd,net_send0,send_num+1,0)<0)
		{
		close(cli_sendfd);
//		net_erroflag=1;
		my_erro("net write  erro");
		}
//	net_erroflag=0;
	close(cli_sendfd);
	printf("net send sucess!\n");
	return 0;
}


//uchar LcdCtrlLine = 0x00;
typedef unsigned char uchar;
void WriteLcdCmd(char seg, uchar cmd, int fd)
{
	if(seg == LEFT)
		ioctl(fd, LEFT_CMD, (unsigned long)&cmd);
		//outportb(0x304, cmd);
	else
		ioctl(fd, RIGHT_CMD, (unsigned long)&cmd);
		//outportb(0x306, cmd);
}

void WriteLcdData(char seg, uchar data, int fd)
{