public.c

税控收款机源码:拼音输入法,LCD,VFD驱动,IC卡驱动,税控国标

/*-------------------------------------------------------------
	说明:公用的转换、键盘处理功能函数
	日期:2003年5月
    作者:
-------------------------------------------------------------*/
#include "include.h"

/*测试用函数*/

//=========================================================================================
/*void testf(uchar row,uchar* str)
{
	clear_lcd(row,1);
	lcd_disp(row,0,str);
	while(!get_key());
}*/
/********************************************
检查两数相乘是否有溢出
********************************************/
uchar is_mul_overflow(ulong x,ulong y)
{
	ulong z;
   //2005.11.25
	z=a_mul_b(x,y,1);
	//t=a_div_b(z,x);
    //send_str(4,&z);send_str(4,&t);
   //if(((t>y)&&(t>(y+1)))||((y>t)&&(y>(t+1))))return(1);//防止有4舍5入的问题
   if(z==0)return(1);
		
	return(0);
}
/********************************************
检查两数相加是否有溢出
********************************************/
uchar is_add_overflow(ulong x,ulong y)
{
	ulong z;
	z=x+y;
	if(z-x!=y)
		return(1);
	return(0);
}
/***********************************************
拷贝字符串，并在前面(before!=0时)或后面补空格
************************************************/
void copy(uchar* src,uchar * dst,uchar len,uchar before)
{
	uchar src_len,i;
	src_len=strlen((const char *)src);
	if(before) //前面补空格
	{
        //send_char(src_len);
        //send_char(len);
		if(src_len>=len)
			memcpy(dst,src,len);
		else
		{
			for(i=0;i<len-src_len;i++)
				dst[i]=' ';
			memcpy(&dst[i],src,src_len);
		}
	}
	else //后面补空格
		for(i=0;i<len;i++)
		{
		
			if(src_len<=i)
				dst[i]=' ';//补空格
			else
				dst[i]=src[i];
		}
	dst[len]=0;
		
}
/*********************************************
 函数功能： 计算LRC校验和
 入口参数： length 参加运算数据长度,不包含待校验的LRC 
            calc为1则表示只计算，为0则表示计算后比较
			buffer 数据地址指针
            			 
 返回值：   若为计算，则返回计算后的校验值；
            若为比较，相等返回0，否则为1
 作者：
/*********************************************/
uchar lrcdata(uint length,uchar calc,void *buffer)
{
	uchar lrc;
	uint i;
	lrc=0;
	for(i=0;i<length;i++)
		lrc^=((uchar *)buffer)[i];
	if(calc)
		return(lrc);
	else
		if(lrc==((uchar *)buffer)[length])
			return(0);
	else return(1);
}

/*********************************************
 函数功能： 给给定缓冲区清0
 入口参数： buf,赋值前的缓冲区;len,长度
            
 出口参数： buf,赋值后的缓冲区
 返回值  ：无
 作者：
/*********************************************/
void set_value0(void *buffer,uint len)
{
	uint i;
	for(i=0;i<len;i++)
	{
		*((uchar*)buffer)=0;
		((uchar*)buffer)++;
	}
}
//===============================================
ulong mypow(ulong base,uint times)
{
	ulong num;
	uint i;
	if(times==0)
		return(1);
	num=1;
	for(i=0;i<times;i++)
		num*=base;
	return(num);
}


/*********************************************
功能：将数组中的字节按高低顺序转换为长整型
	  如buf[0]=0x10,buf[1]=0x20,buf[2]=0x30,buf[3]=0x40
 	  则转换后的值为0x10203040
入口参数：buf,待转换的数据，len,待转换的数据字节数
返回值  ：转换后的值
作者：

***************************************/
ulong ToLong(uchar * buf,uchar len)
{
	uchar i;
	ulong value;
	value=0;
	for(i=0;i<len;i++)
		value+=buf[i]*mypow(0x10,2*(len-1)-2*i);
	return(value);
}

