ordermaker.cpp

西门子变频器控制代码的生成程序

#include <iostream.h>
#define VALUEBASE 327.68
/*cpoy string*/
char * string_strcpy(char *target,const char *source);
/*append string*/
char * string_strcat(char *target,const char *source);
/*insert char to string not finished*/
char * string_insert(char * target, const char data, const int position);
/*int to string(B or H)*/
char * string_itobs(int n, char * ps, int x=0,const bool carry=0);
/*double to B string*/
char * string_dtobs(double n,char * ps,int x);
/*upcase string*/
char * string_upcase(char * target);
/*lowcase string*/
char * string_lowcase(char * target);
/*B string to H string*/
char * string_bstohs(char * hs,const char * bs);
/*H string to B string*/
char * string_hstobs(char * bs, char * hs);
/*nor a string*/
char * string_nor(char * target, char * source);
/*make the IEEE value*/
char * string_IEEE(char * s_ieeeb,const struct struct_PKW * pkw);
/*make the pkw head*/
char * string_pkwhead(char * pkwhead,const struct struct_PKW * pkw);
/*make full pkw*/
char * string_pkw(char * s_pkw,const struct struct_PKW * pkw);
/*make the head of whole string*/
char * string_head(char * s_head,const struct struct_PKW * pkw);
/*make the pzd string*/
char * string_pzd(char * s_pzd, const struct struct_PZD * pzd,const bool format=0);
/*make the whole string*/
char * string_whole(char * s_whole, const struct struct_PKW * pkw,const struct struct_PZD * pzd);

/*get length of string*/
int    int_strlen(const char * string);
/*幂算法*/
int    int_pow(int x,const unsigned int n);
/*B string to int*/
int    int_bstoi(char * source,const bool carry=0);
/*得到浮点数的阶*/
int    int_jie(const double x,const bool n=0);

/*对4取余，余数1到4*/
inline int int_mod4(int n);

/*PKW结构*/
struct struct_PKW{
	int address;/*地址*/
	int ID;   /*命令类型*/
	int order;/*命令名*/
	int index;/*命令下标*/	
	int format;/*对象数值类型（单字或双字）*/
	double value;/*设定的值*/
};

/*PZD结构*/
struct struct_PZD{
	bool state00;
	bool state01;
	bool state02;
	bool state03;
	bool state04;
	bool state05;
	bool state06;
	bool state07;
	bool state08;
	bool state09;
	bool state10;
	bool state11;
	bool state12;
	bool state13;
	bool state14;
	bool state15;
	double frequency;
};


void main(void)
{
/*设定PKW区，依次为地址，状态字（读或写），命令，下标，格式（单字双字暂时未用），设定的值*/
/********手动修改下面的值，可以测试结果是否正常***********/
	struct struct_PKW pkw={
		/*address=*/0,
		/*ID=*/2,
		/*order=*/2010,
		/*index=*/1,		
		/*foramt=*/0,
		/*value=*/50,
		
	};
/*设定PZD区，依次为电机状态，设定的频率*/
	struct struct_PZD pzd={
	
	/*电机状态*/	0,0,0,0,0,1,1,1,0,1,1,1,0,1,1,0,
	/*频率*/		40.0,
	};
	char s_ieeeb[80]="";

	cout<<string_whole(s_ieeeb,&pkw,&pzd);
	




	


}


/*得到字符串长度*/
int int_strlen(const char * string)
{
    int i=0;
    while(string[i]) i++;
    return i;
} 
/*复制字符串*/
char * string_strcpy(char *target, const char *source)
{ 
	char * address = target; 
	while( (*target++ = * source++) != '\0' ); 
	return address ; 
}

/*连接字符串 */
char * string_strcat(char *target,const char *source)
{

	char *original;
	original=target;
	while(*target) target++;     
	while(*target++=*source++);
	return(original);
}




/*插入字符，未完成*/
char * string_insert(char * target, const char data, const int position)
{
	char * backup;
	int i=0;
	backup=target;
	for(i=0;i<position;i++)
	{		
		target++;
	}
	return backup;

}

