station.c

LINUX的简单应用

	 
	station.radiodatanum=0;
	station.signalnum=0;  
	station.tracknum=0;   
	station.switchnum=0;  
	station.entrancenum=0;

	station.jbjlfile=NULL;
	station.fhjlfile=NULL;
	station.limitfile=NULL;
	station.linkfile=NULL;
	station.devicefile=NULL;
	station.specfile=NULL;

	station.entrances=NULL;
	station.tracks=NULL;
	station.switchs=NULL;
	station.signals=NULL;
	station.showtra=NULL;

	pbrthead=NULL;
	pbrts=NULL;
	pmrthead=NULL;
	pmrts=NULL;
	plnkhead=NULL;
	plnks=NULL;
	jobtr.trannum=0;
	jobtr.mems=NULL;

	station.jbjlfile=malloc(15);
	station.fhjlfile=malloc(15);
	station.limitfile=malloc(15);
	station.linkfile=malloc(15);
	station.devicefile=malloc(15);
	station.specfile=malloc(15);
	station.jobfile=malloc(15);

	station.conversion=DEFAULT_CONVERSION;
	station.pipe=DEFAULT_PIPE;

	if((fl=fopen(FILETRAIN,"r"))==NULL) return;

	lvalue=0;
	fscanf(fl,"train=%ld\n",&lvalue);
	train.nohi=lvalue>>16;
	train.nomid=lvalue>>8;
	train.nolo=lvalue&0xff;
	printf("train no=%ld\n",lvalue);

	lvalue=0;
	fscanf(fl,"direction=%ld\n",&lvalue);
	train.drctsort=lvalue;
	printf("drct sort=%d\n",train.drctsort);
	
	lvalue=0;
	fscanf(fl,"conversion=%ld\n",&lvalue);
	station.conversion=lvalue;
	printf("conversion=%d\n",station.conversion);
	if(station.conversion<10 || station.conversion>30)
		station.conversion=DEFAULT_CONVERSION;

	lvalue=0;
	fscanf(fl,"pipe=%ld\n",&lvalue);
	station.pipe=lvalue;
	printf("pipe=%d\n",station.pipe);

	lvalue=0;
	fscanf(fl,"station=%ld\n",&lvalue);
	printf("station=%ld\n",lvalue);
	fclose(fl);
	ResetStation(lvalue);

	//debug down
	//CreateRoute(&route1,158);
	//printf("id=%d,jlnum=%d,start=%d,end=%d\n",route1.id,route1.fhjl.jlnum,route1.start,route1.end);
	//for(i=0;i<route1.fhjl.jlnum;i++)
	//	printf("base%d=%d,%d,%d\n",route1.fhjl.jl[i],route1.base[i].tracknum,route1.base[i].start,route1.base[i].end);

	/*printf("Signal link loc debug:\n");
	for(i=0;i<(station.dhdcnum+station.dhlcnum+station.dhxnnum+5);i++)
	{
		lvalue=GetSigLnkLoc(2*i+1);
		printf("Signal link %d loc=%ld\n",2*i+1,lvalue);
		if(plnks[lvalue].devid!=(2*i+1))
			printf("Signal link Error!\n");
	}
	for(i=0;i<(station.shdcnum+station.shlcnum+station.shxnnum+5);i++)
	{
		lvalue=GetSigLnkLoc(2*i+2);
		printf("Signal link %d loc=%ld\n",2*i+2,lvalue);
		if(plnks[lvalue].devid!=(2*i+2))
			printf("Signal link Error!\n");
	}*/
	//printf("Sig %d Prop=%x,Sig %d Prop=%x\n",2,GetSigProp(2),46,GetSigProp(46));
	//debug up
}

int TranslateJobTrk(char *str)
{
	int i;
	for(i=0;i<jobtr.trannum;i++)
	{
		if(!strcmp(jobtr.mems[i].tstr,str))
			return(jobtr.mems[i].track);
	}
	return(0);
}

int GetTrkLoc(int tid)
{
	int i;
	if(tid&1)
	{
		if(tid>(station.dhgdnum*2-1))
			i=-1;
		else
			i=(tid-1);
	}
	else
	{
		if(tid>(station.shgdnum*2))
			i=-1;
		else
		{
			i=(station.dhgdnum+3)/4;
			i=i*8;
			i+=tid-2;
		}
	}
	return(i);
}

int GetTrkEngage(int tid)
{
	int i;
	i=GetTrkLoc(tid);
	if(i<0)
		return(1);
	return(GetBit(station.tracks[i/8],i%8,0));
}

