iec61850.cpp

基于linux下的故障录波前置程序

																								      
																									
																									  
																									    
																									      
																										}//for(j=0;j<6;j++)
																										
																										  
																										    //di_state_change	();
																										    
																										      
																											for(j=0;j<9;j++)
																											{
																											startflagall |=startflag[j];
																											}
startflagall |= startflag_dc;

if(startflagall !=0 )
{

	  SendRecordWaveStart();
	  SendRecordWaveStart();
          RecordCfgFile();
          RecordWave(point,1000,HIGHSPEED);
	  sleep(4);
	  if((point+3800*4)>YCID)
	  	point  = point +3800*4 -YCID;
	else
		point += 3800*4;
          RecordWave(point,3800, LOWSPEED);
	//  break;
                                                     	
	startflagall = 0; 
	SendCreateFile();
	SendRecordWaveEnd();
	SendRecordWaveEnd();
	}
	







	}
}

void SendCreateFile()
{
	UBYTE buf[10];
	buf[0] = 0x07;
	buf[1] = 0x81;
	buf[2] = 0x05;
	buf[3] = m_second;
	buf[4] = m_minute;
	buf[5] = m_hour;
	buf[6] = m_day;
	buf[7] = m_month;
	buf[8] = m_year;
	buf[9] = 0x16;
	SendSlaveCommand(buf,10);
	
}

//************************************************************************************************************************
//*******计算负序
//*******参数：phase_A、phase_B、phase_C：线路的三相傅立叶计算的虚部、实部
//*******返回：线路的负序量
//************************************************************************************************************************

float cacl_position(float *phase_A ,float *phase_B ,float *phase_C)
{
	float a[2],a2[2];
	float PHASE_A[2];
	float PHASE_B[2];
	float PHASE_C[2];
	a[0] = -0.5;
	a[1] = 0.866;
	a2[0] = 0-0.5;
	a2[1] =0- 0.866;
	PHASE_A[0] = phase_A[0];
	PHASE_A[1] = phase_A[1];
	PHASE_B [0] = vector_multiply (phase_B , a , 0);
	PHASE_B [1] = vector_multiply (phase_B , a , 1);
	PHASE_C [0] = vector_multiply (phase_C , a2 , 0);
	PHASE_C [1] = vector_multiply (phase_C , a2 , 1);
	return (vector_add ( PHASE_A ,PHASE_B ,PHASE_C) );
}
//************************************************************************************************************************
//*******计算负序
//*******参数：phase_A、phase_B、phase_C：线路的三相傅立叶计算的虚部、实部
//*******返回：线路的负序量
//************************************************************************************************************************

float cacl_negative(float *phase_A ,float *phase_B ,float *phase_C)
{
	float a[2],a2[2];
	float PHASE_A[2];
	float PHASE_B[2];
	float PHASE_C[2];
	a[0] = 0-0.5;
	a[1] = 0.866;
	a2[0] = 0-0.5;
	a2[1] =0-0.866;
	PHASE_A[0] = phase_A[0];
	PHASE_A[1] = phase_A[1];
	PHASE_B [0] = vector_multiply (phase_B , a2 , 0);
	PHASE_B [1] = vector_multiply (phase_B , a2 , 1);
	PHASE_C [0] = vector_multiply (phase_C , a , 0);
	PHASE_C [1] = vector_multiply (phase_C , a , 1);
	return (vector_add ( PHASE_A ,PHASE_B ,PHASE_C) );
}

//************************************************************************************************************************
//*******
//*******序量计算函数
//*******
//************************************************************************************************************************

float  vector_add(float *vector1,float *vector2,float *vector3)
{
	float qqr,qqi ;
	qqr = vector1[0] + vector2[0] +vector3[0] ;
	qqi = vector1[1] + vector2[1] +vector3[1] ;
	return ( sqrt( qqr*qqr + qqi*qqi));
} 

float  vector_multiply(float *vector1,float *vector2,int real_imag)
{
	if(real_imag)return((float)vector1[1]*vector2[0]+(float)vector1[0]*vector2[1]);
	else return((float)vector1[0]*vector2[0]-(float)vector1[1]*vector2[1]);
}


