caijiji.c

linux modbus程序

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
//#include <pid.h>
#include <signal.h>
#include <wait.h>
#include <pthread.h>
#include <errno.h>
#include <termios.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <sys/time.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <string.h>
#include "can4linux.h"

#include <sys/stat.h>

#include <term.h>
#include <curses.h>


/*******
display data
**/
#define LEFT 0
#define RIGHT 1
#define LEFT_CMD        0
#define LEFT_DATA       1
#define RIGHT_CMD       2
#define RIGHT_DATA      3

/*****
net data
***/
#define  CSE_PORT 1236                          //采集机主动发送开关量等数据
#define CRE_PORT 1237	                        //采集机接受口

#define BUFFERLEN 255
#define SERIAL_232 "/dev/ttyS0"
#define SE232_BT B115200
#define FEN_NUM 0 //0-31采集机

 char sename[8][11]={"/dev/ttyS2","/dev/ttyS3","/dev/ttyS4","/dev/ttyS5",
 					"/dev/ttyS6","/dev/ttyS7","/dev/ttyS8","/dev/ttyS9"};
 int fd_485[8];
Config_par_t cfg;

char sercan_id;
pthread_mutex_t net_lock,can_lock;
int erro_vari[8]={0};
int swit=1;
char erro_flag=1;
 struct data_zone {
	short a[15][40];
	short b[3][255];
	}dazo;
char cmde[]={0x1e,0x7f,0x80,0x81,0x82,0x84,0x86,0x87,0x88,0x89,
			0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x98,0x99,0x9a};
unsigned int T_accmask,T_acccode,T_baud,T_mode_reg;
int  fd_CAN0,fd_CAN1;
char back=0;
struct net_485 {
		unsigned int serverip;
		unsigned int clientip;
		}net_conf;
	
struct can_conf485 {
		unsigned char can_ad;
		unsigned short can_rate;
		}can_conf;

struct conf_485 {
		unsigned short brate;
		unsigned char interval;
		unsigned char timeout;
		}conf485;
struct config_duce {
		unsigned char st_ad;
		unsigned char ad_len;
		unsigned char code;
		};
struct config_com {
		
		unsigned char ad_num;                         //八个485索引号
		unsigned char index;                             //每个485下32个接点地址0-31
		struct config_duce conduce[32];           //每个接点地址下的积存器信息
		struct conf_485 conf485;
		}com485[8];


void  my_erro(const char str[]) { 
	printf("%s\n",str);
	exit(-1); }                //改为goto

int save_conf(void)
{
	int size,i;
	FILE *conf_s;
	if((conf_s=fopen("/home/config_232","w+"))==NULL)
		{
		printf("open file erro\n");
		return -1;
		}
	rewind(conf_s);
	size=sizeof(struct config_com);
	fwrite(&com485[0],size,8,conf_s);
	fclose(conf_s);
	printf("save data sucess!\n");
	return 0;	
}

int load_conf(void)	
{
	int size,i;
	FILE *conf_s;	
	if((conf_s=fopen("/home/config_232","r+"))==NULL)
		{
		printf("open file erro\n");
		return -1;
		}
	rewind(conf_s);
	size=sizeof(struct config_com);
	fread(&com485[0],size,8,conf_s);
	fclose(conf_s);
	printf("load config data sucess\n");
	can_conf.can_ad=1;
	can_conf.can_rate=250;
	return 0;
}



void clear_child(int signo)
{
	int stat,pid;
	while((pid=waitpid(-1,&stat,WNOHANG))>0)
	printf("child process %d cleaned,return %d\n",pid,stat);
}

