pc_comm.c

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

}
#endif /* End SCANNER */

/*-----------------------------------------------------------------------*
					System parameter up -load.
 *-----------------------------------------------------------------------*/
void Do_Sys_Para_Up(void)
{
	SYSFLAGDEF Sys_Flag;

	if(Data_Len != 0)
	{
		Send_Error_Info(NOT_MATCH_FORMAT);
		return;
	}
	Send_Buff[0] = SYS_PARA_UP;
	Send_Buff[1] = SYS_PARA_LEN;
	Sys_Flag.SF1.datefmt 				= 		sysflag->datefmt;
	Sys_Flag.SF1.sysdots 				= 		sysflag->sysdots;
	Sys_Flag.SF1.xCount_round 			= 		sysflag->xCount_round;
	Sys_Flag.SF1.tax_round 				= 		sysflag->tax_round;
	Send_Buff[2] = Sys_Flag.SF;
	Sys_Flag.SF2.clerk_mode				=		sysflag->clerk_mode;
	Sys_Flag.SF2.zero_skip				= 		sysflag->zero_skip;
	Sys_Flag.SF2.prn_table_detail		=		sysflag->prn_table_detail;
	Sys_Flag.SF2.z_reset_rcpt_no		=		sysflag->z_reset_rcpt_no;
	Sys_Flag.SF2.Tax_System			=		sysflag->Tax_System;
	Sys_Flag.SF2.tax_shift_mode		=		sysflag->tax_shift_mode;
	Sys_Flag.SF2.Prn_Bar_Flag			=		sysflag->Prn_Bar_Flag;
	Sys_Flag.SF2.check_clerk			=		sysflag->check_clerk;
	Send_Buff[3] = Sys_Flag.SF;
	Sys_Flag.SF3.Subt_PressPrn				= 		sysflag->Subt_PressPrn;
	#ifdef STOCK		/* Support the PLU stock function */
	Sys_Flag.SF3.PLU_Stock_Flag		=		sysflag->PLU_Stock_Flag;
	#endif /* End STOCK */
	Sys_Flag.SF3.BackLight				=		sysflag->BackLight;
	Sys_Flag.SF3.NS_switch				=		sysflag->NS_switch;
	Sys_Flag.SF3.RPLDP_flag				=		sysflag->RPLDP_flag;
	Sys_Flag.SF3.dept_shift				=		sysflag->dept_shift;
	Sys_Flag.SF3.Rcpt_prn			=		sysflag->Rcpt_prn;
	Sys_Flag.SF3.fl_wmotor				=		sysflag->fl_wmotor;
	Send_Buff[4] = Sys_Flag.SF;
	Sys_Flag.SF4.Btm_Msg_Flag			=		sysflag->Btm_Msg_Flag;
	#ifdef SCANNER		/* Support the scanner function */
	Sys_Flag.SF4.Input_Bar_Mode		=		sysflag->Input_Bar_Mode;
	#endif /* End SCANNER */
	Sys_Flag.SF4.soft_lock_flag		=		sysflag->soft_lock_flag;
	#ifdef AUTO_PER	/* Support the auto percent function */
	Sys_Flag.SF4.Auto_Per_Use_Flag	=		sysflag->Auto_Per_Use_Flag;
	Sys_Flag.SF4.Auto_Per_Prn_Flag	=		sysflag->Auto_Per_Prn_Flag;
	#else
	Sys_Flag.SF4.Auto_Per_Use_Flag	=	0;
	Sys_Flag.SF4.Auto_Per_Prn_Flag	=	0;
	#endif /* End SCANNER */
	#ifdef ELEC_JRNL	/* Support the electronic journal function */
	Sys_Flag.SF4.Elec_Jrnl_VAT_Flag	=		sysflag->Elec_Jrnl_VAT_Flag;
	#endif /* End ELEC_JRNL */
	#ifdef VER_RSNT 	/* Support the restaurant function */
	Sys_Flag.SF4.Waiter_Must_Flag		=		sysflag->Waiter_Must_Flag;
	Sys_Flag.SF4.Waiter_Sure_Flag		=		sysflag->Waiter_Sure_Flag;
	#endif /* End VER_RSNT */
	Send_Buff[5] = Sys_Flag.SF;
	Sys_Flag.SF5.Udt_Stock_Mode		=		sysflag->Udt_Stock_Mode;
	Sys_Flag.SF5.zero_trans_flag		=		sysflag->zero_trans_flag;
	Sys_Flag.SF5.kp_font					=		kp_font;
	Sys_Flag.SF5.LogoPosi_Flag			=		sysflag->LogoPosi_Flag;
	Sys_Flag.SF5.PrnAdj_Flag			=		sysflag->PrnAdj_Flag;
	Send_Buff[6] = Sys_Flag.SF;
	
	Sys_Flag.SF6.Log_Atv_Flag			=		sysflag->Log_Atv_Flag;
//	Sys_Flag.SF6.Compulsory_clerk		=		sysflag->Compulsory_clerk;
	Sys_Flag.SF6.Security				=		sysflag->Security;
	Sys_Flag.SF6.prn_tab_pre_posi		=		sysflag->prn_tab_pre_posi;
	Send_Buff[7] = Sys_Flag.SF;

	Long2Bcd(Send_Buff+10,sysflag->McheNum,2);
	Long2Bcd(Send_Buff+12,sysflag->RcptNum,2);
	Long2Bcd(Send_Buff+14,sysflag->HaloNum,5);
	Send_Buff[19] = (((sysflag->CurrLogoNo)/10)<<4)|((sysflag->CurrLogoNo%10));
	Send_Buff[20] = (((sysflag->wgt_bar.id)/10)<<4)|(((sysflag->wgt_bar.id)%10));
	Send_Buff[21] = sysflag->wgt_bar.len;
	Send_Buff[22] = sysflag->wgt_bar.flag;
	Send_Buff[23] = ((sysflag->Dept_Shift_Inc/10)<<4)|(sysflag->Dept_Shift_Inc%10);
	Long2Bcd(Send_Buff+24, sysflag->top_cash_ttl, 4);
	Send_Buff[28] = ((sysflag->LineFeedCnt/10)<<4)|(sysflag->LineFeedCnt%10);

	CalCS(Send_Buff+2, SYS_PARA_LEN, &Check_Sum);
	Send_Buff[29] = Check_Sum;
	Write_Head();
	Wr_Str_Uart(COMM_PORT, Send_Buff, 2+SYS_PARA_LEN+1);
}

