prn_drv.c

一款收款机C源代码！因为是几年前的代码了

//		else
		{
			Ta2_Intvl = th_temp_get();
			if (Ta2_Intvl == NG)
			{
				Ta2_Intvl = 800 * FOSC / 8;
			}
			ta4s = 0;
//			ta4 = 500 * FOSC / 8;
			ta4 = Ta2_Intvl;
			ta4s = 1;
		}
	}
}

/**************************************************************************************
* Describe：	DMA0 ISR
* Input ：	void
* Output：	void
* return：	void
*	DMA0	interrupt
*	Used for send the thermal dot data to thermal printer, when this interrupt occurs,
*	the whole data finish sending.
*	Next latch the data and heating it.
*	03-4-2 17:02
***************************************************************************************/
void Dma0Isr( void )
{
	STB1 = 0;
	Prn_Latch = 0;
	Prn_Stat = PRN_HEAT;						// Next status is heating.
	Prn_Latch = 1;

	Ta2_Intvl = th_temp_get();
	if (Ta2_Intvl == NG)
	{
		Prn_Stat = PRN_PROTECT;					// 过热保护.
		STB1 = STB2 = 1;
		return;
	}
	ta4s = 0;
//	ta4 = 500 * FOSC / 8;
	ta4 = Ta2_Intvl;
	ta4s = 1;									// Start timer A2
}

/******************************************************************************
* Describe：	Timer A2 initial function, use to heat printer
* Input ：	void
* Output：	void
* return：	void
******************************************************************************/
void InitialHeatTimer(void)
{
	// set timer A2 work mode
	ta2mr = 0x40;						// f8, disable gate, timer mode
	// set timer A2 initial value
	ta2 = HEAT_TM * FOSC / 8;				// 10M xtal, 800ns * 1250 = 1 ms
	// enable timer A2 downflow interrupt
	ta2ic = 0x03;
	ta2s = 0;							// Start timer A2
}

/******************************************************************************
* Describe：	Timer A4 initial function
* Input ：	void
* Output：	void
* return：	void
******************************************************************************/
void InitialFeedTimer(void)
{
	ta4mr = 0x40;						// f8, disable gate, timer mode
	ta4 = 1000 * FOSC / 8;				// 10M xtal, 800ns * 1250 = 1 ms
	ta4ic = 0x03;						// enable timer A4 downflow interrupt
	ta4s = 1;							// Start timer A4
}

/******************************************************************************
* Describe：	Initial DMA0 use for UART4 Transfer
* Input ：	void
* Output：	void
* return：	void
******************************************************************************/
void InitDMA0( void )
{
	DEBUG_HW(return;)
	dm0ic = 0x03;					//Interrupt control register.
	dm0sl = 0x96;					// UART4 Transfer(Request Cause Set)
#pragma ASM
	ldc _dmaDataAddr, dma0			//Source data Adress.
	ldc #02fah, dsa0				//Destination Adress.
	ldc _dmaTranLen, dct0
	ldc #09h, dmd0					//One-Shot mode.
#pragma ENDASM
}

/************************************************************************
*	Initialize the Printer using parameter, Including:
*	a.	DMA initialize mode set.
*	b.	Step Feed timmer initialize .
*	c.	Heat timmer initialize.
*	d.	STB port mode set.
*	03-4-7 9:59
************************************************************************/
void Init_Prn(void)
{
	InitialFeedTimer();
	InitialHeatTimer();
	InitDMA0();
	Init_ADC();

	STB1_DIR = STB2_DIR = 1;
	STB1 = STB2 = 1;
	PRN_PEND_DIR = 0;
	VPR_OFF();
	prc2 = 1;
	Prn_Latch_DIR = 1;
	prc2 = 1;
	Prn_CLK_DIR = 1;
	prc2 = 1;
	Prn_DI_DIR = 1;
	OPEN_JOURNAL_PRN();
	PRN_TH_DIR = 0;
	prc2 = 1;
	PRN_VCC_DIR = 1;
	PrnVccOff();

	WMTOR_DIR = 1;
	WMTOR = 0;

	STEP_OFF();
	
	Prn_Stat = PRN_IDLE;
	phead = prear = 0;
	clr_Prn_Buf();
	*(CHR*)&prn_flag = 0;
}
/*---------------------------------------------------------------------------------------------
*	According to the ADC convert result, to get the register load counter
*
*	If the thermal head temprature is high or low of the result, then deal it with the
*	High or broke.
*----------------------------------------------------------------------------------------------*/
//WORD	th_temp_get(void)
//{
//	CHR	th_data;
//	WORD	work = 0;
//	byte i;
//
////	return(600);
//	th_data = (char)ad0;
//
//	if (th_data > 0xf5)
//	{	/*Temp. under -5 */
//		/*   b3:thermistor sensor break	*/
//		for (i=0; i<30; i++);
//		if ((byte)ad0 > 0xf5)
//		{
//			prn_flag.prn_break = 0x01;
//			return(NG);
//		}
//	}
//
//	if ( th_data > 210 )
//	{/*Temp. 0 => 10*/
//		work = HEAT_1000;						//1000 msecond
//	}
//	else if (th_data > 194)
//	{/*Temp. 11 => 20*/						//800 msecond
//		work = HEAT_800;
//	}
//	else if (th_data > 184)					//750msec
//	{/*Temp. 21 => 30*/
//		work = HEAT_750;
//	}
//	else if (th_data > 174)					//700msec
//	{/*Temp. 31 => 40*/
//		work = HEAT_700;
//	}
//	else if ( th_data > 164 )				//600msec
//	{/*Temp. 41 => 50*/
//		work = HEAT_600;
//	}
////	else if (th_data > 154 )				//500 msecond
//	else
//	{/*Temp. 51 => 60 */
//		work = HEAT_500;
//	}
//
//	return(work);
//}

