printfunction.c

9针的打印机驱动程序,单片机采用ST uPSD3254A

					PaperSpeedUpForward(PFP);//走纸加速20步
					PaperConstantSpeedForward(PFP,temp-8);//走纸常速temp步
					PaperSpeedDownForward(PFP);//走纸减速4步
			}
			PaperHold(0);//走纸相位保持
      break;}
		case ESCPaperBackByte:
		{
      XBYTE[defaltcommandmark]=0;//缺省命令标记置0
      PrintBuffer();//打印缓冲
      temp=XBYTE[backchar];
      temp=temp<<3;
      if(temp==FALSE)
			PaperSlowSpeedBack(PhaseDirectionSwitch(PFP),16);//退纸n步
			else
			{
					PaperSpeedUpBack(PhaseDirectionSwitch(PFP));//退纸加速12步
					PaperConstantSpeedBack(PBP,temp-8);//退纸常速temp步
					PaperSpeedDownBack(PBP);//退纸减速4步
			}
			PaperHold(0);//走纸相位保持
      break;}
		case FSEnterChinese:
		{
      XBYTE[chinesemethod]=1;//汉字方式
      break;}
    case FSExitChinese:
    {
      XBYTE[chinesemethod]=0;//字符方式
      break;}
    case	GSBlackMark:
    {
    	
    	break;}	                                                                        
		default:break;					
	 }
}