int serial232(struct config_com com485[],struct can_conf485 *can_confp,struct net_485 *net_confp) 
{	
	int fd,num,i;
	char config_msg[10]={0};
	char se_ok=0x06;                  //接受8字节成功
	char se_erro=0x04;                 //接受8字节失败
	if((fd=open(SERIAL_232,O_RDWR))<0)
		{
		printf("232 open failed\n");
		return 1;
		}
	
	struct termios opt;
	tcgetattr(fd,&opt);
	cfsetispeed(&opt,SE232_BT);
	cfsetospeed(&opt,SE232_BT);
	opt.c_cflag &=~PARENB;
	opt.c_cflag &=~CSTOPB;
	opt.c_cflag &=~CSIZE;
	opt.c_cflag|=CS8;
//	opt.c_cflag=SE232_BT | CS8 | CLOCAL | CREAD;
	opt.c_cc[VTIME]=0;
	opt.c_cc[VMIN]=8;
	opt.c_lflag &=~(ICANON|ECHO|ECHOE|ISIG);
	opt.c_oflag =0;
	opt.c_iflag = IGNPAR;
	tcflush(fd, TCIFLUSH);
	tcsetattr(fd,TCSANOW,&opt);

	printf("receive confige infomation\n");
	while(1)
		{
		memset(config_msg,0,sizeof(config_msg));
		if((num=read(fd,config_msg,8))<0)
			{
			printf("232 read failed\n");
			return -1;
			}
		printf("num=%d\n",num);
		for(i=0;i<8;i++)
			printf("%x ",config_msg[i]);

		if(config_msg[1]!=FEN_NUM) //注意委婉
			{
			printf("not config local no!my fen_sum=%d\n",FEN_NUM);
			return -1;
			}
		if((config_msg[0]==0xfa)&&(config_msg[7]==0xff))
			{
			if(write(fd,&se_ok,1)<0)
				{
				printf("232 write failed\n");
				
				}
			printf("configure end\n");
			goto out;
			}
		if(((config_msg[0]==0x0a)||(config_msg[0]==0x0b)||(config_msg[0]==0x0c)||(config_msg[0]==0x0d))&&(config_msg[7]==0xff))
		{
		switch(config_msg[0])
			{
			case 0x0a:
				{
					com485[config_msg[2]].ad_num=config_msg[2];
					com485[config_msg[2]].index=config_msg[3];
					com485[config_msg[2]].conduce[config_msg[3]].st_ad=config_msg[4];
					com485[config_msg[2]].conduce[config_msg[3]].ad_len=config_msg[5];
					com485[config_msg[2]].conduce[config_msg[3]].code=config_msg[6];
				
					break;
				}
			case 0x0b:
				{
					com485[config_msg[2]].ad_num=config_msg[2];
					
					com485[config_msg[2]].conf485.brate=config_msg[3]&0xff;
					com485[config_msg[2]].conf485.brate|=(config_msg[4]&0xff)<<8;
					com485[config_msg[2]].conf485.interval=config_msg[5];
					com485[config_msg[2]].conf485.timeout=config_msg[6];
					break;
				}
			case 0x0c:
					{
					can_confp->can_ad=config_msg[2];
					can_confp->can_rate=config_msg[3]&0xff;
//					can_conf->can_rate=(config_msg[4]&0xff)<<8;
					can_confp->can_rate*=10;
					break;
					}
			case 0x0d:
					{
						if(config_msg[2]==1)
							{
							net_confp->serverip=config_msg[3];
							net_confp->serverip|=config_msg[4]<<8;
							net_confp->serverip|=config_msg[5]<<0x10;
							net_confp->serverip|=config_msg[6]<<0x18;
							}
						else {
							net_confp->clientip=config_msg[3];
							net_confp->clientip|=config_msg[4]<<8;
							net_confp->clientip|=config_msg[5]<<0x10;
							net_confp->clientip|=config_msg[6]<<0x18;
							}
						break;
					}
			
			}
		write(fd,&se_ok,1);
//			{
//			printf("232 write sucess\n");
//			close(fd);
//			return -1;
//			}
						
		}
		
		else 			
			{
			write(fd,&se_erro,1);
			printf("232 recv erro\n");
			}
		}
out:
	printf("configure sucess!\n");
//	tcsetattr(fd, TCSANOW, &oldtio);
	close(fd);
	save_conf();
	return 0;
		
}