/*-----------------------------------------------------------------------*
					Clerk parameter up -load.
 *-----------------------------------------------------------------------*/
void Do_Clerk_Up(void)
{
	byte i;
	byte j;
	byte idx;
	CLERK_STRU *clerk_stru;

	if(Data_Len != 1)
	{
		Send_Error_Info(NOT_MATCH_FORMAT);
		return;
	}
	idx = Data_Area[0];
	if((idx > Max_Clerk_No) || (idx == 0))
	{
		Send_Error_Info(NOT_MATCH_FORMAT);
		return;
	}
	idx --;

	Send_Buff[0] = CLERK_UP;
	Data_Len = COMM_CLERK_NUM * sizeof(CLERK_STRU);
	Send_Buff[1] = Data_Len;
	clerk_stru = (CLERK_STRU *)(Send_Buff+2);
	for(i = 0, j = idx; i < COMM_CLERK_NUM; i ++, j ++)
	{
		if(j < Max_Clerk_No)
		{
			memcpy(clerk_stru[i].Description, clerk[j].desc, MAX_DESC_LEN);
			Long2Bcd(clerk_stru[i].Sec_CODE, clerk[j].secret, 2);
		}
		else
		{
			memset(&(clerk_stru[i]), 0, sizeof(CLERK_STRU));
		}
	}
	CalCS(Send_Buff+2, Data_Len, &Check_Sum);
	Send_Buff[2 + Data_Len] = Check_Sum;

	Write_Head();
	Wr_Str_Uart(COMM_PORT, Send_Buff, 2+Data_Len+1);
}