void RecordCfgFile()
{

	struct stat m_stat;
	FILE*  handle;
	char tmp[20];
	char linedata[40];
	int serial_no = 0;
	char pserial_no[6];
	char *tmpbuf;
    char tmp_buf[20];
	char dirpath[100];
	int frenum;
	int i;
	TimeStruct m_time;
	char cmdbuf[100];
	
	char buf[255];

        memset(cfg_file,0,100);
        memset(dat_file,0,100);
	memset(dirpath,0,100);
        
	GetCurrentTime(&m_time);
	sprintf(dirpath,"/data/%d年%d月%d日%d时%d分%d秒",m_time.year , m_time.month, m_time.day , m_time.hour , m_time.minute , m_time.sec);
	
	sprintf( cfg_file ,"%s/%d年%d月%d日%d时%d分%d秒.cfg" , dirpath,m_time.year , m_time.month, m_time.day , m_time.hour , m_time.minute , m_time.sec );
	sprintf( dat_file ,"%s/%d年%d月%d日%d时%d分%d秒.dat", dirpath,m_time.year , m_time.month, m_time.day , m_time.hour , m_time.minute , m_time.sec );
	sprintf(cmdbuf,"mkdir %s",dirpath);
	
	system(cmdbuf);
	
	handle =fopen( cfg_file ,"a+b"); 
	if(handle == 0)
	{
		return;
	}
	
	stat(cfg_file,&m_stat);
	
	if(m_stat.st_size>100)
		return;
	
	fputs((char *)StationName, handle);
	memset(linedata , 0 , 40);
        fputs("\n", handle);
	sprintf( (char *)linedata , "%d,%dA,%dD\n" , GetYcNum() + GetNsYcNum()+GetNsYxNum() , 
		GetYcNum() + GetNsYcNum() , GetNsYxNum());
	
	fputs((char *)linedata, handle);
	
	
	for( i = 0;i<GetYcNum();i++)
	{
		serial_no++;
		memset(pserial_no , 0 , 6);
		sprintf(pserial_no , "%d," , serial_no );
		fputs(pserial_no, handle);
			
			
		fwrite(m_YcChannelCfg[i].name , strlen((char*)m_YcChannelCfg[i].name ) ,1, handle );
		fputc(',' , handle);       
		fwrite(m_YcChannelCfg[i].unit , strlen((char*)m_YcChannelCfg[i].unit) ,1, handle );
		fputs(", ,", handle);  
		fwrite(m_YcChannelCfg[i].unit , strlen((char*)m_YcChannelCfg[i].unit) ,1, handle );
		fputc(',' , handle);  
			
		gcvt(m_YcChannelCfg[i].ratio,7,tmp);
		fwrite( tmp, strlen(tmp) ,1, handle );
		fputs(",0.000000,0.000000,-32767,32767\n" , handle);
	}
		

	for(i = 0;i<GetNsYcNum();i++)
	{
		serial_no++;
		memset(pserial_no , 0 , 6);
		sprintf(pserial_no , "%d," , serial_no );
		fputs(pserial_no, handle);
		
		
		fwrite(m_NsYcChannelCfg[i].name , strlen((char*)m_NsYcChannelCfg[i].name ) ,1, handle );
		fputc(',' , handle);       
		fwrite(m_NsYcChannelCfg[i].unit , strlen((char*)m_NsYcChannelCfg[i].unit) ,1, handle );
		fputs(", ,", handle);  
		fwrite(m_NsYcChannelCfg[i].unit , strlen((char*)m_NsYcChannelCfg[i].unit) ,1, handle );
		fputc(',' , handle);  
		
		gcvt(m_NsYcChannelCfg[i].ratio,7,tmp);
		fwrite( tmp, strlen(tmp) ,1, handle );
		fputs(",0.000000,0.000000,-32767,32767\n" , handle);
	}    
	
	for(i = 0 ; i <GetNsYxNum(); i ++ )
	{
		
		serial_no++;
		memset(pserial_no , 0 , 6);
		sprintf(pserial_no , "%d," , serial_no );
		fputs(pserial_no , handle);
		fwrite(m_NsYxChannelCfg[i].name , strlen((char*)m_NsYxChannelCfg[i].name ) ,1, handle );
		fputs(",0\n" , handle);       
	}
	
       
	fflush(handle );
	
	
	fputs("50 \n", handle);
	
	memset(tmp_buf , 0 ,20 );
	frenum = 2;
	sprintf(tmp_buf , "%d\n" ,  frenum );
	fputs(tmp_buf , handle);       

	tmpbuf = "5000,1800\n" ;
	fputs(tmpbuf , handle);       

	tmpbuf = "1000,4800\n" ;
	fputs(tmpbuf , handle);   
	
	
        sprintf(buf,"%d/%d/%d,%d:%d:%d.%d\n",m_time.year,m_time.month,m_time.day,m_time.hour,m_time.minute,m_time.sec,m_time.usec-40000);
	fputs(buf , handle );

        sprintf(buf,"%d/%d/%d,%d:%d:%d.%d\n",m_time.year,m_time.month,m_time.day,m_time.hour,m_time.minute,m_time.sec,m_time.usec);
        
	fputs(buf , handle );
	fputs("BINARY" , handle);
	
	fclose(handle);
}