/*整形转字符串。n:整形数；ps:目标字符串；x:字符串长度；carry=0(二进制)carry=1(十六进制)*/
char * string_itobs(int n, char * ps,int x,const bool carry)
{
	int i;
	int i_hvalue;
	int i_size;
	if(carry==0)/*二进制*/
	{	     
	    
	         if(n==0)/*长度至少为一*/
			 {
				 x=(x>0)?x:1;
                for(i=0;i<x;i++)
				{
					ps[i]='0';
				}
				ps[x]='\0';
		       	return ps;		
			 }
		     else/*字符串长度为设定值和实际值之间的较大者*/
			 {
		        
				i_size=((int_jie(n)+1)>x)?(int_jie(n)+1):x;
	            for(i=i_size-1;i>=0;i--,n>>=1)
		        ps[i]=(01&n)+'0';
	            ps[i_size]='\0';
	 	        return ps;
			 }
		 
	}
	else/*十六进制*/
	{
		
	         if(n==0)/*长度至少为一*/
			 {
				 x=(x>0)?x:1;
		    	for(i=0;i<x;i++)
				{
					ps[i]='0';
				}
                ps[x]='\0';
		       	return ps;		
			 }
		     else/*字符串长度为设定值和实际值之间的较大者*/
			 {
		        int i_size=((int_jie(n,1)+1)>x)?((int_jie(n,1)+1)):x;
	            for(i=i_size-1;i>=0;i--,n>>=4)
				{
                    i_hvalue=15&n;
					ps[i]=(i_hvalue>=0&&i_hvalue<=9)?(i_hvalue+'0'):(i_hvalue+55);
				}
	            ps[i_size]='\0';
	 	        return ps;
			 }
		
	}


}
/*小数部分转字符串。x为字符串长度*/
char * string_dtobs(double n,char * ps,int x)
{
	double dn;
	int i=0;
	dn=n-(int)n;
	for(i=0;i<x;i++)
	{ 	
		ps[i]=(int)(2*dn)+'0';
		dn=2*dn-(int)(2*dn);
	}
	      ps[x]='\0';
	 	  return ps;
}

/*大写化*/
char * string_upcase(char * target)
{
	char * backup;
	backup=target;
	while(*target)
	{
		if(*target>='a'&&*target<='z')
		{
			*target=*target-32;			
			target++;
		}
		else
		{
			target++;
		}

	}
	return backup;
}

/*小写化*/
char * string_lowcase(char * target)
{
	char * backup;
	backup=target;
	while(*target)
	{
		if(*target>='A'&&*target<='Z')
		{
			*target=*target+32;			
			target++;
		}
		else
		{
			target++;
		}

	}
	return backup;
}


/*乘方只处理0次及以上次*/
int int_pow(int x,const unsigned int n)
{ 
	unsigned int i=0;
	int i_result=1;
	if(x==0)
	{
		return 0;
	}
	else
	{
	for(i=0;i<n;i++)
	{
		i_result=i_result*x;
	}
	return i_result;
	}
}
/*字符串转整形,carry=0二进制，carry=1十六进制*/
int  int_bstoi(char * source,const bool carry)
{
	int x=0;
	int i=0;
	int y=0;
	int len=int_strlen(source);
	if(carry==0)/*二进制*/
	{
	 
	 for(i=0;i<len;i++)
	 {
		x=*source-'0';					
		y=y+(x<<(len-i-1));
		source++;
	 }
	 return y;
	}
	else/*十六进制*/
	{
		string_upcase(source);/*upcase*/
		for(i=0;i<len;i++)
		{
			if(*source>='0'&&*source<='9')
			{
				x=*source-'0';
			}
			else
			{
				x=*source-55;
			}				
			y=y+(x<<((len-1-i)<<2));
			
			source++;
		}
		return y;
	}
}
/*得到输入值的阶n=0,二进制阶；n=1,十六进制阶*/
int int_jie(const double x,const bool n)
{
	
	int i=0;
	int ix=0;
	double dx=0.0;
	if(n==0)/*二进制*/
	{
	
		
	    if(x>=1)/*值大于1时*/
		{
	 	  ix=(int)x;
	 	  while(ix)
		  {
			ix>>=1;
			i++;
		  }
	     	return i-1;
		}
    	if(x<1&&x>0)/*值小于1时*/
		{
		   dx=x;
		  while(dx<1)
		  {
			dx=dx*2;
			i++;
		  }
		return -i;
		}
	}
	else/*十六进制*/
	{
		if(x>=1)/*值大于1时*/
		{
			ix=(int)x;
			while(ix)
			{
				ix>>=4;
				i++;
			}
			return i-1;
		}
		if(x>0&&x<1)/*值小于1时*/
		{
			dx=x;
			while(dx<1)
			{
				dx=dx*16;
				i++;
			}
			return -i;
		}
		
	}
	
}
/*把二进制字符串转变为十六进制字符串*/
char * string_bstohs(char * hs,const char * bs)
{
	int i=0;
	int j=0;
	int hsi=0;
	int bslen=0;
	int hslen=0;
	int bsi;
	int bsmod4;
	bslen=int_strlen(bs);	
	bsmod4=bslen&3;
	hslen=(bsmod4==0)?(bslen>>2):((bslen>>2)+1);
    
	for(i=0;i<hslen;i++)/*十六进制字符串长度*/
	{	
		hsi=0;
		for(j=0;j<4;j++)/*生成一个十六进制字符*/
		{	
			bsi=(((i<<2)+j-4+int_mod4(bslen))>=0)?bs[(i<<2)+j-4+int_mod4(bslen)]:'0';			
			hsi=hsi+((bsi-'0')<<(3-j));			
		}
	
		hs[i]=(hsi>=0&&hsi<=9)?(hsi+'0'):(hsi+55);
		
	}
	hs[hslen]='\0';
	return hs;
}

