comm103.c

串口103规约

	if(len>0){
		if(dp->leveloneque.buf[dp->leveloneque.quesave]!=NULL)free(dp->leveloneque.buf[dp->leveloneque.quesave]);
		dp->leveloneque.buf[dp->leveloneque.quesave]=malloc(COMM103_LEVELONE_BUFLEN);
		dp->leveloneque.buflenth[dp->leveloneque.quesave]=len;
		COMM103Memcopy(dp->leveloneque.buf[dp->leveloneque.quesave],buf,len,0);
		dp->leveloneque.quesave=(dp->leveloneque.quesave+1)%COMM103_LEVELONE_NUM;
	}
}
static int COMM103GetmsgFromLeveloneQue(struct  COMM103_DEVICE_DATABASE * dp,u_char *buf){
	int len;
	while(dp->leveloneque.queload!=dp->leveloneque.quesave)
	{
		if(dp->leveloneque.buf[dp->leveloneque.queload]!=NULL)
		{
			len=dp->leveloneque.buflenth[dp->leveloneque.queload];
			COMM103Memcopy(&buf[6],dp->leveloneque.buf[dp->leveloneque.queload],len,0);
			free(dp->leveloneque.buf[dp->leveloneque.quesave]);
			dp->leveloneque.buf[dp->leveloneque.quesave]=NULL;
			dp->leveloneque.queload=(dp->leveloneque.queload+1)%COMM103_LEVELONE_NUM;
			return len;
		}
		dp->leveloneque.queload=(dp->leveloneque.queload+1)%COMM103_LEVELONE_NUM;
	}
	return 0;
}
static void COMM103ClearLevelOneQue(struct COMM103_DEVICE_DATABASE *dp){
	int i;
	for(i=0;i<COMM103_LEVELONE_NUM;i++){
		if(dp->leveloneque.buf[i]!=NULL)free(dp->leveloneque.buf[i]);
		dp->leveloneque.buf[i]=NULL;
		dp->leveloneque.buflenth[i]=0;
	}
	dp->leveloneque.queload=0;
	dp->leveloneque.quesave=0;
}
static u_char COMM103GetLinkControl(struct COMM103_DEVICE_DATABASE *dp,u_char fun){
	if(dp->leveloneque.queload!=dp->leveloneque.quesave)return 0x20+fun;
	else return fun;
}

static struct	 COMM103_DEVICE_DATABASE * COMM103FindDevice(struct  COMM103_DEVICE_MAP * ndp,u_short addr){
	u_short i;
	for(i=0;i<ndp->devicenum;i++){
		if(ndp->commdevice_database[i]==NULL)continue;
		if(ndp->commdevice_database[i]->dev_addr==addr)return ndp->commdevice_database[i];
	}
	return NULL;
}

static struct  DEV_ENTRY_DES_DATA * COMM103FindFUNINF(struct  COMM103_DEVICE_DATABASE * dp,u_char grp,u_char entry){
	u_char i,fun,inf,j;
	for(j=0;j<dp->groupnum;j++){
		if(dp->groupindex[j]==NULL)continue;
		if(dp->groupindex[j]->ginhight!=grp)continue;
		for(i=0;i<dp->groupindex[j]->groupgin->entry_num;i++){
			if(dp->groupindex[j]->groupgin->entry[i].entry==entry){
				return &dp->groupindex[j]->groupgin->entry[i];
			}
		}
	}
	return NULL;
}

static void COMM103DealUpSendMsg(struct  COMM103_DEVICE_DATABASE * dp,struct	can_asdu *asdup,int len){
	u_char ginptr;
	u_char *upbuf;
	int lenth;
	struct	can_asdu10 *asdu10p;
	asdu10p=(struct	can_asdu10 *)asdup;
	if(dp->qhstate==COMM103_CALLINGQH_COMMAND){
		if((asdup->asdu_type==10)&&(asdu10p->GIN[0]==dp->grpqh)){
			len=COMM103_answer_one_entry_list(dp,asdup,len);
			dp->qhstate=COMM103_NO_CALLQH_COMMAND;
		}
	}
	asdup->address=dp->map_addr;
	if((asdup->asdu_type==11)||((asdup->asdu_type>=23)&&(asdup->asdu_type<=31))){
		upbuf=&asdup->asdu_type;
		COMM103IsertinLeveloneQue(dp,upbuf,len-sizeof(struct can_asdu_head));
		return;
	}
	if(asdup->asdu_type!=10)return;
	switch(asdup->cot){
	case 1:
	case 2:
	case 9:
		COMM103ChangAsduType(dp,asdu10p,len);
		break;
	case 40:
	case 41:
	case 42:
	case 43:
	case 44:
		lenth=COMM103GenReadHeadCheck(dp,asdu10p,len);
		upbuf=&asdup->asdu_type;
		COMM103IsertinLeveloneQue(dp,upbuf,lenth-sizeof(struct can_asdu_head));
		break;
	case 10:
		COMM103FormEndCall(dp,asdu10p->RII);
		break;
	}
}
static void COMM103DealDownSendMsg(struct  COMM103_DEVICE_MAP * ndp,u_char *buf,int len){
	int i;
	u_char *pp;
	struct  COMM103_DEVICE_DATABASE *dp;

	if(len<0)return ;
	COMM103Memcopy(&ndp->recvbuf[ndp->recvlenth],buf,len,0);
	ndp->recvlenth+=len;
#ifdef  _COMM103_SEND_DEBUG_
		printf("\nlen=%d buflen=%d \n",len,ndp->recvlenth);
#endif
	i=COMM103COMMMsgVerfy(ndp);
#ifdef  _COMM103_SEND_DEBUG_
		printf("Verfy=%d ",i);
#endif
	if(i==0)return;
	else if(i<0){ndp->recvlenth=0;return;}
#ifdef  _COMM103_SEND_DEBUG_
		printf("answer \n");
#endif
	dp=COMM103MsgVerfyFcb(ndp,i);
	ndp->recvlenth=0;
}