void RecordWave(long  curpoint,long num,UBYTE type)
{

	short value;
	UBYTE yxvalue;
	int j;
	

	switch(type)
	{
	case LOWSPEED:
		{
			for(int i=num-1;i>=0;i--)
			{
				fwrite(&iid ,  4 , 1 , fhandle);
				fwrite(&ltime ,  4 , 1 , fhandle );
				
				for( j = 0;j<GetYcNum();j++)
				{
					GetValueYc(j+1,curpoint,i*4+1,&value);
					fwrite(&value,2,1 , fhandle);
				}
				
			/*	for(j = 0;j<GetNsYcNum();j++)
				{
					GetNsValueYc(j+1,curpoint,i*4+1,&value);
					fwrite(&value,1,1 , fhandle);
				}

				for(j = 0;j<GetNsYxNum();j++)
				{
					GetNsValueYx(j+1,curpoint,i*4+1,&yxvalue);
					fwrite(&yxvalue,1,1 , fhandle);
				}
				if(GetNsYxNum()%2 != 0)
				{
					yxvalue =  0xff;
					fwrite(&yxvalue,1,1 , fhandle);
				}
			*/
                        iid++;
                        ltime+=1000;
			}

			fclose(fhandle);
		}

		break;

	case MIDDLESPEED:
		{

		}

		break;

	case HIGHSPEED:
		{

			fhandle = fopen(dat_file,"a+b");
			if(fhandle == NULL)
				return;

			for(int i = num-1;i>=0;i--)
			{
				fwrite(&iid ,  4 , 1 , fhandle);
				fwrite(&ltime ,  4 , 1 , fhandle );
				
				for( j = 0;j<GetYcNum();j++)
				{
					GetValueYc(j+1,curpoint,i+1,&value);
					fwrite(&value,2,1 , fhandle);
				}
				
			/*	for(j = 0;j<GetNsYcNum();j++)
				{
					GetNsValueYc(j+1,curpoint,i+1,&value);
					fwrite(&value,1,1 , fhandle);
				}
				
				for(j = 0;j<GetNsYxNum();j++)
				{
					GetNsValueYx(j+1,curpoint,i+1,&yxvalue);
					fwrite(&yxvalue,1,1 , fhandle);
				}
				if(GetNsYxNum()%2 != 0)
				{
					yxvalue =  0xff;
					fwrite(&yxvalue,1,1 , fhandle);
				}
*/
                                iid++;
                                ltime+=100;
			
			}
		}
		
		break;

	default:
		break;
	}

	iid = 1;
	ltime = 0;

}

void SendRecordWaveStart()
{
	UBYTE buf[22];
	buf[0] = 0xff;
	buf[1] = 0xff;
	buf[2] = 0xff;
	buf[3] = 0xff;
	buf[4] = 0xff;
	buf[5] = 0xff;
	buf[6] = 0xff;
	buf[7] = 0xff;
	buf[8] = 0xff;
	buf[9] = 0xff;
	buf[10] = 0xff;
	buf[11] = 0xff;
	buf[12] = 0x00;
	buf[13] = 0x00;
	buf[14] = 0x00;
	buf[15] = 0x00;
	buf[16] = 0x00;
	buf[17] = 0x00;
	buf[18] = 0x00;
	buf[19]= 0xa5;
	buf[20] = 0x00;
	buf[21] = 0x54;
	
	
	ether_send(buf,22,0);
}

void SendRecordWaveEnd()
{
	UBYTE buf[22];
	buf[0] = 0xff;
	buf[1] = 0xff;
	buf[2] = 0xff;
	buf[3] = 0xff;
	buf[4] = 0xff;
	buf[5] = 0xff;
	buf[6] = 0xff;
	buf[7] = 0xff;
	buf[8] = 0xff;
	buf[9] = 0xff;
	buf[10] = 0xff;
	buf[11] = 0xff;
	buf[12] = 0x00;
	buf[13] = 0x00;
	buf[14] = 0x00;
	buf[15] = 0x00;
	buf[16] = 0x00;
	buf[17] = 0x00;
	buf[18] = 0x00;
	buf[19]= 0xa5;
	buf[20] = 0x00;
	buf[21] = 0x52;
	
	
	
	ether_send(buf,22,0);
	
	
}