iccard.c

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

	}
//	enint();
	Flash_CS = 1;
}


/********************************************************************************
* 函数说明：	Read the data from the AT45DB041 (attention: len <= 264)
* 输入参数：	len and source address
* 输出参数：	dest string pointer,
* 返回值：	0 is OK.
* 说明: 
********************************************************************************/
byte IC_ReadString(byte *dest, dword srcAddr, WORD len)
{
	WORD bankNo, startAdd;

	bankNo = srcAddr / ROW_SIZE_IC;
	startAdd = srcAddr % ROW_SIZE_IC;
	if (startAdd + len <= ROW_SIZE_IC)
	{
		FlashPageRead(bankNo, startAdd, len, dest);
	}
	else
	{
		FlashPageRead(bankNo, startAdd, ROW_SIZE_IC-startAdd, dest);
		bankNo++;
		dest += ROW_SIZE_IC - startAdd;
		FlashPageRead(bankNo, 0, len-(ROW_SIZE_IC-startAdd), dest);
	}
	return 0;
}

/***************************************************************
* 函数说明: 将一个字符串写入IC Card
* 输入参数: 待写入的字符串, 字符串长度, 字符串存储的起始地址
* 输出参数: 无
* 返回结果: ERROR----- error occur                  
*			OK   ----- read successfully 
* 说明: 解析起始地址为页地址和页内地址,
***************************************************************/
char IC_WriteString(char *src, int len, dword destAddr)
//byte WriteArray(dword destAddr, byte *src, WORD len)
{
	WORD bankNo, startAddr, tmpCtrl, i;
	byte tmpReadBuff[ROW_SIZE_IC];
	byte tmpChkBuff[ROW_SIZE_IC];
	dword tmpSectorAddr;
	WORD j;

	bankNo = destAddr / ROW_SIZE_IC;//here the destAddr is treated as a continuate space, it can't be treated as the address which the IC Card could process directly.
	startAddr = destAddr % ROW_SIZE_IC;
	tmpSectorAddr = (dword)bankNo * ROW_SIZE_IC;//record the start address pointed address

	if ((startAddr+len) <= ROW_SIZE_IC)						//Only in one Bank area.
	{
		FlashPageRead(bankNo, 0, ROW_SIZE_IC, tmpReadBuff);	//Read the contents need update.
		for (i=0; i<len; i++, startAddr++)
		{
			tmpReadBuff[startAddr] = *src++;
		}
		FlashPageWrite(bankNo, 0, ROW_SIZE_IC, tmpReadBuff);//成页写入

		// check 如果新读入的数据与刚才要写入的数据一致,继续.否则,返回IC卡已坏的信息.
		ReadIccard(tmpChkBuff, tmpSectorAddr, ROW_SIZE_IC);
		if (memcmp(tmpChkBuff, tmpReadBuff, ROW_SIZE_IC) != 0)
		{
			return IC_BAD;
		}
		for (i=0; i<ROW_SIZE_IC; i++)
		{
			if (tmpChkBuff[i] != tmpReadBuff[i])
			{
				return (IC_BAD);
			}
		}
	}
	else												//In two Bank area.
	{
		FlashPageRead(bankNo, 0, ROW_SIZE_IC, tmpReadBuff);	//Read the contents need update.
		for (i=0; startAddr < ROW_SIZE_IC; i++, startAddr++)
		{
			tmpReadBuff[startAddr] = *src++;
		}
		tmpCtrl = i;

		FlashPageWrite(bankNo, 0, ROW_SIZE_IC, tmpReadBuff);
		// check sector #1
		ReadIccard(tmpChkBuff, tmpSectorAddr, ROW_SIZE_IC);
		for (i=0; i<ROW_SIZE_IC; i++)
		{
			if (tmpChkBuff[i] != tmpReadBuff[i])
			{
				return (IC_BAD);
			}
		}

		bankNo++;
		tmpSectorAddr += ROW_SIZE_IC;
		FlashPageRead(bankNo, 0, ROW_SIZE_IC, tmpReadBuff);	//Read the contents need update.

		for (i=0; tmpCtrl<len; tmpCtrl++, i++)
		{
			tmpReadBuff[i] = *src++;
		}
		FlashPageWrite(bankNo, 0, ROW_SIZE_IC, tmpReadBuff);
		// check sector #2
		ReadIccard(tmpChkBuff, tmpSectorAddr, ROW_SIZE_IC);
		for (i=0; i<ROW_SIZE_IC; i++)
		{
			if (tmpChkBuff[i] != tmpReadBuff[i])
			{
				return (IC_BAD);
			}
		}
	}
	return 0;
}