/*********************************************
功能：将4个字节长整型转换为4个字节的数组
	  如0x10203040，转换后的值为output[0]=0x10,output[1]=0x20,
	                            output[2]=0x30,output[3]=0x40
入口参数：long,待转换的长整数，len,待转换的数据字节数
出口参数：output,转换后的4个字节的数组的首地址
返回值  ：无
作者：

***************************************/
void ltoa(ulong value,uchar * output)
{
	uchar i;
	for(i=0;i<4;i++)
		output[i]=value >> ((3-i)*8);
}
/*********************************************
功能：将4字节长整型转换为大写字符串,
      如将12345678转换为"壹拾贰万叁仟四佰五拾陆元柒角捌分"
入口参数：  vale,待转换的数值
出口参数  ：output,转换后的字符串的首地址
返回值  ：无
作者：

***************************************/
void convert_cap(ulong value,uchar * output)
{
	const uchar cap[]={"仟佰拾"},cap2[]={"亿万元"};
	uchar buf[20];
	uchar i,j,tmp,flag;

	j=0;
	flag=255;
	sprintf((char *)buf,"%012lu",value/100);
	for(i=0;i<12;i++)
	{
		tmp=buf[i]-0x30;
		if(tmp)
		{
			memcpy(&output[j],&capitalization[2*tmp],2);
			j+=2;
			if((i+1)%4)
			{
				memcpy(&output[j],&cap[i%4*2],2);
				j+=2;
			}
			if(i<=3) flag=3; //亿
			else if(i<=7) flag=7;  //万
			//else flag=11;           //元
		}
		if(i==flag)
		{
			memcpy(&output[j],&cap2[((i+1)/4-1)*2],2);
			j+=2;
		}

	}
   // 2005.8.14
   if(value/100)
   {
	if(j==0)
	{
		memcpy(output,"零",2);
		j+=2;
	}
    
	memcpy(&output[j],"元",2);
	j+=2;
    }
	//小数部分
	value=value%100;
	if(value==0)
	{
		memcpy(&output[j],"整",2);
		output[j+2]=0;
		return;
	}
	tmp=value/10;
	if(tmp)
	{
		memcpy(&output[j],&capitalization[2*tmp],2);
		j+=2;
		memcpy(&output[j],"角",2);
		j+=2;
	}
	tmp=value%10;
	if(tmp)
	{
		memcpy(&output[j],&capitalization[2*tmp],2);
		j+=2;
		memcpy(&output[j],"分",2);
		j+=2;
	}
	output[j]=0;

}

/* 入口参数：a和b是放大了100倍的长整型数
   返回值:a和b缩小100倍后的乘积，也是放大了100倍的长整型数
*/
/*
ulong a_mul_b(ulong a,ulong b,uchar mode)
{
	ulong a1,a2,b1,b2;
	ulong t;
    ulong x;
	//ulong y;
    uchar times;

   
		 
	b1=b/100,b2=b%100; //b的整数部分和小数部分,小数部分乘了100
	if(mode==0)
	{
	 a1=a/100,a2=a%100; //a的整数部分和小数部分,小数部分乘了100
	 t=a1*b1*100+a1*b2+a2*b1+a2*b2/100;
	 if((a2*b2%100)>=50)t++;//4舍5入
	}
	else
	 {
	  times=a>>24;
	  a&=0xffffff;
	  if(times>0)
	   {
	     x=mypow(10,times);
 	     a1=a/x,a2=a%x; //a的整数部分和小数部分,小数部分乘了
		 
	   	 if(times>2)
	       {
	         x=mypow(10,times-2); 
	         t=a1*b1*100+(a1*b2)+(a2*b1)/x+(a2*b2)/(100*x);//t=a1*b1*100+(a1*b2)+(a2*b1*100+a2*b2)/(100*x);
			 //y=(((a2*b2)%(100*x))/100);
             //if((((a2*b2)%(100*x))%100)>=50)y++;
			 if(((((a2*b1)%x)*100+(a2*b2)%(100*x))%(100*x))>=(x*50))t++;//if(((a2*b1*100+a2*b2)%(100*x))>=(x*50))t++;
			
	       }
		 else if(times==2)
		  {
		    t=a1*b1*100+a1*b2+a2*b1+a2*b2/100;
	        if((a2*b2%100)>=50)t++;//4舍5入
		  }
		  else
		  {
		   t=a1*b1*100+a1*b2+a2*b1*10+a2*b2/10;
           if((a2*b2%10)>=5)t++;//4舍5入
		  }
	   }
	   else t=a*b1*100+a*b2; //整数*一个小数
	 }
	 
    return(t);
}*/
/*
ulong a_mul_b(ulong a,ulong b,uchar mode)
{
	ulong a1,a2,b1,b2;
	ulong t;
    ulong x;
	//ulong y;
    uchar times;
		 
	b1=b/100,b2=b%100; //b的整数部分和小数部分,小数部分乘了100
	if(mode==0)
	{
		a1=a/100,a2=a%100; //a的整数部分和小数部分,小数部分乘了100
		t=a1*b1*100+a1*b2+a2*b1+a2*b2/100;
		if((a2*b2%100)>=50)t++;//4舍5入
	}
	else
	{
		times=a>>24;
		a&=0xffffff;
		x=mypow(10,times-1);
		if(times)
			t = (1.0*a*b/x+5)/10;
		else
			t = 1.0*a*b;
	}
    return(t);
}*/