/******************************************************************************
* Describe：when paper end, some of report or receipt need print last line again
* Input ：	void
* Output：	void
* return：	void
* Caution:	需考虑掉电 ?
******************************************************************************/
byte Prn_Last_Line_Paper_End(void)
{
	byte idx = 0x00, idx1;
	byte i, j;
	byte tmphead;
	byte bufBackFlag = 0;
	byte tmpBKphead;
	byte backphead, backprear;
	byte paperEndFlag = 0;

	// judge whether feed or print
	// 不管该行是否已经全部打完与否,只要没有走纸,均重打
	idx = prear;
	tmphead = phead;
	for (i=0; i<49; i++)
	{
		if (idx == tmphead)
		{
			// backup dot buffer
			for (j=0; j<49; j++)
			{
				memcpy(tmpDotBuffer[48-j], Prn_Dot_Ring[phead-1-j], 55);
			}
			// copy bkdotbuff to dot buffer
			tmpBKphead = bkphead;
			for (j=0; j<49; j++)
			{
				if (tmpBKphead == 0)
					tmpBKphead = 48;
				else
					tmpBKphead--;
				memcpy(Prn_Dot_Ring[phead-1-j], bkDotRing[tmpBKphead], 55);
			}
			// reset flag
			tmphead -= 49;
			bufBackFlag = 1;
		}
		idx--;
		if (Prn_Dot_Ring[idx][0] == NM_CHA_SP_CNTR)
		{
			if (i == 0)				// last action is FEED
			{
				if (bufBackFlag == 1)
				{
					// copy data from tmpDotBuffer to Dot buffer
					for (j=0; j<49; j++)
					{
						memcpy(Prn_Dot_Ring[phead-1-j], tmpDotBuffer[48-j], 55);
					}
				}
				return OK;
			}
			backphead = phead;
			backprear = prear;
			idx1 = prear;
			for (j=0; j<49; j++)
			{
				if (Prn_Dot_Ring[idx1][0] == NM_CHA_SP_CNTR)
				{
					break;
				}
				idx1++;
			}
			phead = idx1;
			prear = idx + 1;
			// only for prevent too many error  -- it seems no use
			if (phead >= prear)
			{
				if ((phead - prear) > 48)
					phead = prear + 48;
			}
			else
			{
				if (((phead + 256) - prear ) > 48)
					phead = prear + 48;
			}
			// start one line print
			prn_flag.papr_end = FALSE;
			while (1)
			{
				if( (phead == prear) && ( Prn_Stat == PRN_IDLE))
					break;
				if (PRN_PEND == 1)
				{
					paperEndFlag = 1;
					break;
				}
			}
			prn_flag.papr_end = TRUE;		// stop print
			if (bufBackFlag == 1)
			{
				for (j=0; j<49; j++)
				{
					memcpy(Prn_Dot_Ring[backphead-1-j], tmpDotBuffer[48-j], 55);
				}
			}
			if (paperEndFlag == 0)
			{
				phead = backphead;
				return OK;
			}
			else
			{
				phead = backphead;
				prear = backprear;
				return PAPER_END_ERR;
			}
		}
	}
	if (bufBackFlag == 1)
	{
		for (j=0; j<49; j++)
		{
			memcpy(Prn_Dot_Ring[phead-1-j], tmpDotBuffer[48-j], 55);
		}
	}
	return NG;
}