/*-----------------------------------------------------------------------*
					Total description up -load.
 *-----------------------------------------------------------------------*/
void Do_Ttl_Desc_Up(void)
{
	byte i;
	char *p;

	if(Data_Len != 0)
	{
		Send_Error_Info(NOT_MATCH_FORMAT);
		return;
	}
	Send_Buff[0] = TTL_DESC_UP;
	Data_Len = (MAX_CHECK_NUM+MAX_CHARGE_NUM)*MAX_DESC_LEN;
	Send_Buff[1] = Data_Len;
	p = (char *)(Send_Buff+2);
	for(i = 0; i < MAX_CHECK_NUM; i ++)
	{
		memcpy(p, charge[i], MAX_DESC_LEN);
		p += MAX_DESC_LEN;
	}
	for(i = 0; i < MAX_CHARGE_NUM; i ++)
	{
		memcpy(p, check[i], MAX_DESC_LEN);
		p += MAX_DESC_LEN;
	}
	CalCS(Send_Buff+2, Data_Len, &Check_Sum);
	Send_Buff[2 + Data_Len] = Check_Sum;
	Write_Head();
	Wr_Str_Uart(COMM_PORT, Send_Buff, 2+Data_Len+1);
}

/*-----------------------------------------------------------------------*
					Refund parameter up-load.
 *-----------------------------------------------------------------------*/
void Do_Rfnd_Up(void)
{
	char *p;

	if(Data_Len != 0)
	{
		Send_Error_Info(NOT_MATCH_FORMAT);
		return;
	}
	Send_Buff[0] = RFND_UP;
	Data_Len = MAX_DESC_LEN+3+1;
	Send_Buff[1] = Data_Len;
	p = (char *)(Send_Buff + 2);
	memcpy(p, refund.desc, MAX_DESC_LEN);
	p += MAX_DESC_LEN;
	Long2Bcd((byte *)p, refund.price, 3);
	p += 3;
	* p++ = refund.flag;
	CalCS(Send_Buff+2, Data_Len, &Check_Sum);
	* (byte *)p = Check_Sum;
	Write_Head();
	Wr_Str_Uart(COMM_PORT, Send_Buff, 2+Data_Len+1);
}

/*-----------------------------------------------------------------------*
					Welcome message up-load.
 *-----------------------------------------------------------------------*/
void Do_Wlcm_Msg_Up(void)
{
	byte i;
	byte idx;
	char *p;

	if(Data_Len != 1)
	{
		Send_Error_Info(NOT_MATCH_FORMAT);
		return;
	}
	idx = Data_Area[0];
	if(idx > 1)
	{
		Send_Error_Info(NOT_MATCH_FORMAT);
		return;
	}
	idx *= 3;
	Send_Buff[0] = WLCM_MSG_UP;
	Data_Len = MSG_HEAD_LINES*(2+MAX_PRN_LEN*2)/2;
	Send_Buff[1] = Data_Len;
	p = (char *)(Send_Buff + 2);
	for(i = 0; i < MSG_HEAD_LINES/2; i ++)
	{
		memcpy(p, Wlcm_Msg[i+idx], 2+MAX_PRN_LEN*2);
		p += 2+MAX_PRN_LEN*2;
	}
	CalCS(Send_Buff+2, Data_Len, &Check_Sum);
	*p = Check_Sum;
	Write_Head();
	Wr_Str_Uart(COMM_PORT, Send_Buff, 2+Data_Len+1);
}

/*-----------------------------------------------------------------------*
					Trailer message up -load.
 *-----------------------------------------------------------------------*/
