comunic.cpp

profibus主站及从站源代码

#include "comunic.h"
#include <stdio.h>
#include <string.h>

long far* ceas,martor,timp;

unsigned char fc(){
  // nu m-am prins cine e fc asa ca e tot timpul 1
	return 1;
}



void init_port(int port){
	if (port==1) port = 0x3f8;
	else if (port==2) port = 0x2f8;
	else return;
	int DATE = port;	//port date
	int IER = port+1;	//interrupt enable register
//	int IIR = port+2;	//interrupt identification register
	int LCR = port+3;	//line control register
	int MCR = port+4;	//modem control register
//	int LSR = port+5;	//line status register
//	int MSR = port+6;	//modem status register
//	int SSR = port+7;	//status send-rec

	outportb(LCR, 0x80);//set Divisor Latch Access Bit (DLAB)
	outportb(DATE, 6);//19200 biti/s, divisor latch low byte
	outportb(IER, 0);//divisor latch high byte
	outportb(LCR, 0x1b);//caracter de 8 biti, paritate pare, 1 bit de stop
//	outportb(SSR, 0x01);//rec RS 485
//	outportb(IER, 0x0);//dezactiveaza intreruperile
	outportb(MCR, 0x0e);//activate OUT1, OUT2, DTR (rec)
 //	if((inportb(LSR) & 1) != 0) inportb(DATE);

}

unsigned char fcs(unsigned char pachet[])
{
	unsigned char fcs = 0;
	int i, lung;
	switch(pachet[0]){
		case SD1:
			lung = 3;
			i = 1;
			break;
		case SD2:
			lung = pachet[1] + 3;
			i = 4;
			break;
		case SD3:
			lung = 11;
			i = 1;
		}
	for (; i <= lung; i++){
		 fcs += pachet[i];
		}
	return fcs;
}

void send_char(int port,unsigned char c){
//	 char masca;
	 int STARE=port+5;
	 while(! ( (inportb(STARE)) & EMIS_G) );
	 /*printf("Starea citita este: %x\n",masca); */
	 outportb(port,c);
	 //printf("scriu %d\n",c);
}

int recv_char(int port,unsigned char *ch){
//	 unsigned char masca;
	 int STARE=port+5;
	 martor=*ceas;
	 while(! ( (inportb(STARE)) & RECP_C) )
	{
	 /*printf("Starea citita este: %x\n",masca);*/
	 timp= (*ceas) - martor;
	 if (timp >= TMOUT) return TIMEOUT;
	}
	 *ch = inportb(port);
	 //printf("am primit : %c \n",*ch);
	 return RECVOK;
}