int GetTrkOpen(int tid)
{
	int i;
	i=GetTrkLoc(tid);
	if(i<0)
		return(0);
	return(GetBit(station.tracks[i/8],7-(i%8),0));
}

int GetSigLoc(int sid)
{
	int i;
	if(sid<=0)
		return(-1);
	if(sid&1)
	{
		if(sid<=(station.dhdcnum*2-1))
			i=sid-1;
		else if(sid<=((station.dhdcnum+station.dhlcnum)*2-1))
		{
			i=(station.dhdcnum+3)/4+(station.shdcnum+3)/4;
			i=i*8;
			i+=2*(sid-(2*station.dhdcnum+1));
		}
		else
			i=-1;
	}
	else
	{
		if(sid<=(station.shdcnum*2))
		{
			i=(station.dhdcnum+3)/4;
			i=i*8;
			i+=sid-2;
		}
		else if(sid<=((station.shdcnum+station.shlcnum)*2))
		{
			i=(station.dhdcnum+3)/4+(station.shdcnum+3)/4+(station.dhlcnum+1)/2;
			i=i*8;
			i+=2*(sid-(2*station.shdcnum+2));
		}
		else
			i=-1;
	}
	
	return(i);
}

int GetSigProp(int id)
{
	int i;
	unsigned char ret;
	ret=0;
	if(id<=0)
		return(ret);
	i=GetSigLnkLoc(id);
	if(i<0)
		return(ret);
	if(plnks[i].direction!=LINK_DRCT_UP)
		ret|=PROPERTY_XX;
	if(plnks[i].type==5)
	{
		if(plnks[i].character==1 || plnks[i].character==2 || plnks[i].character==3)
			ret|=PROPERTY_JT;
		else if(plnks[i].character==4)
			ret|=PROPERTY_FJ;
		else if(plnks[i].character==5)
			ret|=PROPERTY_ZJ;
		ret|=PROPERTY_XN;
	}
	else if(plnks[i].type==1)
	{
		if(plnks[i].character==13)
			ret|=PROPERTY_FJ;
		else if(plnks[i].character==11)
			ret|=PROPERTY_ZJ;
	}
	return(ret);
}

int IsBackSignal(int sgid)
{
	int i;
	i=GetSigLnkLoc(sgid);
	if(i<0)
		return(0);
	if(plnks[i].type==5 && plnks[i].character==8)
		return(1);
	return(0);
}

int IsGudaoXhj(int id)
{
	int i;
	int node;
	if(id<=0)
		return(0);
	i=GetSigLnkLoc(id);
	if(i<0)
		return(0);
	if(plnks[i].direction!=1)
	{
		node=plnks[i].upd-1;
		for(i=0;i<2;i++)
		{
			if(node<0)
				return(0);
			if(plnks[node].type==1 || plnks[node].type==4)
			{
				return(0);
			}
			else if(plnks[node].type==3)
				return(1);
			node=plnks[node].upd-1;
		}
	}
	else
	{
		node=plnks[i].downd-1;
		for(i=0;i<2;i++)
		{
			if(node<0)
				return(0);
			if(plnks[node].type==1 || plnks[node].type==4)
			{
				return(0);
			}
			else if(plnks[node].type==3)
				return(1);
			node=plnks[node].downd-1;
		}
	}
	return(0);
}

int GetGdTrack(int gid)
{
	if(gid<=0)
		return(0);
	return(plnks[plnkhead->gdstart+gid-1].devid);
}

int IsTrkGudao(int id)
{
	int i;
	if(id<=0)
		return(0);
	for(i=0;i<plnkhead->gdnum;i++)
	{
		if(plnks[plnkhead->gdstart+i].devid==id)
			return(i+1);
	}
	return(0);
}

int IsRtGudao(ROUTE *rt)
{
	int i;
	if(0==rt->id || rt->fhjl.jlnum<=0)
		return(0);
	i=IsTrkGudao(rt->base[rt->fhjl.jlnum-1].tracks[rt->base[rt->fhjl.jlnum-1].tracknum-1]);
	return(i);
}

int GetGdLength(int trkid)
{
	int i;
	if(trkid<=0)
		return(0);
	for(i=0;i<plnkhead->gdnum;i++)
	{
		if(plnks[plnkhead->gdstart+i].devid==trkid)
			return(plnks[plnkhead->gdstart+i].length);
	}
	return(0);
}

unsigned char GetLightDrct(int lt)
{
	//unsigned char ret;
	int i;
	if(lt<=0)
		return(0xff);
	i=GetSigProp(lt);
	if(i&PROPERTY_XX)
		return(DRCTXX);
	else
		return(DRCTSX);
}