/*******************************************************************************
*	Function Name	 :PrintBuffer
*	Description		 :打印缓冲
*	Input			 		 :none								 
*	Return			 	 :none
*******************************************************************************/
void	PrintBuffer(void)
{
		struct buffer  xdata *buf=printbufferaddr;
		struct rowbuffer   xdata *rowbuf=rowbufferaddr;//代码地址
		struct rowcode		 xdata *prowcode=rowcodeaddr;//行代码首地址
		u8  xdata  *prowbuf;
		u8	chineseinterval,charinterval,rowcodecount,dotcountmark;
		static	u16			dotcount=0;
		u16	codecount,bufend,exactdotcount,tempprowbuf;
		bufend=buf->pb+printbufferlength;
		chineseinterval=XBYTE[chineseleftinterval]+XBYTE[chineserightinterval]+16;//汉字间距
		charinterval=XBYTE[charrightinterval]+8;//字符右间距
		rowcodecount=0;
		//dotcount=0;
		prowbuf=rowbuf->rowbufaddr;//代码缓冲首地址
		codecount=rowbuf->count;//代码缓冲大小
		while(codecount!=0)
		{
				if(rowcodecount==FALSE)
				{
						tempprowbuf=prowbuf;
						
				}
				if(*prowbuf>0xa0)
				{
						dotcount+=chineseinterval;//调
						if(dotcount<=400)
						{
							prowbuf+=2;
							rowcodecount+=2;
							codecount-=2;
							exactdotcount=dotcount;
						}
				}
				else
				{
						dotcount+=charinterval;//调
						if(dotcount<=400)
						{
							prowbuf++;
							rowcodecount++;
							codecount--;
							exactdotcount=dotcount;
						}
				}
				if(prowbuf>bufend)//缓冲满
				{
						prowbuf=buf->pb+1;//指向首址
				}
				if(prowbuf==bufend)//缓冲满
				{
						prowbuf=buf->pb;//指向首址
				}
				if(dotcount>400||codecount==FALSE)
				{
						XBYTE[printcharcount]=rowcodecount;//缺省命令下一行字符数
						prowcode->addr=tempprowbuf;//代码地址
						prowcode->count=rowcodecount;//代码大小
						CodeToData();//代码转换为数据
						NoPaperDeal();//无纸处理
						PrintOneRow(0);	//单向打印
						if(codecount!=0||dotcount>=400)
						{
								PaperSlowSpeedForward(PFP,XBYTE[charrowinterval]+16);//慢速走纸8步
								PaperHold(0);//相位保持
						}
						rowcodecount=0;
						if(dotcount>=400)//接着计点数
						{
								dotcount=0;
								dotcountmark=0; 
						}
						else
						{
								dotcountmark=1; 
						}
						if(XBYTE[defaltcommandmark]==TRUE)
						{
								if(dotcountmark==TRUE)
								XBYTE[nextposition]=exactdotcount>>1;//下一位置打印点
								else
								XBYTE[nextposition]=0;
								break;
						}
						else
						{
								XBYTE[nextposition]=0;
								dotcount=0;
						}
				}
		}
}
/*******************************************************************************
*	Function Name	 :CodeToData
*	Description		 :代码转换数据
*	Input			 		 :u8 direction 								 
*	Return			 	 :none
*******************************************************************************/
void	CodeToData(void)	
{
		struct buffer  xdata *buf=printbufferaddr;
		struct rowcode		 xdata *prowcode=rowcodeaddr;//行代码首地址
  	struct rowbufdata	 xdata *rowdata=rowbufdataaddr;//代码内容地址
  	
  	u8  xdata  *prowbuf;
  	u8	xdata	 *prowdata;	
  	u8  i,j,temp,temp1,temp2,hang,bufcount;
  	u16  data addr,bufend;
  	u32  data addrtemp;
		bufend=buf->pb+printbufferlength;
  	prowbuf=prowcode->addr;//打印缓冲字符代码首地址
  	bufcount=prowcode->count;//代码数
  	prowdata=rowdata->pb;//行缓冲首地址
  	rowdata->count=0;//初始行缓冲计数
		while(bufcount!=0)                               
  	{
  		 if(*prowbuf>0xa0)
  		 {
		 			temp=XBYTE[chineseleftinterval];//定义汉字左间距
					for(i=0;i<temp;i++)
					{
						*(prowdata)=0;
						*(prowdata+420)=0;
						prowdata++;
						rowdata->count++;
					}
					temp1=*prowbuf;
					prowbuf++;
					if(prowbuf==bufend)
					prowbuf=buf->pb;
					temp2=*prowbuf;
					prowbuf++;
					if(prowbuf==bufend)
					prowbuf=buf->pb;
		 			addrtemp =(u32)((temp1-0xB0)*94+(temp2-0xA1))*32;
  	      addr=addrtemp;
  	      addr|=0x8000;
  	      PSD_REG.PAGE=addrtemp>>15;
  	      for(i=0;i<16;i++)
  	      {
  	      		//temp1=XBYTE[i+addr];
  	      		//temp2=XBYTE[i+16+addr];
							temp=XBYTE[i+addr];		//字节倒序
							temp1=0;
							for(j=0;j<8;j++)
							{
							 	if(temp&(1<<j))
								temp1|=(1<<(7-j));	
							}
							temp=XBYTE[i+16+addr];//字节倒序
							temp2=0;
							for(j=0;j<8;j++)
							{
							 	if(temp&(1<<j))
								temp2|=(1<<(7-j));	
							}
  	      				//temp1=*(p+i);
  	      				//temp2=*(p+i+16);
  	      		//汉字奇数行缓冲数据		
							temp=0;
  	      		for(j=0;j<4;j++)
							{	
								if(temp1&(1<<(2*j+1)))		                                               
								temp|=(1<<(4+j));
							}
							for(j=0;j<4;j++)	
							{
								if(temp2&(1<<(2*j+1)))
								temp|=(1<<j);
							}
							*(prowdata)=temp;
							//汉字偶数行缓冲数据
							temp=0;
  	      		for(j=0;j<4;j++)
							{	
								if(temp1&(1<<(2*j)))
								temp|=(1<<(4+j));
							}
							for(j=0;j<4;j++)	
							{
								if(temp2&(1<<(2*j)))
								temp|=(1<<j);
							}
							*(prowdata+420)=temp; //384
							prowdata++;
							rowdata->count++;
					}
					temp=XBYTE[chineserightinterval];//定义汉字右间距
					for(i=0;i<temp;i++)
					{
						*(prowdata)=0;
						*(prowdata+420)=0;
						prowdata++;
						rowdata->count++;
					}
					bufcount-=2;
					//prowbuf+=2;
  		 }
  		 else
  		 if(*prowbuf>0x1f)
  		 {
  				addr=(*prowbuf-0x20)*8;//16
  				addr|=0x8000;
  				for(i=0;i<8;i++)	 		
  				{
  						//temp1=zimux[i+addr];
  						//temp2=zimux[i+8+addr];
  						PSD_REG.PAGE=7;
  						temp=XBYTE[i+addr];
  						temp1=0;
							for(j=0;j<8;j++)//字节倒序
							{
							 	if(temp&(1<<j))
								temp1|=(1<<(7-j));	
							}
							//西文字符奇数行缓冲数据
							*(prowdata)=temp1;
  						//西文字符偶数行缓冲数据
							*(prowdata+420)=0;//temp;//384
							prowdata++;
							rowdata->count++;
  				}
  				temp=XBYTE[charrightinterval];//字符右间距
  				for(i=0;i<temp;i++)
  				{
  						*(prowdata)=0;
  						*(prowdata+420)=0;
  						prowdata++;
							rowdata->count++;
  				}
  		 		bufcount--;
					prowbuf++;
					if(prowbuf==bufend)
  		 		{
  		 				prowbuf=buf->pb;	
  		 		}
  		 }
		}
}
/*******************************************************************************
*	Function Name	 :PrintOneRow
*	Description		 :打印一行内容
*	Input			 :u8 direction 								 
*	Return			 :none
*******************************************************************************/
void	PrintOneRow(u8	direction)
{
		struct printrow 	 xdata *prow=printrowbaseaddr;//打印行缓冲地址
		struct rowbufdata	 xdata *rowdata=rowbufdataaddr;//代码内容地址		
		u8	i,temp,stepcount;
		//prowbuf=rowbuf->rowbufaddr;//打印缓冲字符代码首地址
		PaperSlowSpeedBack(PhaseDirectionSwitch(PFP),4);//慢速退纸4步
		PaperSlowSpeedForward(PhaseDirectionSwitch(PBP),4);//慢速走纸4步
		PaperHold(0);//相位保持
		if(rowdata->count>420)//限制打印点数
		rowdata->count=420;
		//打印奇数行	
		//PaperSlowSpeedForward(PFP,XBYTE[charrowinterval]);//慢速走纸n步
		//PaperHold(0);//保持相位	
  	prow->printrowaddr=rowbufdataaddr+2;//奇数行缓冲地址
  	stepcount=(rowdata->count+1)/2;
		prow->printrowcount=stepcount;//奇数行缓冲大小
		CarriageSpeedUpRightToLeft(PhaseDirectionSwitch(CLRP));//左加速12步
		CarriageConstantSpeedRightToLeft(CRLP,XBYTE[nextposition]+2);//左常速下一位置+2步
		while(prow->printrowcount!=0)
		{
			 CarriageRightToLeft(CRLP);
			 delay(15);
			 for(i=0;i<2;i++)
			 {
			 		temp=XBYTE[prow->printrowaddr];
			 		PrintDrive(XBYTE[prow->printrowaddr],35);
			 		delay(4);
			 		prow->printrowaddr++;
			 }
			 prow->printrowcount--;
		}
		CarriageSpeedDownRightToLeft(CRLP);//左减速12步
  	CarriageSpeedUpLeftToRight(PhaseDirectionSwitch(CRLP));//右加速12步
  	CarriageConstantSpeedLeftToRight(CLRP,XBYTE[nextposition]+2);//右常速2步
  	CarriageConstantSpeedLeftToRight(CLRP,stepcount);//右常速X步
  	CarriageSpeedDownLeftToRight(CLRP);//右减速12步
  	CarriageHold(600);
  	if(XBYTE[chinesemethod]==TRUE)//汉字方式
  	{
  			if(direction==FALSE)//汉字单向打印
  			{	
  				 prow->printrowaddr=rowbufdataaddr+422;//偶数行缓冲地址	386
				 	 prow->printrowcount=stepcount;//偶数行缓冲大小
  				 
  			 	 PaperSlowSpeedForward(PFP,1);//慢速走纸1步
  			   PaperHold(0);//走纸相位保持	
  				 CarriageSpeedUpRightToLeft(PhaseDirectionSwitch(CLRP));//左加速12步
  				 CarriageConstantSpeedRightToLeft(CRLP,XBYTE[nextposition]+2);//左常速2步
				 	 while(prow->printrowcount!=0)
				 	 {
				 	 		CarriageRightToLeft(CRLP);
				 	 		delay(15);
				 	 		for(i=0;i<2;i++)
				 	 		{
				 	 			PrintDrive(XBYTE[prow->printrowaddr],35);
				 	 			delay(4);
				 	 			prow->printrowaddr++;
				 	 		}
				 	 		prow->printrowcount--;
				 	 }
				   CarriageSpeedDownRightToLeft(CRLP);//左减速12步
  				 CarriageSpeedUpLeftToRight(PhaseDirectionSwitch(CRLP));//右加速12步
  				 CarriageConstantSpeedLeftToRight(CLRP,XBYTE[nextposition]+2);//右常速2步
  				 CarriageConstantSpeedLeftToRight(CLRP,stepcount);//右常速X步
  				 CarriageSpeedDownLeftToRight(CLRP);//右减速12步
  			}
  			else//汉字双向打印
  			{
						prow->printrowaddr=rowbufdataaddr+421+rowdata->count;//偶数行缓冲地址385
				 	 	prow->printrowcount=stepcount;//偶数行缓冲大小
				 	 	CarriageConstantSpeedRightToLeft(CRLP,2);//左常速2步
				 	 	CarriageSpeedDownRightToLeft(CRLP);//左减速12步
				 	 	CarriageHold(600);
  			 		PaperSlowSpeedForward(PFP,1);//慢速走纸1步
  			 		PaperHold(0);//走纸相位保持
  					CarriageSpeedUpLeftToRight(PhaseDirectionSwitch(CRLP));//右加速12步
  					CarriageConstantSpeedLeftToRight(CLRP,2);//右常速2步
				 		while(prow->printrowcount!=0)
				 		{
				 				CarriageLeftToRight(CLRP);
				 				delay(30);
				 				for(i=0;i<2;i++)
				 				{
  			         	PrintDrive(XBYTE[prow->printrowaddr],35);
				 					delay(4);
				 					prow->printrowaddr--;
				 				}
				 				prow->printrowcount--;
				 		}
  			}
  	}		
  	CarriageHold(0);//字车相位保持
}	

