fs44b0mu110.c

uClinux基于S3C44B0X打印机驱动

	#define ZiMoBuf_len 32
	#define hzbuf_len  32
	#define ascbuf_len 10
	
  ZiMoBuf = (u8 *)kmalloc(ZiMoBuf_len,GFP_KERNEL);
  hzbuf = (u8 *)kmalloc(hzbuf_len,GFP_KERNEL);
  ascbuf = (u8 *)kmalloc(ascbuf_len,GFP_KERNEL);  
	i = strlen((char *)Str);
	
	iLen = (i > 50)?50:i;		// 25 * 2 = 50
	
	
	memset(PrintBuf, 0, sizeof(PrintBuf));
	
	pos = 0;
	while(*Str)
	{
	
		if (!iLen)
			break;
			
		memset(ZiMoBuf, 0, ZiMoBuf_len);
			
		if (*Str >= 161)
		{	//汉字
			qm = *(Str) - 161;
			wm = *(Str + 1) - 161;
    	ulOffset = (U32)(qm * 94 + wm) * 32;
    	
    	memset(hzbuf, 0, hzbuf_len);
    	for (j = 0; j < 32; j++)
    	{				
				hzbuf[j] = g_auc_HZK16_Dot[ulOffset+j];				
      }        
      Str  += 2;
      iLen -= 2;
      // convert font and put into PrintBuf[][];
      PreHZ( hzbuf, ZiMoBuf);
      PreFont(FONT_HZ16, pos, ZiMoBuf);   	
   		pos += 16;
   			   		
		}
		else
		{	// ASCII 字符			
			qm = *Str;
	   	ulOffset = (U32)(qm) * 10;	
	   		
	   	memset(ascbuf, 0, sizeof(ascbuf));	
   		for (j = 0; j < 8; j ++)
   		{				
				ch = (~Asc79[ulOffset + j]);		
				c = 0;	
				for (t = 0; t < 8; t++)
				{
					if (ch & 0x01)
					{
						c = c | 0x01;					
					}
					c = c<<0x01;
					ch = ch>>0x01;					
				}
				c |= 0x01;	
				ascbuf[j] = c;				
			//ascbuf[j] =	~ASC_font[ulOffset + j];
   		}
   		ascbuf[8] = 0xff;
   		ascbuf[9] = 0xff;	   		
   		Str++;
   		iLen--;
   		// convert font and put into PrintBuf[][];
			PreFont(FONT_ASC79, pos, ascbuf);
			//PreFont(FONT_ASC79, pos, &Asc79[ulOffset]);			
			pos += 10;			
		}
	}
	PrintLen = pos;
	for(u = PrintLen; u < 418; u++)
	{
		PrintBuf[0][u] = 0xff;
		PrintBuf[1][u] = 0xff;
	}			
	kfree(ZiMoBuf);
	kfree(hzbuf);
	kfree(ascbuf);
}