int serial485_init(struct config_com com485[]) 
{	
	int speed_arr[] = {B115200,B57600,B38400, B19200, B9600, B4800, B2400, B1200, B300,  };
	int name_arr[] = {0xf0f0,0xe100,0x9600, 0x4b00, 0x2580, 0x12c0, 0x960, 0x4b0, 0x12c,};

	struct termios options;
	int seri,i;
	for(seri=0;seri<8;seri++)
		{
		if((fd_485[seri]=open(sename[seri],O_RDWR))<0)
			{
			printf("no %d 485 open failed\n",seri);
			return -1;
			}
		printf("fd%d=%d\n",fd_485[seri],fd_485[seri]);
		tcgetattr(fd_485[seri],&options);	
		if(com485[seri].conf485.brate==0)
			{
			cfsetispeed(&options,speed_arr[3]);
			cfsetospeed(&options,speed_arr[3]);
			}
		else {
			for(i=0;i<9;i++)
				if(com485[seri].conf485.brate==name_arr[i])
					{
					cfsetispeed(&options,speed_arr[i]);
					cfsetospeed(&options,speed_arr[i]);
					break;
					}
			}	
		options.c_iflag |= INPCK;
		options.c_cflag |= PARENB; 
		options.c_cflag &= ~PARODD;
		options.c_cflag &=~CSTOPB;
		options.c_cflag &=~CSIZE;
		options.c_cflag |=CS8;
//		options.c_iflag = IGNPAR;
		options.c_lflag &=~(ICANON|ECHO|ECHOE|ISIG);
		options.c_oflag=0;
		options.c_cc[VTIME] = (com485[seri].conf485.timeout)*10; /* 设置超时500 ms*/   
		options.c_cc[VMIN] = BUFFERLEN; 
		tcsetattr(fd_485[seri],TCSANOW,&options);
		}
	printf("485 config sucess\n");
	return 0;
}

/*******
void calccrc(char a)
{
	char i;

	crc=crc ^ a;
	for(i=0;i<8;i++)
	{
		char TT;
		crc=crc>>1;
		crc=crc&0x7fff;
		TT=crc&1;
		if (TT==1)
			crc=crc^0xa001;
		crc=crc&0xffff;
	}
}

*******/
int write_data4(char buff[],int init,int sum);
int net_send(char send_msg1[],int init,int sum);
char erro_put[2]={0};
//int test[8]={0};
void erro_fun(void)
{
	char self_erro[5];
	int t,i;
	for(t=0;t<8;t++)
		{
		if(erro_vari[t]==0)
			if(t>7)
				{
				erro_flag=0;
				goto out;
				}	
		else {
			self_erro[0]=0;
			self_erro[1]=0x1f;
			self_erro[2]=0x02;
			int l;
			if(erro_vari[t]!=0)
			{
			self_erro[3]=t;
			for(l=0;l<31;l++)
				{
				if((erro_vari[t]>>l)&0x01!=0)
					{
					self_erro[4]=l;
					erro_put[0]=t;
					erro_put[1]=l;
					erro_flag=1;
					if(swit==1)
						{
						pthread_mutex_lock(&can_lock);
						write_data4(self_erro,1,5);
						pthread_mutex_unlock(&can_lock);
						}
					else {
						pthread_mutex_lock(&net_lock);
						net_send(self_erro,1,5);
						pthread_mutex_unlock(&net_lock);
						}

					}
				}
					
			}
		
			}
		}
out:
	for(i=0;i<8;i++)
		{
//		test[i]=erro_vari[i];
		erro_vari[i]=0;
		}
}