/*******************************************************************************
*	Function Name	 :CarriageLeftToRight
*	Description		 : 字车电机右进
*	Input					 : u8	PhaseIn									 
*	Return				 : CurrentPhase	---0~3
*******************************************************************************/
u8	CarriageLeftToRight(u8 PhaseIn)
{
		u8	phase;
		switch(PhaseIn)
		{
				case 0:{	 
								 CarriagePhase0;
								 break;}
				case 1:{	
								 CarriagePhase1;
								 break;}
				case 2:{	 
								 CarriagePhase2;
								 break;}
				case 3:{	 
								 CarriagePhase3;
								 break;}
		}
		CarriageION3;
		if(PhaseIn==3)
		phase=0;
		else
		phase=PhaseIn+1;
		CLRP=phase;
		return	phase;
}
/*******************************************************************************
*	Function Name	 :CarriageSpeedUpLeftToRight
*	Description		 : 字车电机右加速
*	Input					 : u8 PhaseIn								 
*	Return				 : CurrentPhase	---0~3
*******************************************************************************/
void	CarriageSpeedUpLeftToRight(u8 PhaseIn)
{
		u8	i,phase;
		for(i=0;i<12;i++)
		{
				phase=(i+PhaseIn)%4;
				CarriageLeftToRight(phase);
				delay(ACCTime[i]);
		}		
}
/*******************************************************************************
*	Function Name	 :CarriageSpeedDownLeftToRight
*	Description		 : 字车电机右减速
*	Input					 : u8 PhaseIn								 
*	Return				 : CurrentPhase	---0~3
*******************************************************************************/
void	CarriageSpeedDownLeftToRight(u8 PhaseIn)
{
		u8	i,phase;
		for(i=0;i<12;i++)
		{
				phase=(i+PhaseIn)%4;
				CarriageLeftToRight(phase);
				delay(DECTime[i]);
		}		
}
/*******************************************************************************
*	Function Name	 :CarriageConstantSpeedLeftToRight
*	Description		 : 字车电机右常速
*	Input					 : u8 PhaseIn,u8	stepcount								 
*	Return				 : CurrentPhase	---0~3
*******************************************************************************/
void	CarriageConstantSpeedLeftToRight(u8 PhaseIn,u8	stepcount)
{
		u8	i,phase;
		for(i=0;i<stepcount;i++)
		{
				phase=(i+PhaseIn)%4;
				CarriageLeftToRight(phase);
				delay(105);//105
		}		
}
/*******************************************************************************
*	Function Name	 :CarriageSlowSpeedLeftToRight
*	Description		 : 字车电机右慢速,未满24步
*	Input					 : u8 PhaseIn,u8	stepcount								 
*	Return				 : CurrentPhase	---0~3
*******************************************************************************/
void	CarriageSlowSpeedLeftToRight(u8 PhaseIn,u8	stepcount)
{
		u8	i,phase;
		for(i=0;i<stepcount;i++)
		{
				phase=(i+PhaseIn)%4;
				CarriageLeftToRight(phase);
				delay(500);
		}		
}
/*******************************************************************************
*	Function Name	 :CarriageRightToLeft
*	Description		 :字车电机左进---单向打字方向//字车传感器即为左
*	Input			 		 :u8	PhaseIn
*	Return			   :CurrentPhase---0~3
*******************************************************************************/
u8	CarriageRightToLeft(u8 PhaseIn)
{
		u8	phase;
		switch(PhaseIn)
		{
				case 0:{	 
								 CarriagePhase3;
								 break;}
				case 1:{	
								 CarriagePhase2;