TEL *recv(int com,int *type){
	if (com==1) com=0x3f8;
	else if(com==2) com=0x2f8;
	else {
		*type = UNKNOWN_COM;
		return NULL;
	}
	ceas=(long far *)MK_FP(0x0040,0x006c);
	int i;
	int front=0;
	TEL *tel;
	*type = TELEGRAMA_NECUNOSCUTA;
	int err;
	unsigned char ch; // caracter temp. pt. citire
	unsigned char test=0; // tin calculul fcs-ului pt. pachetul primit

	do {
		err = recv_char(com,&ch);
		if (err==TIMEOUT) {
			*type=TIMEOUT;
			return NULL;
		}
		if (ch==255) front++;
	}while (ch==255);

	switch (ch) {
		case SC: if (front) return NULL;
					*type = T_RASPUNS_SCURT;
					return NULL;

		case SD4: if (!front) return NULL;
					 tel = (TEL *)malloc(sizeof(TEL));
					 if (tel==NULL) {
							*type = MALLOC_ERROR;
							return NULL;
					 }
					 err=recv_char(com,&tel->da);
					 if (err==TIMEOUT) {
						*type=TIMEOUT;
						return NULL;
					 }
					 err=recv_char(com,&tel->sa);
					 if (err==TIMEOUT) {
						*type=TIMEOUT;
						return NULL;
					 }
					 *type = TOKEN;
					 return tel;

		case SD1: tel = (TEL *)malloc(sizeof(TEL));
					 if (tel==NULL) {
							*type = MALLOC_ERROR;
							return NULL;
					 }
					 *type = TELEGRAM_ERROR;
					 err=recv_char(com,&tel->da);
					 if (err==TIMEOUT) {
						*type=TIMEOUT;
						return NULL;
					 }
					 err=recv_char(com,&tel->sa);
					 if (err==TIMEOUT) {
						*type=TIMEOUT;
						return NULL;
					 }
					 err=recv_char(com,&ch); //fc
					 if (err==TIMEOUT) {
						*type=TIMEOUT;
						return NULL;
					 }
					 test = tel->da + tel->sa + ch;
					 err=recv_char(com,&ch); //fcs
					 if (err==TIMEOUT) {
						*type=TIMEOUT;
						return NULL;
					 }
					 if (ch!=test) { // testez fcs-ul
						  free(tel);
						  return NULL;
					 }
					 err=recv_char(com,&ch); //ED
					 if (err==TIMEOUT) {
						*type=TIMEOUT;
						return NULL;
					 }
					 if (ch!=ED) { free(tel); return NULL;}
					 if (front) *type = TI_FARA_DATE;
					 else *type = TR_FARA_DATE;
					 return tel;

		case SD3: tel = (TEL *)malloc(sizeof(TEL));
					 if (tel==NULL) {
							*type = MALLOC_ERROR;
							return NULL;
					 }
					 *type = TELEGRAM_ERROR;
					 err=recv_char(com,&tel->da);
					 if (err==TIMEOUT) {
						*type=TIMEOUT;
						return NULL;
					 }
					 err=recv_char(com,&tel->sa);
					 if (err==TIMEOUT) {
						*type=TIMEOUT;
						return NULL;
					 }
					 err=recv_char(com,&ch); //fc
					 if (err==TIMEOUT) {
						*type=TIMEOUT;
						return NULL;
					 }
					 test = tel->da + tel->sa + ch;
					 tel->length = 8;
					 tel->data = (char *)malloc(sizeof(unsigned char)*8);
					 if (tel->data==NULL) {
							free(tel);
							*type = MALLOC_ERROR;
							return NULL;
					 }
					 for(i=0;i<8;i++){
						err=recv_char(com,&(tel->data[i]));
						if (err==TIMEOUT) {
							*type=TIMEOUT;
							return NULL;
						}
						test += tel->data[i];
					 }
					 err=recv_char(com,&ch); //fcs
					 if (err==TIMEOUT) {
						*type=TIMEOUT;
						return NULL;
					 }
					 if (ch!=test) { // testez fcs-ul
						  free(tel->data);
						  free(tel);
						  return NULL;
					 }
					 err=recv_char(com,&ch); //ED
					 if (err==TIMEOUT) {
						*type=TIMEOUT;
						return NULL;
					 }
					 if (ch!=ED) { free(tel->data); free(tel); return NULL;}
					 if (front) *type = TI_LF_CU_DATE;
					 else *type = TR_LF_CU_DATE;
					 return tel;

		case SD2: *type = TELEGRAM_ERROR;
								 unsigned char len;
					 err=recv_char(com,&len); // len1
					 if (err==TIMEOUT) {
						*type=TIMEOUT;
						return NULL;
					 }
					 err=recv_char(com,&ch); //len2
					 if (err==TIMEOUT) {
						*type=TIMEOUT;
						return NULL;
					 }
					 if (len!=ch) return NULL;
					 err=recv_char(com,&ch); //SD2
					 if (err==TIMEOUT) {
						*type=TIMEOUT;
						return NULL;
					 }
					 if (ch!=SD2) return NULL;
					 tel = (TEL *)malloc(sizeof(TEL));
					 if (tel==NULL) {
							*type = MALLOC_ERROR;
							return NULL;
					 }
					 err=recv_char(com,&tel->da);
					 if (err==TIMEOUT) {
						*type=TIMEOUT;
						return NULL;
					 }
					 err=recv_char(com,&tel->sa);
					 if (err==TIMEOUT) {
						*type=TIMEOUT;
						return NULL;
					 }
					 err=recv_char(com,&ch); //fc
					 if (err==TIMEOUT) {
						*type=TIMEOUT;
						return NULL;
					 }
					 test = tel->da + tel->sa + ch;
					 tel->length = len-3;
					 tel->data = (char *)malloc(sizeof(unsigned char)*tel->length);
					 if (tel->data==NULL) {
							*type = MALLOC_ERROR;
							free(tel);
							return NULL;
					 }
					 for(i=0;i<tel->length;i++){
						 err=recv_char(com,&(tel->data[i]));
						 if (err==TIMEOUT) {
							*type=TIMEOUT;
							return NULL;
						 }
						test += tel->data[i];
					 }
					 err=recv_char(com,&ch); //fcs
					 if (err==TIMEOUT) {
						*type=TIMEOUT;
						return NULL;
					 }
					 if (ch!=test) { // testez fcs-ul
						  free(tel->data);
						  free(tel);
						  return NULL;
					 }
					 err=recv_char(com,&ch); //ED
					 if (err==TIMEOUT) {
						*type=TIMEOUT;
						return NULL;
					 }
					 if (ch!=ED) { free(tel->data); free(tel); return NULL;}
					 if (front) *type = TI_LV_CU_DATE;
					 else *type = TR_LV_CU_DATE;
					 return tel;
		default : return NULL;
	}
}