/*对4取余，余数范围1－4*/
inline int int_mod4(int n)
{
	n=n&3;
	n=(n>0)?n:(n+4);
	return n;
}

/*十六进制字符串转成二进制字符串，注意原十六进制字符窜会被大写化*/
char * string_hstobs(char * bs, char * hs)
{
	char temp[5]="";	
	int i=0;
//	int j=0;
	int i_hslen=0;
//	int i_bslen=0;
	int i_hvalue=0;
	i_hslen=int_strlen(hs);
	string_upcase(hs);
	string_strcpy(bs,"");
	for(i=0;i<i_hslen;i++)
	{
		i_hvalue=(hs[i]>='0'&&hs[i]<='9')?(hs[i]-'0'):(hs[i]-55);
		string_itobs(i_hvalue,temp,4);		
		string_strcat(bs,temp);
	}
	return bs;
}
/*异或十六进制字符串*/
char * string_nor(char * target, char * source)
{
	int i_sourcelen=0;
	int i_value=0;
	int i_sourcei=0;
	int i_tempvalue=0;
	int i=0;
	int j=0;
	int i_norvalue=0;
	string_upcase(source);
	i_sourcelen=int_strlen(source);
	if(i_sourcelen<=2||((i_sourcelen&1)==1))/*长度小于二或者长度为单则返回WR*/
	{
		return "WR";
	}
	else
	{
		for(i=0;i<(i_sourcelen>>1);i++)
		{
			i_value=0;
			for(j=0;j<2;j++)
			{
				i_sourcei=source[(i<<1)+j];				
				/*得到一个字节的十进制值*/
				i_tempvalue=(i_sourcei>='0'&&i_sourcei<='9')?(i_sourcei-'0'):(i_sourcei-55);
				
				i_value=i_value+((i_tempvalue)<<(4*(1-j)));			
			}			
			i_norvalue=i_norvalue^i_value;
			

		}
		/*转换成十六进制数字符串*/
		target=string_itobs(i_norvalue,target,2,1);
		return target;
	}
}