static void COMM103FormEndCall(struct  COMM103_DEVICE_DATABASE * dp,u_char scn){
	u_char asdu8[10];
	asdu8[0]=8;
	asdu8[1]=0x81;
	asdu8[2]=10;
	asdu8[3]=dp->map_addr;
	asdu8[4]=0xff;
	asdu8[5]=0x00;
	asdu8[6]=scn;
	COMM103IsertinLeveloneQue(dp,asdu8,7);
}

static int COMM103GenReadHeadCheck(struct  COMM103_DEVICE_DATABASE * dp,struct	can_asdu10 *asdu10p,int len){
	u_short gin;
	int i,ginnum,j,lenth;
	u_char *ptr,*pts;
	u_char wid,num,upginnum;

	if(asdu10p->inf!=240)return len;
	ginnum=dp->groupnum;
	ptr=&asdu10p->GIN[0];
	lenth=8;
	upginnum=0;
	for(i=0;i<ginnum;i++){
		if(dp->groupindex[i]->converttype==COMM103_GROUP_TYPE_GIN){
			*ptr++=dp->groupindex[i]->ginhight;/*gin kod type =4byte*/
			*ptr++=0;/*gin */
			*ptr++=10;/*kod*/
			*ptr++=1;/*type*/
			wid=strlen(dp->groupindex[i]->des);
			*ptr++=wid;/*wid*/
			*ptr++=1;/*num*/
			lenth+=(wid+6);
			for(j=0;j<wid;j++)*ptr++=dp->groupindex[i]->des[j];
			upginnum++;			
		}
	}
	asdu10p->NGD=upginnum;
	if(upginnum==0)return 0;
	else return (lenth+sizeof(struct can_asdu_head));
}

static void COMM103ChangAsduType(struct  COMM103_DEVICE_DATABASE * dp,struct	can_asdu10 *asdu10p,int len){
	u_char grp,wid,num,ginl;
	int i,ginnum;
	u_char *ptr;
	struct  DEV_ENTRY_DES_DATA *entylp;

	ginnum=asdu10p->NGD&0x3f;
	ptr=&asdu10p->GIN[0];
#ifdef  _COMM103_RECV_DEBUG_
	printf("chang:\n");
	COMM103BufShow((u_char *)asdu10p,len);
#endif
	switch(COMM103FindGintype(dp,*ptr)){
	case COMM103_GROUP_TYPE_GIN:
		COMM103IsertinLeveloneQue(dp,(u_char *)&asdu10p->asdu_type,len-sizeof(struct can_asdu_head));
		break;
	case COMM103_GROUP_TYPE_FUNINF:
		for(i=0;i<ginnum;i++){
			grp=*ptr++;
			ginl=*ptr++;
			entylp=COMM103FindFUNINF(dp,grp,ginl);
			ptr+=2;
			wid=*ptr++;
			num=*ptr++;
#ifdef  _COMM103_RECV_DEBUG_
	printf("gin:%02x%02x wid%d num%d ",grp,ginl,wid,num);
#endif
			if(entylp!=NULL){
				switch(entylp->actual_value.GDD0){
				case 18:
				case 203:
					COMM103FormAsdu1(dp,ptr,entylp->fun,entylp->inf,asdu10p->cot,asdu10p->RII);
					break;
				case 19:
				case 204:
					COMM103FormAsdu2(dp,ptr,entylp->fun,entylp->inf,asdu10p->cot,asdu10p->RII);
					break;
				case 20:
				case 205:
					COMM103FormAsdu4(dp,ptr,entylp->fun,entylp->inf,asdu10p->cot,asdu10p->RII);
					break;
				default:
#ifdef  _COMM103_RECV_DEBUG_
			myprintf("err%d ",entylp->actual_value.GDD0);
#endif					break;
				}
			}
#ifdef  _COMM103_RECV_DEBUG_
			else myprintf("can't find ");
#endif
			ptr+=(wid*num);
		}
		break;
	default:
		break;
	}

}