int send(int com,TEL *tel,int type){
	int lung,i;
	unsigned char FC;
	int PORT;
	if ((type!=T_RASPUNS_SCURT) && (tel==NULL)) return TELEGRAM_ERROR;
	if (com==1) PORT=0x3f8;
	else if(com==2) PORT=0x2f8;
   else return UNKNOWN_COM;
	if (((type==TI_LV_CU_DATE) || (type==TR_LV_CU_DATE)) && (tel->length>246)) return TELEGRAM_ERROR;
	if (((type==TI_LV_CU_DATE) || (type==TR_LV_CU_DATE) ||
		  (type==TI_LF_CU_DATE) || (type==TR_LF_CU_DATE))
		  && (!tel->data)) return TELEGRAM_ERROR;
	switch (type) {
	  case TI_FARA_DATE : lung = 6; break;
	  case TR_FARA_DATE : lung = 6; break;
	  case TI_LF_CU_DATE : lung = 6 + 8; break;
	  case TR_LF_CU_DATE : lung = 6 + 8; break;
	  case TI_LV_CU_DATE : lung = 9 + tel->length; break;
	  case TR_LV_CU_DATE : lung = 9 + tel->length; break;
	  case TOKEN : lung = 3; break;
	  case T_RASPUNS_SCURT : lung = 1; break;
	  default :  return TELEGRAMA_NECUNOSCUTA;
	}
	unsigned char* pachet = (unsigned char *) malloc(sizeof(char)*lung);
	if (pachet==NULL) return MALLOC_ERROR;
	if ((type==TI_FARA_DATE) || (type==TR_FARA_DATE)) {
		pachet[0] = SD1;
		pachet[1] = tel->da;
		pachet[2] = tel->sa;
		pachet[3] = FC;
		pachet[4] = fcs(pachet);
		pachet[5] = ED;
	} else if ((type==TI_LF_CU_DATE) || (type==TR_LF_CU_DATE)) {
		pachet[0] = SD3;
		pachet[1] = tel->da;
		pachet[2] = tel->sa;
		pachet[3] = FC;
		for(int i=0;i<8;i++) pachet[4+i] = tel->data[i];
		pachet[12] = fcs(pachet);
		pachet[13] = ED;
	} else if ((type==TI_LV_CU_DATE) || (type==TR_LV_CU_DATE)) {
		pachet[0] = SD2;
		pachet[1] = (char) (tel->length+3);
		pachet[2] = (char) (tel->length+3);
		pachet[3] = SD2;
		pachet[4] = tel->da;
		pachet[5] = tel->sa;
		pachet[6] = FC;
		for(int i=0;i<tel->length;i++) pachet[7+i] = tel->data[i];
		pachet[7+tel->length] = fcs(pachet);
		pachet[7+tel->length+1] = ED;
	} else if (type==TOKEN){
		pachet[0]=SD4;
		pachet[1]=tel->da;
		pachet[2]=tel->sa;
	} else if (type==T_RASPUNS_SCURT) {
		pachet[0]=SC;
	}
//	init_port(PORT);

	if ((type==TI_LV_CU_DATE) || (type==TI_FARA_DATE) || (type==TOKEN) ||
		 (type==TI_LF_CU_DATE)) for(i=0;i<5;i++) send_char(PORT,255);
	for(i=0;i<lung;i++) send_char(PORT,pachet[i]);
	free(pachet);
	return type;
}