void Clr_BK_DotBuf(void)
{
	byte i;
	for (i=0; i<49; i++)
	{
		bkDotRing[i][0] = NM_CHA_SP_CNTR;
	}
	bkphead = 0;
}



word heatAddTime;

#define		MAX_HEAT_TIME			300


/*---------------------------------------------------------------------------------------------
*	According to the ADC convert result, to get the register load counter
*
*	If the thermal head temprature is high or low of the result, then deal it with the
*	High or broke.
*----------------------------------------------------------------------------------------------*/
WORD	th_temp_get(void)
{
	CHR	th_data;
	WORD	work = 0;
	byte i;

	if (heatAddTime > MAX_HEAT_TIME)
	{
		heatAddTime = 0;
	}
	
	th_data = (char)ad1;

	if (th_data > 0xf5)
	{	/*Temp. under -5 */
		/*   b3:thermistor sensor break	*/
		for (i=0; i<30; i++);
		if ((byte)ad1 > 0xf5)
		{
			prn_flag.prn_break = 0x01;
			return (NG);
//			return (HEAT_800);
		}
	}

	if ( th_data > 210 )
	{/*Temp. 0 => 10*/
		work = HEAT_1000;						//1000 msecond
	}
	else if (th_data > 194)
	{/*Temp. 11 => 20*/						//800 msecond
		work = HEAT_800;
	}
	else if (th_data > 184)					//750msec
	{/*Temp. 21 => 30*/
		work = HEAT_750;
	}
	else if (th_data > 174)					//700msec
	{/*Temp. 31 => 40*/
		work = HEAT_700;
	}
	else if ( th_data > 164 )				//600msec
	{/*Temp. 41 => 50*/
		work = HEAT_600;
	}
//	else if (th_data > 154 )				//500 msecond
	else
	{/*Temp. 51 => 60 */
		work = HEAT_500;
	}

	return (work + heatAddTime);
}



/******************************************************************************
* Describe：	set printer heat time, user can be add (0 ~ 300)us.
* Input ：	word addTime (Caution: never exceed 300).
* Output：	void
* return：	OK / NG
******************************************************************************/
byte Prn_SetHeatTime(word addTime)
{
	if (addTime > MAX_HEAT_TIME)
	{
		return 0xff;
	}
	heatAddTime = addTime;
	return OK;
}

/******************************************************************************
* Describe：	set printer heat time, user can be add (0 ~ 300)us.
* Input ：	word addTime (Caution: never exceed 300).
* Output：	void
* return：	OK / NG
******************************************************************************/
byte Prn_GetHeatTime(word *addTime)
{
	if (heatAddTime > MAX_HEAT_TIME)
	{
		heatAddTime = 0;
	}
	*addTime = heatAddTime;
	return OK;
}

void LineFeedNoDetectPaper(byte num)
{
	word step = num * (NM_CHA_SP_CNTR * 1.5);
	byte tmp = 0;

	while (1)
	{
		if (step == 0)
		{
			break;
		}
		else if (step > 250)
		{
			step -= 250;
			tmp = 250;
		}
		else
		{
			tmp = step;
			step = 0;
		}
		disint();
		Prn_Stat = PRN_FEED; 
		Ttl_Fd_line = tmp;
		PrnVccOn();
		VPR_ON();
		enint();
	
		while (Ttl_Fd_line);
	}
}

/* Apply one line */
void	apply_one_line(void)
{
	while(phead+(byte)1 == prear);
}

/* Update one line to print */
void	update_one_line(void)
{
	Prn_Dot_Ring[phead][0] = NM_DOT_FD_CNTR;
	phead ++;
}

/* Apply n lines */
void	apply_lines(byte n)
{
	byte	line_i;
	byte	line_idx;

	for(line_i = 0, line_idx = phead + 1; line_i < n; )
	{
		if (line_idx != prear)
		{
			line_idx++;
			line_i++;
		}
	}
}

/* Update n lines to print */
void	update_lines(byte n)
{
	byte	line_i;
	byte	line_idx;

	line_idx = phead + n;
	for(line_i = phead; line_i != line_idx; line_i ++)
		Prn_Dot_Ring[line_i][0] = NM_DOT_FD_CNTR;
	phead += n;
}

///////////////////////////////////////////////////////////////////////////////
// Descript:	initial wind motor
// In Param:	void
// Out Param:	void
// Return:		void
///////////////////////////////////////////////////////////////////////////////
void Prn_InitWind(void)
{
	WMTOR_DIR = 1;
	CloseWindMotor();
}

void CloseWindMotor(void)	
{	
	WMTOR = 0;	
}
void OpenWindMotor(void)	
{	
	WMTOR = 1;	
}

void Prn_SyncMotor(void)
{
}