int *scan_485(void)
{
	int i,retval,turn=0,m,loop=0,s,senu,rs,recv_erro;//loop--每次请循环清除字节数
	char modbus1[8];             
	char modbus2[BUFFERLEN];
	int utime;
//	crc=0xffff;
	memset(modbus1,0,8);
//			crc=(crc&0)|0xffff;
	for(i=0;i<18;i++)
		if(i<=14)
			memset(dazo.a[i],0,40);
		else memset(dazo.b[i-15],0,BUFFERLEN);
	for(senu=0;senu<8;senu++)
		printf("fd=%d ",fd_485[senu]);
	while(1)
		{
		for(senu=0;senu<8;senu++)
			for(i=0;i<32;i++)			
			{
			recv_erro=0;
			rs=0;
			if((com485[senu].conduce[i].ad_len!=0)&&(cmde[turn]==com485[senu].conduce[i].code))
				{
				modbus1[0]=i;
				modbus1[1]=0x03;
				modbus1[2]=0;
				modbus1[3]=com485[senu].conduce[i].st_ad;
				modbus1[4]=0;
				modbus1[5]=com485[senu].conduce[i].ad_len;
				modbus1[6]=0;
				modbus1[7]=0;
retry:
				if(recv_erro>2)
					{
					erro_vari[senu]|=(int)(1<<i);
					printf("485 comunication erro\n");
					continue;
					}
				retval=write(fd_485[senu],modbus1,8);
				if(retval<0) 
					my_erro("code write erro");
				rs=read(fd_485[senu],modbus2,BUFFERLEN);
				printf("485 read end\n");
				if(rs<0) 
					my_erro("code read erro");
				if(rs=0)
					{
					printf("485 recv modbus rs=0\n");
					recv_erro++;
					goto retry;
					}
				if(rs>0)
				{
					if((modbus2[1]!=0x03)||(modbus2[2]!=(rs-4)))
					{
					recv_erro++;
					usleep(com485[senu].conf485.interval);
					goto retry;
					}
				erro_fun();
				memset(modbus2,0,BUFFERLEN);
				if(turn<=14)
					{
					if(loop==0)
						{
						loop=1;
						dazo.a[turn-2][0]=0;
						m=2;
						}
						dazo.a[turn-2][0]+=(rs-4);
						dazo.a[turn-2][1]=0;
					memcpy(&dazo.a[turn-2][m],&modbus2[2],(rs-4));
					m+=(rs-4);
					}
				else {
					if(loop==0)
						{
						loop=1;
						dazo.b[turn-17][0]=0;
						m=2;
						}
					dazo.b[turn-17][0]+=(rs-4)+10;
					dazo.b[turn-17][1]=0;
					dazo.b[turn-17][++m]=senu;
					dazo.b[turn-17][++m]=i;
					dazo.b[turn-17][++m]=com485[senu].conduce[i].ad_len;
					if((turn==19)||(turn==17))
						{
						utime=time((time_t *)NULL);
						dazo.b[turn-17][++m]=utime&0xff;
						dazo.b[turn-17][++m]=(utime>>8)&0xff;
						dazo.b[turn-17][++m]=(utime>>16)&0xff;
						dazo.b[turn-17][++m]=(utime>>24)&0xff;
						if(senu==7)
							dazo.b[turn-17][++m]=0;
						else
							dazo.b[turn-17][++m]=1;
						}
					
					dazo.b[turn-17][++m]=rs-4;
					dazo.b[turn-17][++m]=0;
					memcpy(&dazo.b[turn-17][++m],&modbus2[2],(rs-4));
					m+=(rs-4);
					}
				usleep(com485[senu].conf485.interval);
				}
			}
			
			}
		loop=0;
		turn++;
		if(turn==20)
			{
			back=1;
			m=0;
			turn=0;
		       }
		}
	return 0;
}


int read_485buff(char cmd,char msg[])
{	
	
	int ret,i; 
	msg[0]=0;
	msg[1]=cmd;
	
	for(i=0;i<20;i++)
		if(cmd==cmde[i])
			{
			if(i<=16)