/*if the recode of PLU is completed, clear the flag*/
byte IC_Write_End(byte type)
{
	dword ICaddress;
	byte tmpstr[10];

	memset(tmpstr, 0xAA, 5);
	switch(type)
	{
		case 0:
			ICaddress = IC_PLUSINDEX_ADDR;
			break;
		case 1:
			ICaddress = IC_DEPT_ADDR;
			break;
		default:
			ICaddress = IC_SYSFLAG_ADDR;
			break;
	}
	if(IC_WriteString(tmpstr, 5, ICaddress) != OK)
		return IC_BAD;
	return OK;
}


byte IC_Write_Sindex(void)
{
	DWORD ICAddress;
	WORD i;
	byte tmpstr[10];
	byte maxcnt = ROW_SIZE_IC/(sizeof(WORD));

	if(IC_CardInsert() != OK)
		{errorType(ERR_IC_NO_CARD); return NG;}
	//write head
	memset(tmpstr, 0, 10);
	ICAddress = IC_PLUSINDEX_ADDR;
	memset(tmpstr,0x55, 5);
	Long2Bcd(tmpstr+8, Max_Plu_No, 2);
	if(IC_WriteString(tmpstr, 10, ICAddress) != OK)
		{errorType(ERR_IC_BAD); return NG;}

	ICAddress += ROW_SIZE_IC;
		
	for(i = 0; i <  Max_Plu_No ; i += maxcnt)
	{
		if(i+maxcnt > Max_Plu_No)
			maxcnt = Max_Plu_No - i;
		
		if(ICAddress >= IC_PLU_ADDR)//no used , just for protect the PLU paramate
			{errorType(ERR_IC_ADDR_OVER); return NG;}
			
		if(IC_WriteString((byte *)&Sindex [i], maxcnt*(sizeof(WORD)), ICAddress) !=OK)
			{errorType(ERR_IC_BAD); return NG;}
		ICAddress +=  maxcnt*(sizeof(WORD));
	}
	return OK;
}


byte IC_Write_PLU(WORD StartIdx, WORD Numcnt )
{
	dword ICaddress;
	WORD i;
	byte maxcnt = ROW_SIZE_IC/(sizeof(PLU_STRU));//recode the max numcnt of PLU per page.
	PLU_STRU plu_stru[20];

	if(IC_CardInsert() != OK)
		{errorType(ERR_IC_NO_CARD); return NG;}
	
	if(StartIdx + Numcnt > Max_Plu_No)
		{errorType(ERR_DIGIT_ILLEGAL); return NG;}
	
	ICaddress = IC_PLU_ADDR + (dword)(StartIdx*(sizeof(PLU_STRU)));
	for(i = 0; i< Numcnt; i +=maxcnt)
	{
		byte j;
		
		if(ICaddress >= IC_MAX_ADDR)
			{errorType(ERR_IC_ADDR_OVER); return NG;}

		if(i+maxcnt > Numcnt)
			maxcnt = Numcnt-i;
			
		for(j = 0; j<maxcnt; j++)
		{
			WORD tmp = StartIdx + i +j;
			
			memset(&plu_stru[j], 0, sizeof(PLU_STRU));
			
			if(tmp < Max_Plu_No)
			{
			#ifdef SCANNER 		/* Support the scanner function */
				memcpy(plu_stru[j].Bar_Code,plu[tmp].barcode,BAR_BUFF_LEN);
			#endif
				plu_stru[j].Dept_link= plu[tmp].plink;
            #ifdef REST_PLU_FUNC
				plu_stru[j].Attribute = plu[tmp].attr;
            #endif
				Long2Bcd(plu_stru[j].Pre_Price, plu[tmp].price, 3);
				memcpy(plu_stru[j].Desc, plu[tmp].desc, MAX_DESC_LEN_EX+1);
			}
		}
		if(IC_WriteString((byte *)plu_stru, maxcnt*sizeof(PLU_STRU),  ICaddress) != OK)
			{errorType(ERR_IC_BAD); return NG;}
			
		ICaddress += maxcnt*sizeof(PLU_STRU);
			
		Insert_Period((i/100)%10);
		if(i != 0)
			Cancel_Period((i/100 -1)%10);
	}
	
	if(IC_Write_End(0)  != OK)
		{errorType(ERR_IC_BAD); return NG;}
		
	return OK;
}