unsigned char *encode(unsigned char *text,int len,int* retlen){
	int bitslen = len * 11;
	*retlen = bitslen / 8;
	int poz,pz,i,tmp,par,j;
	if (bitslen % 8) *retlen = *retlen +1;
	unsigned char * ret = (unsigned char *) malloc(sizeof(unsigned char) * *retlen);
	pz = 7;
	poz = 0;
	ret[poz] = 0;
	for(i = 0;i<len;i++){
	  ret[poz] = ret[poz] | (0<<pz);  // bit START
	  pz --;
	  if (pz<0) {
		 poz++;
		 pz = 7;
		 ret[poz] = 0;
	  }

	  par = 0;

	  for (j = 7;j>=0;j--) {
		  tmp = (text[i]>>j)&1;
		  par = par ^ tmp;
		  tmp = tmp<<pz;
		  ret[poz] = ret[poz] | tmp;
		  pz --;
		  if (pz<0) {
			 poz++;
			 pz = 7;
			 ret[poz] = 0;
		  }
	  }

	  ret[poz] = ret[poz] | (par<<pz);  // bit paritate
	  pz --;
	  if (pz<0) {
		 poz++;
		 pz = 7;
		 ret[poz] = 0;
	  }


	  ret[poz] = ret[poz] | (1<<pz);  // bit STOP
	  pz --;
	  if (pz<0) {
		 poz++;
		 pz = 7;
		 ret[poz] = 0;
	  }
	}
	return ret;
}


unsigned char *decode(unsigned char *text,int len,int* retlen, int *error){
	*error = 0;
	int bitslen = len * 8;
	*retlen = bitslen / 11;
	int poz,pz,i,tmp,par,j;
	unsigned char * ret = (unsigned char *) malloc(sizeof(unsigned char) * *retlen);
	pz = 7;
	poz = 0;
	ret[poz] = 0;
	for(i = 0;i<(*retlen);i++){
	  tmp = (text[poz]>>pz) & 1;
	  if (tmp) *error = 1;     // test bit start
	  pz --;
	  if (pz<0) {
		 poz++;
		 pz = 7;
	  }
	  par = 0;
	  ret[i] = 0;
	  for (j = 7;j>=0;j--) {
		  tmp = (text[poz]>>pz)&1;
		  par = par ^ tmp;
		  tmp = tmp<<j;
		  ret[i] = ret[i] | tmp;
		  pz --;
		  if (pz<0) {
			 poz++;
			 pz = 7;
		  }
	  }

	  tmp = (text[poz]>>pz) & 1;
	  if (tmp!=par) *error = 1;   // test bit paritate
	  pz --;
	  if (pz<0) {
		 poz++;
		 pz = 7;
	  }

	  tmp = (text[poz]>>pz) & 1;
	  if (!tmp) *error = 1; // test bit stop

	  pz --;
	  if (pz<0) {
		 poz++;
		 pz = 7;
	  }
	}
	tmp = text[poz]>>pz;
	if (tmp) *error = 1; // nu a fost umplut cu 0 la sf
	return ret;
}