/*由PKW结构得到IEEE数的十六进制字符串*/
char * string_IEEE(char * s_ieee,const struct struct_PKW * pkw)
{	
	char s_sign[2]="";
	char s_jie[9]="";
	char s_weishu[24]="";
	
	double d_pweishu=0;	
    int i_jie=0;
	int i=0;
	/*双字转字符串*/
   if((pkw->ID)==3)
   {
    /*符号位字符串*/
	s_sign[0]=((pkw->value)>0)?'0':'1';
	s_sign[1]='\0';

    /*阶字符串*/
	i_jie=int_jie(pkw->value);
	string_itobs(127+i_jie,s_jie,8);

	/*尾数字符串*/
	d_pweishu=(pkw->value)/(1<<i_jie);/**************此处使用了浮点数的除法*****************/
	string_dtobs(d_pweishu,s_weishu,23);

    /*二进制IEEE字符串*/
	string_strcpy(s_ieee,s_sign);	
	string_strcat(s_ieee,s_jie);	
	string_strcat(s_ieee,s_weishu);	
	s_ieee[32]='\0';

	/*二进制转十六进制字符串*/
	string_bstohs(s_ieee,s_ieee);
    
	return (s_ieee);
   }
   /*无操作*/
   if((pkw->ID)==0)
   {

	   return "00000000";
   }
   /*单字转字符串*/
   if((pkw->ID)==2)
   {	   
	   string_itobs((int)(pkw->value),s_ieee,4,1);	  
	   return s_ieee;
   }

}
/*PKW区头，包含了状态位，命令，下标*/
char * string_pkwhead(char * pkwhead,const struct struct_PKW * pkw)
{
	char s_ID[2]="";
	char s_order[4]="";
	char s_pnu2k[2]="";
	char s_pnuindex[4]="";
    /*状态*/
    string_itobs((pkw->ID),s_ID,1,1);
	/*命令（是否过2000）*/
	if((pkw->order)>=2000)
	{
		string_itobs((pkw->order)-2000,s_order,3,1);
		s_pnu2k[0]='8';
		s_pnu2k[1]='\0';
	}
	else
	{
		string_itobs((pkw->order),s_order,3,1);
		s_pnu2k[0]='0';
		s_pnu2k[1]='\0';
	}
	/*下标*/
	string_itobs((pkw->index),s_pnuindex,3,1);
	/*合成PKW头部*/
	string_strcpy(pkwhead,s_ID);
	string_strcat(pkwhead,s_order);
	string_strcat(pkwhead,s_pnu2k);
	string_strcat(pkwhead,s_pnuindex);


	return (pkwhead);
	
}
/*调用string_IEEE和string_pkwhead合成整个PKW段十六进制代码*/
char * string_pkw(char * s_pkw, const struct struct_PKW * pkw)
{
	char s_IEEE[34]="";
	s_pkw[0]='\0';

	string_pkwhead(s_pkw,pkw);	
    string_IEEE(s_IEEE,pkw);	
	string_strcat(s_pkw,s_IEEE);
	return s_pkw;
}
/*字符串头，包括固定的02,长度，地址*/
char * string_head(char * s_head,const struct struct_PKW * pkw)
{
	char s_begin[]="02";
	char s_length[3]="";
	char s_address[3]="";
	if((pkw->ID)==2)
	{
		s_length[0]='0';
		s_length[1]='C';
		s_length[2]='\0';
	}
	else
	{
		s_length[0]='0';
		s_length[1]='E';
		s_length[2]='\0';
	}
	string_itobs((pkw->address),s_address,2,1);
	string_strcpy(s_head,s_begin);
	string_strcat(s_head,s_length);
	string_strcat(s_head,s_address);
	return (s_head);
}

/*PZD区字符串.s_pzd目标字符串；*pzd 源PZD结构；format，十六进制还是十进制*/
char * string_pzd(char * s_pzd, const struct struct_PZD * pzd,const bool format)
{
	char s_value[5]="";
	
	s_pzd[0]=pzd->state00+'0';
	s_pzd[1]=pzd->state01+'0';
	s_pzd[2]=pzd->state02+'0';
	s_pzd[3]=pzd->state03+'0';
	s_pzd[4]=pzd->state04+'0';
	s_pzd[5]=pzd->state05+'0';
	s_pzd[6]=pzd->state06+'0';
	s_pzd[7]=pzd->state07+'0';
	s_pzd[8]=pzd->state08+'0';
	s_pzd[9]=pzd->state09+'0';
	s_pzd[10]=pzd->state10+'0';
	s_pzd[11]=pzd->state11+'0';
	s_pzd[12]=pzd->state12+'0';
	s_pzd[13]=pzd->state13+'0';
	s_pzd[14]=pzd->state14+'0';
	s_pzd[15]=pzd->state15+'0';
	s_pzd[16]='\0';
	string_bstohs(s_pzd,s_pzd);
	if(format==1)
	{
				
	}
	else
	{
		string_itobs((pzd->frequency)*VALUEBASE,s_value,4,1);		
	}
	return (string_strcat(s_pzd,s_value));

}
/*生成整个命令，s_whole目标字符串，*pkw 源PKW结构，*pzd 源PZD结构*/
char * string_whole(char * s_whole, const struct struct_PKW * pkw,const struct struct_PZD * pzd)
{
	char s_head[32]="";
	char s_pkw[32]="";
	char s_pzd[32]="";
	
	char s_BCC[3]="";
	/*命令头*/
	string_head(s_head,pkw);
	/*PKW区*/
	string_pkw(s_pkw,pkw);
	/*PZD区*/
	string_pzd(s_pzd,pzd);	

	string_strcpy(s_whole,s_head);
	string_strcat(s_whole,s_pkw);
	string_strcat(s_whole,s_pzd);
	/*BCC校验*/
	string_nor(s_BCC,s_whole);	
	string_strcat(s_whole,s_BCC);
	return s_whole;

}