//********************************************************
//********************************************************
static void	MoveToHome(void)
{
	u8	i = 0;
	i = CR_Step;
	if (i < 10)	
	{		
		while(i--)
		{
			CR_Motor_B_Step();
			MdelayTime(4900);
		}
	}
	else
	{
		// first Accelerate  4 steps
		CR_Motor_B_Step();
		MdelayTime(4900);
		CR_Motor_B_Step();
		MdelayTime(1920);
		CR_Motor_B_Step();
		MdelayTime(1470);
		CR_Motor_B_Step();
		MdelayTime(1240);
		
		// second const speed 
		while((i--) - 10)
		{
			CR_Motor_B_Step();
			MdelayTime(1200);
		}
		// third deleration speed 6 steps
		CR_Motor_B_Step();
		MdelayTime(1200);
		CR_Motor_B_Step();
		MdelayTime(1350);	
		
		CR_Motor_B_Step();
		MdelayTime(1560);
		CR_Motor_B_Step();
		MdelayTime(1890);
		CR_Motor_B_Step();
		MdelayTime(2530);
		CR_Motor_B_Step();
		MdelayTime(6000);
	}
}
//********************************************************
//********************************************************
static void	TurnRight(void)
{
	u16	i = 0;
	
	i = CR_Step;
	//printk("CR_Step_R1 = %d\n",CR_Step);
	SetWorkCurrent(CR_MOTOR,NORMAL_CURRENT);
	
	if (i < 32)	
		MoveToHome();
	else
	{
		CR_Acceleration_B();	// 14 steps
		
		CR_ConstSpeed_B(i - 32);
			
		CR_Deleration_B();		//18 steps
	}
	Motor_Off(CR_MOTOR);
	//printk("CR_Step_R2 = %d\n",CR_Step);
}
//********************************************************
//********************************************************
static void	MoveToLeft(void)
{
	u8	i = 0;
	i = CR_MAX_STEP - CR_Step;
	if (i > 10 )	
	{		
		// first Accelerate  4 steps
		CR_Motor_A_Step();
		MdelayTime(4900);
		CR_Motor_A_Step();
		MdelayTime(2200);
		CR_Motor_A_Step();
		MdelayTime(1690);
		CR_Motor_A_Step();
		MdelayTime(1420);
		
		// second const speed 
		while((i--) - 10)
		{
			CR_Motor_A_Step();
			MdelayTime(1250);
		}
		// third deleration speed 6 steps
		CR_Motor_A_Step();
		MdelayTime(1250);
		CR_Motor_A_Step();
		MdelayTime(1350);	
		
		CR_Motor_A_Step();
		MdelayTime(1560);
		CR_Motor_A_Step();
		MdelayTime(1890);
		CR_Motor_A_Step();
		MdelayTime(2530);
		CR_Motor_A_Step();
		MdelayTime(6000);	
	}
	else
	{
		while(i--)
		{
			CR_Motor_A_Step();
			MdelayTime(4900);
		}
	}
}
//********************************************************
//********************************************************
static void	TurnLeft(void)
{
	u16	i = 0;
	
	i = CR_Step;
	//printk("CR_Step_L1 = %d\n",CR_Step);
	SetWorkCurrent(CR_MOTOR,NORMAL_CURRENT);
	if (i > 210)	
		MoveToLeft();
	else
	{
		CR_Acceleration_A();		// 17 steps
		
		CR_ConstSpeed_A(CR_MAX_STEP - i - 32);
			
		CR_Deleration_A();			//15 steps
	}	
	Motor_Off(CR_MOTOR);
	//printk("CR_Step_L2 = %d\n",CR_Step);
}
//********************************************************
//********************************************************
static u8	HeadTempCheck(void)
{
	
	if (rPDATG& HEAD_TEMP_CHECK)
		return	0;	// 打印头温度过高
	else
		return	1;
}
//********************************************************
//********************************************************
static u8	HomeCheck(void)
{	
	if (rPDATG & HOME_CHECK)
	{
	
		//Mdelay1MS(1);
		if (rPDATG & HOME_CHECK)
			return	1;	//打印头位于HOME POSITION
		else
			return	0;	
	}
	else
		return	0;
}
//********************************************************
//go home
//********************************************************
static signed char GoHomePosition(void)
{
	char flag_h;
	char flag_hh;
	int i;
	int g_ucMoveNum;
	char g_ucCount;
	if( HomeCheck() == 1 )
	{
		g_ucCount = 2;
		flag_h = 1;
	}
	else
	{
		g_ucCount = 3;
		flag_h = 0;
	}
	while( g_ucCount-- )
	{
		//printk("g_ucCount = %d\n",g_ucCount);
		SetWorkCurrent(CR_MOTOR,NORMAL_CURRENT);
		g_ucMoveNum = 0;
		//printk("HomeCheck() = %d\n",HomeCheck());
		if( HomeCheck() == 0 )											//向右移动
		{
			//printk("HomeCheck()-%d = 0\n",g_ucCount);
			while( g_ucMoveNum < 8 )                 //加速
			{
				CR_Motor_B_Step();
		    MdelayTime(CR_Acc_B[g_ucMoveNum]);
		    g_ucMoveNum++;
				if( HomeCheck() == 1 )
				{
					break;
				}
			}
			while( 	HomeCheck() != 1 )
			{
				CR_Motor_B_Step();
		    MdelayTime(CR_ConstSpeed);
				if( g_ucMoveNum++ > 239 )
				{
					
					//printk("flag_h1 = %d\n",flag_h);
					
					return -10;
				}
			}
			for(i = 0; i < 10; i++)
			{
				CR_Motor_B_Step();
		    MdelayTime(CR_ConstSpeed);
			}
			g_ucMoveNum = 0;
			while( g_ucMoveNum < 12)                           //向右减速
			{
				CR_Motor_B_Step();
		    MdelayTime(CR_Dec_B[g_ucMoveNum]);
		    g_ucMoveNum++;
			}
		}
		else																									//向左移动
		{
			//printk("HomeCheck()-%d = 1\n",g_ucCount);
			g_ucMoveNum = 0;
			while( g_ucMoveNum < 8 )                            //向左加速
			{
				CR_Motor_A_Step();
		    MdelayTime(CR_Acc_A[g_ucMoveNum++]);
			}
			g_ucMoveNum = 0;
			while( g_ucMoveNum < 40 )
			{
				g_ucMoveNum++;
				CR_Motor_A_Step();
		    MdelayTime(CR_ConstSpeed);
			}
			if( HomeCheck() == 1 )
			{
				//printk("flag_h2 = %d\n",flag_h);
				
				return -10;
			}
		  for(i = 0; i < 10; i++)
			{
				CR_Motor_A_Step();
		    MdelayTime(CR_ConstSpeed);
			}
			g_ucMoveNum = 0;
			while( 	g_ucMoveNum < 12 )
			{
				CR_Motor_A_Step();
		    MdelayTime(CR_Dec_B[g_ucMoveNum]);
		    g_ucMoveNum++;
			}
		}
		Motor_Off(CR_MOTOR);
	}
	//printk("flag_h3 = %d\n",flag_h);
	return 1;
}
/*
static char	GoHomePosition()(void)
{
	//u16 i=0;
 unsigned  int go_timeout = 0;
	SetWorkCurrent(CR_MOTOR,NORMAL_CURRENT);	
	
	if (HomeCheck())
	{
		CR_Step = 0;
		// 向左走52步	
		CR_Acceleration_A();	//17 steps
		CR_ConstSpeed_A(20);
		CR_Acceleration_A();	//15		
		if (HomeCheck())
		{
			return	0;
		}
		else
		{
			CR_Acceleration_B();	//14 steps
			go_timeout = init_timeout;
			while (!HomeCheck())
			{
				CR_ConstSpeed_B(1);
				go_timeout--;
				if(go_timeout <= 0)return -1; 
			}				
		  CR_Step = 22;
		  CR_ConstSpeed_B(4);
		  CR_Deleration_B();	//18 STEPS
		}		
	}
	else
	{		
			CR_Step = CR_MAX_STEP;
			go_timeout = 0x300;
			while (!HomeCheck())
			{			
				CR_Motor_B_Step();
				MdelayTime(2096);
				go_timeout--;
				if(go_timeout <= 0)return -1;
			}		
			CR_Step = 22;
			CR_ConstSpeed_B(4);
			CR_Deleration_B();	//18 STEPS
	}
	Motor_Off(CR_MOTOR);
	return	1;
}
*/
//********************************************************
//********************************************************
static u8	BlackMarkCheck(void)
{
	
	if (rPDATG & BLACK_MARK_CHECK)
		return	1;	//检测到黑标
	else
		return	0;
}
//********************************************************
//********************************************************
static u8	PapeCheck(void)
{
	
	if (rPDATF & PAPE_CHECK)
		return	1;	//检测到有纸
	else
		return	0;	//打印机缺纸
}
//********************************************************
//********************************************************
static void	AutoPapeIn(void)
{
	while(PapeCheck())
	{
		OutPape1Line();
	}	
	OutPape1Line();
}
//********************************************************
//********************************************************