unsigned char GetBsRtProperty(ROUTE *rt,int bid)
{
	int i;
	unsigned char ret;
	ret=0;
	if(0==rt->fhjl.jlnum)
		return(ret);
	i=rt->base[bid].end;
	ret=GetSigProp(i)&0x70;
	return(ret);
}

/*unsigned char GetRtProperty(ROUTE *rt)
{
	int i;
	unsigned char ret;
	ret=0;
	if(0==rt->fhjl.jlnum)
		return(ret);
	i=rt->base[rt->fhjl.jlnum-1].tracks[rt->base[rt->fhjl.jlnum-1].tracknum-1];
	if(IsTrkGudao(i))//存车线
	{
		if(GetTrkEngage(i))
			ret|=0x80;
		//printf("i=%d,ret=%x ",i,ret);
	}
	if(16==i)	//尽头线
		ret|=0x40;
	switch(i)		//集中区
	{
	case 7:
	case 24:
		if(DRCTSX==train.trend)
			ret|=0x10;
		break;
	case 126:
	case 130:
	case 143:
	case 144:
		if(DRCTXX==train.trend)
			ret|=0x10;
		break;
	default:
		break;
	}

	switch(i)		//站界
	{
	case 7:
		if(DRCTSX==train.trend)
			ret|=0x20;
		break;
	case 126:
	case 130:
		if(DRCTXX==train.trend)
			ret|=0x20;
		break;
	default:
		break;
	}

	return(ret);
}*/

unsigned char GetRtDrct(ROUTE *rt)
{
	return(GetLightDrct(rt->start));
}

int IsLcOpen(int cl)
{
	if(cl>1 && cl<7)//if(cl>2 && cl<7)//debug
		return(1);
	else
		return(0);
}

void SetTrkColor(int tkid,unsigned char color)
{
	int i,j,offset;
	unsigned char data;
	
	if(tkid<=0)
		return;
	if(tkid&1)
	{
		i=(tkid-1)>>1;
		offset=i>>1;
	}
	else
	{
		i=(tkid>>1)-1;
		offset=(station.dhgdnum+1)>>1;
		offset+=i>>1;
	}
	
	j=(i&1)<<2;
	data=station.showtra[offset]&(0x0f<<j);
	data>>=j;
	if(data!=TKRED)
	{
		station.showtra[offset]&=0xf0>>j;
		station.showtra[offset]|=color<<j;
	}
}

#define Get2Map(b) ((station.signals[b>>3]>>(b&0x07))&0x03)
#define Get4Map(b) ((station.signals[b>>3]>>(b&0x07))&0x0f)
#define GetMapLock(b) ((station.signals[b>>3]>>(b&0x07))&0x02)
#define GetMapEngage(b) ((station.signals[b>>3]>>(b&0x07))&0x01)

int GetSwiNext(int id,int direction)
{
	int i;
	unsigned char c;
	i=plnks[id].swmap-8;
	if(i<0)
		return(-1);
	c=Get2Map(i);
	if(direction==LINK_DRCT_UP)
	{
		if(c==1)//f
			return(plnks[id].upf-1);
		else if(c==2)//d
			return(plnks[id].upd-1);
		else
			return(-1);
	}
	else if(direction==LINK_DRCT_DOWN)
	{
		if(c==1)//f
			return(plnks[id].downf-1);
		else if(c==2)//d
			return(plnks[id].downd-1);
		else
			return(-1);
	}
	else
		return(-1);
}

int GetNextNode(int id,int direction)
{
	int ret;
	unsigned char c;
	if(direction==LINK_DRCT_UP)
	{
		if(plnks[id].type==4)
			ret=GetSwiNext(id,direction);
		else if(plnks[id].type>0 && plnks[id].type<6)
			ret=plnks[id].upd-1;
		else
			return(-1);
	}
	else if(direction==LINK_DRCT_DOWN)
	{
		if(plnks[id].type==4)
			ret=GetSwiNext(id,direction);
		else if(plnks[id].type>0 && plnks[id].type<6)
			ret=plnks[id].downd-1;
		else
			return(-1);
	}
	else
		return(-1);
	if(ret<0)
		return(-1);
	if(plnks[ret].type==4)
	{
		if(id==GetSwiNext(ret,(~direction)&0x03))
			return(ret);
		else
			return(-1);
	}
	else
		return(ret);
}