byte IC_Write_Dept(void)
{
	dword ICaddress;
	byte i;
	byte tmpstr[10];
	DEPT_STRU dept_stru[20];
	byte maxcnt = ROW_SIZE_IC/(sizeof(DEPT_STRU));

	if(IC_CardInsert() != OK)
		{errorType(ERR_IC_NO_CARD); return NG;}

	memset(tmpstr, 0, 10);
	ICaddress = IC_DEPT_ADDR;
	memset(tmpstr,0x55, 5);
	tmpstr[9] = Max_Dept_No;
	if(IC_WriteString(tmpstr, 10, ICaddress) !=OK)
		{errorType(ERR_IC_BAD); return NG;}
		
	ICaddress += ROW_SIZE_IC;

	for(i = 0; i< Max_Dept_No; i += maxcnt)
	{
		byte j;
		
		if(ICaddress >= IC_PLUSINDEX_ADDR)
			{errorType(ERR_IC_ADDR_OVER); return NG;}
			
		if(i+maxcnt >Max_Dept_No)
			maxcnt = Max_Dept_No - i;
		for(j = 0; j < maxcnt; j++)
		{
			byte tmp = i +j ;
			memset(&(dept_stru[j]), 0, sizeof(DEPT_STRU));
			if(tmp < Max_Dept_No)
			{
				Long2Bcd(dept_stru[j].Pre_Price, dept[tmp].price, 4);
				#ifdef AUTO_PER		/* Support the department auto percent function */
				Long2Bcd(dept_stru[j].Auto_Per_Rate, dept[tmp].per_rate, 3);
				#else
				memset(dept_stru[j].Auto_Per_Rate, 0, 3);
				#endif /* End AUTO_PER */
				dept_stru[j].Attribute[0] = dept[tmp].pflag;
				dept_stru[j].Attribute[1] = dept[tmp].group;
				dept_stru[j].Attribute[1] |= (dept[tmp].Hdlo)<<4;
				#ifdef AUTO_PER		/* Support the department auto percent function */
				dept_stru[j].Attribute[2] = dept[tmp].per_flag;
				#else
				dept_stru[j].Attribute[2] = 0;
				#endif /* End AUTO_PER */
				#ifdef VER_RSNT		/* Support the restaurant function */
				dept_stru[j].Attribute[2] |= (dept[tmp].send_kp_flag)<<4;
				#endif /* End VER_RSNT */
				memcpy(dept_stru[j].Desc, dept[tmp].desc, MAX_DESC_LEN_EX+1);
			}
		}
		if(IC_WriteString((char *)dept_stru, maxcnt *sizeof(DEPT_STRU), ICaddress) !=OK)
			{errorType(ERR_IC_BAD); return NG;}

		ICaddress += maxcnt *sizeof(DEPT_STRU);
	}

	if(IC_Write_End(1)  != OK)
		{errorType(ERR_IC_BAD); return NG;}
	
	return OK;
}



/*---------------------------------------------------------------*
	the system paramate needed to be recoded:
	1. sysflag
	2. 	
	
*---------------------------------------------------------------*/
byte IC_Write_Sysflag(void)
{
	dword ICaddress;
	byte tmpstr[10];
	byte tmppage[ROW_SIZE_IC];
	SYSFLAGDEF Sys_Flag;
	
	if(IC_CardInsert() != OK)
		{errorType(ERR_IC_NO_CARD); return NG;}
//head	
	ICaddress = IC_SYSFLAG_ADDR; 
	memset(tmpstr, 0x55, 5);
	if(IC_WriteString(tmpstr, 10, ICaddress) != OK)
		{errorType(ERR_IC_BAD); return NG;}
		
		//major	
	ICaddress += ROW_SIZE_IC;
	memset(tmppage, 0, ROW_SIZE_IC);
	
	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;
	tmppage[0] = 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;
	tmppage[1] = 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;
	tmppage[2] = 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;