static void	PrintLine(char *Str)
{
	u8 i = 0;
	U16 pri_len ;
	u16 n;
	unsigned long flags;
	PrintPreHandle(Str);
	SetWorkCurrent(CR_MOTOR, NORMAL_CURRENT);
	n = 0;
	//if(PrintLen % 2 == 0)pri_len = PrintLen + 1;
	save_flags(flags);    cli();
	pri_len = PrintLen;
	CR_Acceleration_B();//15
	for(i = 0; i < Right_limit; i++)
	{
		CR_Motor_B_Step();
		Mdelay826US();
	}	
	for (i = Right_limit; i < 209; i++)
	{		
	  CR_Motor_B_Step();
		CPLD_M110_PrintDat_Addr = PrintBuf[0][2*n];
		PrintTriggerPulse();
		Mdelay826US();
		CPLD_M110_PrintDat_Addr = 0xff;
		n++;
	}	
	CR_Deleration_B();//222 + 18 = 240 end
	MdelayTime(CR_Lash);
  
  //CR_Acceleration_A();
	//CR_ConstSpeed_A(209);//209
	//CR_Deleration_A();
	
  CR_Acceleration_A();//17
  
	//CR_Motor_A_Step();	
	for (i = Right_limit; i < 209; i++)
	{				
		//Mdelay200US();
		CR_Motor_A_Step();
		Mdelay413US();
		CPLD_M110_PrintDat_Addr = PrintBuf[0][2*n - 1];
		PrintTriggerPulse();
		//CR_Motor_A_Step();
		Mdelay413US();
		//Mdelay626US();
		n--;
		CPLD_M110_PrintDat_Addr = 0xff;	
	}
	//Mdelay200US();
	for(i = 0; i < Right_limit; i++)
	{
		CR_Motor_A_Step();
		Mdelay826US();
	}	
	CR_Motor_A_Step();
		
	CR_Deleration_A();//222 + 18 = 240 end
	MdelayTime(CR_Lash);

  
	//PF_OUT_HalfDot_B();
	//CR_Acceleration_A();
	//CR_ConstSpeed_A(209);//209
	//CR_Deleration_A();
	n = 0;
	PF_OUT_HalfDot_B();
	CR_Acceleration_B();
	for(i = 0; i < Right_limit; i++)
	{
		CR_Motor_B_Step();