ulong a_mul_b(ulong a,ulong b,uchar mode)
{
	ulong a0,a1,a2,b1,b2;
	ulong t,t1,t2,t3,t4;
    ulong x;
	uchar times,i,j;
	if(mode==0)
	{
		a1=a/100,a2=a%100; //a的整数部分和小数部分,小数部分乘了100
		t=a1*b1*100+a1*b2+a2*b1+a2*b2/100;
		if((a2*b2%100)>=50)t++;//4舍5入
	}
	else
	{
		a0 = a&0x00ffffff; 
		times = a>>24;
		a1 = a0>>16;
		a2 = a0&0x0000ffff;
		b1 = b>>16;
		b2 = b&0x0000ffff;

		t1 = a1*b1;
		t2 = b1*a2;
		t3 = a1*b2;
		t4 = a2*b2;
		
		if(t1>0x01||t2>0xffff||t3>0xffff||(t2+t3>0xffff))
		{
			t1 = t1 + (t2>>16) + (t3>>16);
			t = (t2<<16) + (t3<<16) + t4;
			a0 = t1;
			i = 0;
			do
			{
				i++;
				a0 = a0 / 16;
				if(a0==0)
					break;
			}while(1);
		}
		else
		{
			t = (t2<<16) + (t3<<16) + t4;
		}
		
		if(times)
		{
			x=mypow(10,times-1);
			
			//t2 = (t1<<(32-i*4))/x;
			//t3 = (t1<<(32-i*4))%x;
			
			//t2 = t2<<(4*i);
			//t3 = (t3<<(4*i))/x;
			//t = t/x;
			//t = t+t2+t3;

			t = t/x;
			for(j=0;j<i;j++)
			{
				t2 = (((t1>>(j*4))&0xff)<<28)/x;
				t3 = (((t1>>(j*4))&0xff)<<28)%x;
				t2 = t2<<(4*(j+1));
				t3 = (t3<<(4*(j+1)))/x;
				t =  t+t2+t3;
			}
			
			t = (t + 5)/10; //四舌五入
		}
	}
	return(t);
}

//==================================================================
ulong a_div_b(ulong a,ulong b)
{
	ulong t;
	t=a/b*100+a%b*100/b;
	if(((((a%b*100)%b)*100)/b)>=50) t++;	//4舍5入
		return(t);
}
/********************************************
将形如 "AB09CD"作为16进制串每2个字符分别转换(如AB,09,CD)为字节类型
入口参数：str,以\0为结束符的字符串
出口参数：output,转换后的没有结束符的字符指针
返回值  ：转换正确为0，否则返回其他错误
作者：
********************************************/
uchar HexToByte( uchar * str,uchar * output)
{
	uchar len;
	uchar i,j;
	uchar tmp[2];
	len=strlen((const char*)str);
	if(len % 2 )
		return(PARAM_FAIL);
	len /=2;
	for(i=0;i<len;i++)
	{
		tmp[0]=str[2*i];
		tmp[1]=str[2*i+1];
		output[i]=0;
		for(j=0;j<2;j++)
		{
			switch(tmp[j])
			{
			case '0':
			case '1':
			case '2':
			case '3':
			case '4':
			case '5':
			case '6':
			case '7':
			case '8':
			case '9':
				output[i]+=(tmp[j]-0x30)*(j==0?0x10:1);
				break;
			case 'A':
			case 'a':
				output[i]+=10*((j==0?0x10:1));
				break;
			case 'B':
			case 'b':
				output[i]+=11*((j==0?0x10:1));
				break;
			case 'C':
			case 'c':
				output[i]+=12*((j==0?0x10:1));
				break;
			case 'D':
			case 'd':
				output[i]+=13*((j==0?0x10:1));
				break;
			case 'E':
			case 'e':
				output[i]+=14*((j==0?0x10:1));