int GetNextTrk(int id,int direction)
{
	int node;
	int i;
	node=GetNextNode(id,direction);
	for(i=0;i<3;i++)
	{
		if(node<0)
			return(-1);
		if(plnks[node].type==2 || plnks[node].type==3 || plnks[node].type==4)
			return(node);
		if(plnks[node].type==1)
		{
			if((plnks[node].character==2 || plnks[node].character==3) && plnks[node].direction==direction)
				return(-1);
		}
		node=GetNextNode(node,direction);
	}
	return(-1);
}

void ClearLcColor(void)
{
	unsigned char c;
	int i;
	int stoff,shoff;
	int byte,bit;
	for(i=0;i<station.dhgdnum;i++)
	{
		byte=i>>2;
		bit=(i&0x03)<<1;
		c=(station.tracks[byte]>>bit)&0x03;
		if(!c)
		{
			byte=i>>1;
			bit=(i&0x01)<<2;
			if(((station.showtra[byte]>>bit)&0x0f)==TKGREEN)
			{
				station.showtra[byte]&=0xf0>>bit;
			}
		}
	}
	stoff=(station.dhgdnum+3)/4;
	shoff=(station.dhgdnum+1)/2;
	for(i=0;i<station.shgdnum;i++)
	{
		byte=stoff+(i>>2);
		bit=(i&0x03)<<1;
		c=(station.tracks[byte]>>bit)&0x03;
		if(!c)
		{
			byte=shoff+(i>>1);
			bit=(i&0x01)<<2;
			if(((station.showtra[byte]>>bit)&0x0f)==TKGREEN)
			{
				station.showtra[byte]&=0xf0>>bit;
			}
		}
	}
	/*for(i=0;i<(plnkhead->wcnum+plnkhead->gdnum+plnkhead->swnum);i++)
	{
		j=plnkhead->wcstart+i;
		if(plnks[j].map>7)
		{
			k=plnks[j].map-8;
			if(!Get2Map(k))
				ClearGreen(plnks[j].devid);
		}
	}*/
}

void CheckLcSignal(int id)
{
	int j,k;
	int track;
	if((plnks[id].character==2 || plnks[id].character==3) && plnks[id].map>7)
	{
		j=plnks[id].map-8;
		if(IsLcOpen(Get4Map(j)))
		{
			track=GetNextTrk(id,plnks[id].direction);
			while(track>=0)
			{
				k=plnks[track].map;
				if(k<8)
					break;
				k-=8;
				if(!GetMapLock(k))
					break;
				SetTrkColor(plnks[track].devid,TKGREEN);
				track=GetNextTrk(track,plnks[id].direction);
			}
		}
	}
}

void SetLcColor(void)
{
	int i;
	int lcstart,lcend;
	ClearLcColor();
	lcstart=station.dhdcnum;
	lcend=lcstart+station.dhlcnum;
	for(i=lcstart;i<lcend;i++)
	{
		CheckLcSignal(i);
	}
	lcstart=station.dhdcnum+station.dhlcnum+station.shdcnum;
	lcend=lcstart+station.shlcnum;
	for(i=lcstart;i<lcend;i++)
	{
		CheckLcSignal(i);
	}
}

void SearchWhite(int trkid)
{
	int start,end;
	int node;
	int i,j,k;
	int direction;
	unsigned char c;
	if(trkid<=0)
		return;
	if(train.g93trend==0x0a)
		direction=1;
	else if(train.g93trend==0x8a)
		direction=2;
	else
		return;
	i=GetTrkLnkLoc(trkid);
	if(i<0)
		return;
	
	/*if(IsSignalOpen(sgid))
	{
		node=GetNextNode(i,direction);
		while(node>=0)
		{
			if(plnks[node].type==2 || plnks[node].type==3 || plnks[node].type==4)
			{
				k=plnks[node].map;
				if(k<8)
					break;
				k-=8;
				c=Get2Map(k);
				if(c!=2)
					break;
				SetTrkColor(plnks[node].devid,TKWHITE);
			}
			else if(plnks[node].type==1)
			{
				if(plnks[node].direction==direction && !IsSignalOpen(plnks[node].devid))
					break;
			}
			node=GetNextNode(node,direction);
		}
	}*/
	node=GetNextNode(i,direction);
	while(node>=0)
	{
		if(plnks[node].type==2 || plnks[node].type==3 || plnks[node].type==4)
		{
			k=plnks[node].map;
			if(k<8)
				break;
			k-=8;
			if(!GetMapEngage(k))
				break;
		}
		else if(plnks[node].type==1 || plnks[node].type==5)
		{
			if(plnks[node].devid==train.forlight)
				break;
		}
		node=GetNextNode(node,direction);