static u_char COMM103FindGintype(struct  COMM103_DEVICE_DATABASE * dp,u_char gin){
	u_char i;
	for(i=0;i<dp->groupnum;i++){
		if(dp->groupindex[i]->ginhight==gin)return dp->groupindex[i]->converttype;
	}
}

static void COMM103FormAsdu1(struct  COMM103_DEVICE_DATABASE * dp,u_char *buf,u_char fun,u_char inf,
					  u_char cot,u_char rii){
	u_char ptr,i,upbuf[20];
	ptr=0;
	if(inf==0)return;
	upbuf[ptr++]=1;
	upbuf[ptr++]=0x81;
	upbuf[ptr++]=cot;
	upbuf[ptr++]=dp->map_addr;
	upbuf[ptr++]=fun;
	upbuf[ptr++]=inf;
	i=buf[0]&0x03;
	if((i==0)||(i==3))return;
	for(i=0;i<5;i++){
		upbuf[ptr++]=buf[i];
	}
	upbuf[ptr++]=rii;
	COMM103IsertinLeveloneQue(dp,upbuf,ptr);
	return;
}
static void COMM103FormAsdu2(struct  COMM103_DEVICE_DATABASE * dp,u_char *buf,u_char fun,u_char inf,
					  u_char cot,u_char rii){
	u_char ptr,i,upbuf[20];
	ptr=0;
	if(inf==0)return;
	upbuf[ptr++]=2;
	upbuf[ptr++]=0x81;
	upbuf[ptr++]=cot;
	upbuf[ptr++]=dp->map_addr;
	upbuf[ptr++]=fun;
	upbuf[ptr++]=inf;
	i=buf[0]&0x03;
	if((i==0)||(i==3))return;
	for(i=0;i<9;i++){
		upbuf[ptr++]=buf[i];
	}
	upbuf[ptr++]=rii;
	COMM103IsertinLeveloneQue(dp,upbuf,ptr);
	return;
}

static void COMM103FormAsdu4(struct  COMM103_DEVICE_DATABASE * dp,u_char *buf,u_char fun,u_char inf,
					  u_char cot,u_char rii){
	u_char ptr,i,upbuf[40];
	ptr=0;
	if(inf==0)return;
	upbuf[ptr++]=4;
	upbuf[ptr++]=0x81;
	upbuf[ptr++]=cot;
	upbuf[ptr++]=dp->map_addr;
	upbuf[ptr++]=fun;
	upbuf[ptr++]=inf;
	for(i=0;i<12;i++){
		upbuf[ptr++]=buf[i];
	}
	COMM103IsertinLeveloneQue(dp,upbuf,ptr);
	return;
}



static int COMM103COMMMsgVerfy(struct COMM103_DEVICE_MAP *dp){
	u_char k,ch,frame_l,sum=0;
	u_int  len,step,ptr,l;
	
#ifdef  _COMM103_SEND_DEBUG_
		for(len=0;len<dp->recvlenth;len++)printf("%02X ",dp->recvbuf[len]);
#endif
	ptr=0;
	while(dp->recvlenth>ptr){
		if((dp->recvbuf[ptr]==0x10)||(dp->recvbuf[ptr]==0x68))break;
		else ptr++;
	}
	if(dp->recvlenth<=ptr){dp->recvlenth=0;return 0;}
	else if(ptr!=0){
		COMM103Memcopy(dp->recvbuf,&dp->recvbuf[ptr],dp->recvlenth-ptr,0);
		dp->recvlenth-=ptr;
	}

	ptr=0;
    if(dp->recvlenth<5)return 0;	
	len=dp->recvlenth;
	
	ch=dp->recvbuf[ptr++];
	frame_l=1;
     if(ch==0x10)
	{		
		step=1;
		for(k=0;k<4;k++)
		{			
			ch=dp->recvbuf[ptr++];
			frame_l++;
			switch(step)
			{ 
			case 1:	
				step++;
				sum+=ch;
				break;
			case 2:
				step++;
				sum+=ch;
				break;
			case 3:	
				step++;
				if(ch!=sum) return -10;	
				break;
			case 4:
				step++;
				if((ch==0x16)&&(frame_l==len))return 1;
				else return -11;
				break;
		    }
		}
     }
     else if(ch==0x68){		
		step=1;
		frame_l=1;
		while(1)
		{
			ch=dp->recvbuf[ptr++];
			frame_l++;
			switch(step)
			{ 
			case 1:				
				step++;
				break;
			case 2:
				if(ch==dp->recvbuf[1])
				{	
					step++;
					if(dp->recvlenth<(ch+6))return 0;
					else dp->recvlenth=ch+6;
					l=ch-2;
				}
				else return -12;
				break;
			case 3:
				if(ch==0x68)step++;
				else return -13;
				break;
			case 4:
				step++;