void Do_Botm_Msg_Up(void)
{
	byte i;
	byte idx;
	char *p;

	if(Data_Len != 1)
	{
		Send_Error_Info(NOT_MATCH_FORMAT);
		return;
	}
	idx = Data_Area[0];
	if(idx > 1)
	{
		Send_Error_Info(NOT_MATCH_FORMAT);
		return;
	}
	idx *= 3;
	Send_Buff[0] = BOTM_MSG_UP;
	Data_Len = MSG_BTM_LINES * (2+MAX_PRN_LEN*2) / 2;
	Send_Buff[1] = Data_Len;
	p = (char *)(Send_Buff + 2);
	for(i = 0; i < MSG_BTM_LINES/2; i ++)
	{
		memcpy(p, Btm_Msg[i+idx], 2+MAX_PRN_LEN*2);
		p += 2+MAX_PRN_LEN*2;
	}
	CalCS(Send_Buff+2, Data_Len, &Check_Sum);
	*p = Check_Sum;
	Write_Head();
	Wr_Str_Uart(COMM_PORT, Send_Buff, 2+Data_Len+1);
}

/*-----------------------------------------------------------------------*
					Department parameter up -load.
 *-----------------------------------------------------------------------*/
void Do_Dept_Up(void)
{
	byte i;
	byte j;
	byte idx;
	DEPT_STRU *dept_stru;

	if(Data_Len != 1)
	{
		Send_Error_Info(NOT_MATCH_FORMAT);
		return;
	}
	idx = Data_Area[0];
	if((idx > Max_Dept_No) || (idx == 0))
	{
		Send_Error_Info(NOT_MATCH_FORMAT);
		return;
	}
	if(idx > MAX_REL_DEPT_CNT)
	{
		Send_Error_Info(NOT_MATCH_FORMAT);
		return;
	}
	idx --;

	Send_Buff[0] = DEPT_UP;
	Data_Len = COMM_DEPT_NUM * sizeof(DEPT_STRU);
	Send_Buff[1] = Data_Len;
	dept_stru = (DEPT_STRU *)(Send_Buff+2);
	for(i = 0, j = idx; i < COMM_DEPT_NUM; i ++, j ++)
	{
		if(j < Max_Dept_No)
		{
			Long2Bcd(dept_stru[i].Pre_Price, dept[j].price, 4);
			#ifdef AUTO_PER		/* Support the department auto percent function */
			Long2Bcd(dept_stru[i].Auto_Per_Rate, dept[j].per_rate, 3);
			#else
			memset(dept_stru[i].Auto_Per_Rate, 0, 3);
			#endif /* End AUTO_PER */
			dept_stru[i].Attribute[0] = dept[j].pflag;
			dept_stru[i].Attribute[1] = dept[j].group;
			dept_stru[i].Attribute[1] |= (dept[j].Hdlo)<<4;
			#ifdef AUTO_PER		/* Support the department auto percent function */
			dept_stru[i].Attribute[2] = dept[j].per_flag;
			#else
			dept_stru[i].Attribute[2] = 0;
			#endif /* End AUTO_PER */
			#ifdef VER_RSNT		/* Support the restaurant function */
			dept_stru[i].Attribute[2] |= (dept[j].send_kp_flag)<<4;
			#endif /* End VER_RSNT */
			memcpy(dept_stru[i].Desc, dept[j].desc, MAX_DESC_LEN_EX+1);
		}
		else
		{
			memset(&(dept_stru[i]), 0, sizeof(DEPT_STRU));
		}
	}
	CalCS(Send_Buff+2, Data_Len, &Check_Sum);
	Send_Buff[2+Data_Len] = Check_Sum;

	Write_Head();
	Wr_Str_Uart(COMM_PORT, Send_Buff, 2+Data_Len+1);
}

/*-----------------------------------------------------------------------*
					Percent parameter up -load.
 *-----------------------------------------------------------------------*/
void Do_Per_Up(void)
{
	byte i;
	PER_STRU *per_stru;

	if(Data_Len != 0)
	{
		Send_Error_Info(NOT_MATCH_FORMAT);
		return;
	}
	Send_Buff[0] = PER_UP;
	Data_Len = MAX_PER_NUM*sizeof(PER_STRU);
	Send_Buff[1] = Data_Len;
	per_stru = (PER_STRU *)(Send_Buff+2);
	for(i = 0; i < MAX_PER_NUM; i ++)
	{
		Long2Bcd(per_stru[i].Rate, percent[i].rate, 4);
		per_stru[i].Attr = percent[i].flag;
		per_stru[i].Attr |= (percent[i].round) << 4;
		memcpy(per_stru[i].Desc, percent[i].desc, MAX_DESC_LEN);
	}
	CalCS(Send_Buff+2, Data_Len, &Check_Sum);
	Send_Buff[2+Data_Len] = Check_Sum;
	Write_Head();
	Wr_Str_Uart(COMM_PORT, Send_Buff, 2+Data_Len+1);
}

/*-----------------------------------------------------------------------*
					Single PLU up-load.
 *-----------------------------------------------------------------------*/
void Do_Sngl_PLU_Up(void)
{
	int idx;
	PLU_STRU *plu_stru;

	if(Data_Len != 2)				/* The data's length must 2 */
	{
		Send_Error_Info(NOT_MATCH_FORMAT);
		return;
	}
	idx = (int)(*((int *)&Data_Area));				/* Get the PLU index number */
	if((idx > Max_Plu_No) || (idx <= 0))
	{
		Send_Error_Info(NOT_MATCH_FORMAT);
		return;
	}
	idx --;
	Send_Buff[0] = SNGL_PLU_UP;
	Data_Len = sizeof(PLU_STRU);						/* The send data area's length */
	Send_Buff[1] = Data_Len;
	plu_stru = (PLU_STRU *)(Send_Buff+2);
	#ifdef SCANNER 		/* Support the scanner function */
	memcpy(plu_stru->Bar_Code, plu[idx].barcode, BAR_BUFF_LEN);
    #endif /* End SCANNER */
	plu_stru->Dept_link = plu[idx].plink;
    #ifdef REST_PLU_FUNC
	plu_stru->Attribute = plu[idx].attr;
    #endif
	Long2Bcd(plu_stru->Pre_Price, plu[idx].price, 3);
	memcpy(plu_stru->Desc, plu[idx].desc, MAX_DESC_LEN_EX+1);
	CalCS((byte *)plu_stru, Data_Len, &Check_Sum);
	Send_Buff[2+Data_Len] = Check_Sum;

	Write_Head();
	Wr_Str_Uart(COMM_PORT, Send_Buff, 2+Data_Len+1);
}


#ifdef SCANNER 		/* Support the scanner function */
/*------------------------------------------------------------------------*
				Single PLU download index table update.
 *------------------------------------------------------------------------*/
//void Sngl_PLU_Index_Update(void)
//{
//	int i;
//
//	for(i = 0; i < Length; i ++)
//	{
//		SC_UpdateIndex(OldPosi[i], (NewPosi[i]-1));
//	}
//	Length = 0;
//}
#endif /* End SCANNER */


/*------------------------------------------------------------------------*
				Full report up-load.
 *------------------------------------------------------------------------*/
void Do_Full_Rpt_Up(void)
{
	byte i;
	FULL_RPT_DEF *report_stru;
	REPORT *rep;

	if(Rpt_Data_Len != 0)
	{
		Send_Error_Info(NOT_MATCH_FORMAT);
		return;
	}

	Send_Buff[0] = Comd_Type;
	Rpt_Data_Len = sizeof(FULL_RPT_DEF);
	*((word *)(Send_Buff+1)) = Rpt_Data_Len;
	if((Comd_Type == DAILY_RPT_UP_X) || (Comd_Type == DAILY_RPT_UP_Z))		/* The daily full report up-load */
		rep = &report;
	else				/* The Period to date full report up-load */
		rep = &PTD_report;
	report_stru = (FULL_RPT_DEF *)(Send_Buff+3);

	report_stru->NetAmt 					= 		rep->NetAmt;
	report_stru->NetSale 				= 		rep->NetSale;
	report_stru->CashTotal 				= 		rep->CashTotal;
	report_stru->MiscTotal 				= 		rep->MiscTotal;
	memcpy(report_stru->CheckTotal, rep->CheckTotal, MAX_CHECK_NUM*sizeof(long));
	memcpy(report_stru->TVATAble, rep->TVATAble, (MAX_VAT_NU