bct100.c

AT91fr40162的FLASH读写程序

#include "dtm_v3.h"
#include "dtm.h"
#include "externdef.h"
#include <stdio.h>

#define ST_CLOSED	0
#define ST_OPENED	1
#define ST_SAMPLING	2
#define ST_COPYING	3
#define ST_END		4

_BYTE cState;
int iLineCnt;


void BCTWriteReg(_BYTE cOffset, _BYTE cMask, _BYTE cValue);
void BCTSetAddressAndData(_BYTE cAddress,_BYTE cValue);
void BCTSetIO(void);
_BYTE BCTOpen(void);
int BCTClose(void);
U8 BCTReadDPR(void);
int BCTReadScreen(U8 * cpBuffer);
void CorrectImage(_BYTE * cpSourceImage,_BYTE *cpTragetImage);
_BYTE BCTSW1ReadStatus(void);

// 存放BCT寄存器的初始值和当前值
_BYTE BCTRegShadow[6] ={0x00,0x00,0x04,0x04,0x01,0x04};

// *********************************************************************
// 写BCT寄存器,其中：
// cOffset: 为寄存器的地址（偏移）
// cMask:	要写入的寄存器位
// cValus:	要写入继承权的值
// *********************************************************************
void BCTWriteReg(_BYTE cOffset, _BYTE cMask, _BYTE cValue)
{
	_BYTE cNewVal;
	_BYTE cArrOffset;
	
	cArrOffset = cOffset;
	cNewVal = BCTRegShadow[cArrOffset];						// 取寄存器原来的值
	/* set address. CE=0 WE=1 */
    //PIO_CODR = BCT_CE;			// BCT_CE = 0		
    MY_PIO_SODR = BCT_WE;			// BCT_WE = 1		
	// 计算寄存器的值
	cNewVal = (cNewVal & ~cMask) | (cValue & cMask);		// 计算寄存器的新值
	// 放地址
	// 放数据
	BCTSetAddressAndData(cOffset,cNewVal);
	//BCTSetData(cNewVal);
	DelayMCK4(BCT_REG_DELAY);
	
   	//PIO_CODR = BCT_CE;			// BCT_CE = 0		
	/* make a pulse on WE */
    MY_PIO_CODR = BCT_WE;			// BCT_WE = 0		
	DelayMCK4(BCT_WE_DELAY);
    MY_PIO_SODR = BCT_WE;			// BCT_WE = 1	
    //if (cState!=ST_SAMPLING)	
   	//	PIO_SODR = BCT_CE;			// BCT_CE = 1		
	BCTRegShadow[cArrOffset] = cNewVal;						// 保存寄存器当前值
}


void BCTSetAddressAndData(_BYTE cAddress,_BYTE cValue)
{
	_BYTE cByte1,cByte2;
	// 合并地址和数据
	cByte1 = cAddress;
	cByte2 = cValue;
	cByte1 = cByte1 <<4;
	cByte2 = cByte2 | cByte1;
	pCPLD[0x0c] = cByte2;
	// 处理地址的最高位
	cByte1 = cAddress;
	cByte1 &= 0x10;
	if (cByte1!=0) {
    	MY_PIO_SODR = BCT_ABUS4;			// BCT_ABUS4 = 1
    	return;
    }	
	else {
    	MY_PIO_CODR = BCT_ABUS4;			// BCT_ABUS4 = 0
    	return;
    }	
}



// *********************************************************************
// 设置BCT使用的I/O口
// *********************************************************************
void BCTSetIO(void)
{

    // Set BCT D0 - D7 as IO Pin Input
	MY_PIO_PER = BCT_D0|BCT_D1|BCT_D2|BCT_D3|BCT_D4|BCT_D5|BCT_D6|BCT_D7 ;  
	MY_PIO_ODR = BCT_D0|BCT_D1|BCT_D2|BCT_D3|BCT_D4|BCT_D5|BCT_D6|BCT_D7 ;  

    // Set BCT END_SH and SED as IO Pin Input 
	MY_PIO_PER = BCT_END_SH|BCT_SED;  
    MY_PIO_ODR = BCT_END_SH|BCT_SED;
    
    // Set BCT SLEEP as IO Pin Input
    MY_PIO_PER = BCT_SLEEP; 
    MY_PIO_ODR = BCT_SLEEP; 

    // Set BCT DSC, CE, WE as IO Pin OutPut
    MY_PIO_PER = BCT_DSC|BCT_CE|BCT_WE|BCT_RESET; 
    MY_PIO_OER = BCT_DSC|BCT_CE|BCT_WE|BCT_RESET; 

    // Set BCT_ABUS[4:0], BCT_DBUS[3:0] as IO Pin OutPut
    MY_PIO_PER = BCT_ABUS4;	//_MASK|BCT_DBUS_MASK;
    MY_PIO_OER = BCT_ABUS4;	//_MASK|BCT_DBUS_MASK;

    // Set SW1 as IO Pin Input
	MY_PIO_PER = SW1 ;  
	MY_PIO_ODR = SW1 ;  

	// Set CE = H, WE = H, DSC = H
    MY_PIO_SODR = BCT_CE;			// BCT_CE = 1		
    MY_PIO_SODR = BCT_WE;			// BCT_WE = 1		
    MY_PIO_SODR = BCT_DSC;			// BCT_DSC = 1		

    // Set Reset = 0 
    // Delay - BCT_RESET_DELAY
    // Set Reset = 1 
    MY_PIO_SODR = BCT_RESET;			// BCT_RESET = 1		
	DelayMCK4(BCT_RESET_DELAY);
   	MY_PIO_CODR = BCT_RESET;			// BCT_RESET = 0		
	DelayMCK4(BCT_RESET_DELAY);
    MY_PIO_SODR = BCT_RESET;			// BCT_RESET = 1		

	cState = ST_CLOSED;
}



// 初始化BCT
_BYTE BCTOpen(void)
{
	_DWORD wTime,i;
	_DWORD reg32,Tmp;


	/* Initialize BCT-100 */
	/* CE=0, WE=1 */
   	MY_PIO_CODR = BCT_CE;			// BCT_CE = 0		
    MY_PIO_SODR = BCT_WE;			// BCT_WE = 1		
	DelayMCK4(BCT_REG_DELAY);

	/* SLM=1 */
	// Sleep BCT
	BCTWriteReg(BCT_CRH, BCT_CRH_SLM,BCT_CRH_SLM);
 
	/* SLM=0 */
	// Wakeup BCT	
	BCTWriteReg(BCT_CRH, BCT_CRH_SLM,0);

	/* select parallel interface */
	BCTWriteReg(BCT_CSRH, BCT_CSRH_SDOUT,0);

    /* LDS=1, DCI=1, SLM=0 */
	BCTWriteReg(BCT_CRL, BCT_CRL_LDS, BCT_CRL_LDS);
	DelayMCK4(BCT_DCI_DELAY);
	BCTWriteReg(BCT_CRH, BCT_CRH_DCI|BCT_CRH_SLM, BCT_CRH_DCI|0);
	DelayMCK4(BCT_DCI_DELAY);

	/* DCI=0 */
	BCTWriteReg(BCT_CRH, BCT_CRH_DCI, 0);

	/* wait for ENDSH=1 */
	wTime = BCT_INIT_WAIT;
	reg32 = MY_PIO_PDSR;
	Tmp   = reg32&(BCT_END_SH|BCT_SED);
	for (i=0;i<wTime;i++) {
	   if (Tmp==(BCT_END_SH|BCT_SED)) 
	      	return(C_OK);
		wTime--;
		DelayMCK4(1);
		reg32 = MY_PIO_PDSR;
		Tmp   = reg32 & (BCT_END_SH|BCT_SED);
	}
    MY_PIO_SODR = BCT_WE;			// BCT_WE = 1		
   	MY_PIO_SODR = BCT_CE;			// BCT_CE = 1		
	return(C_NOTOK);
}

// 关闭BCT
int BCTClose(void)
{

	cState = ST_CLOSED;
	/* WE=1, CE=1 */
    MY_PIO_SODR = BCT_WE;			// BCT_WE = 1		
   	MY_PIO_SODR = BCT_CE;			// BCT_CE = 1		
	return(C_OK);
}

// 读取DPR的内容,作为函数的返回值返回
_BYTE BCTReadDPR(void)
{
	_BYTE reg8;
	_DWORD reg32;

	/* DSC=0 */
    MY_PIO_CODR = BCT_DSC;
	DelayMCK4(BCT_DSC_DELAY);
	
	reg8=0;
	/* read DRP */
	reg32 = MY_PIO_PDSR;
	if (reg32&BCT_D0) reg8 |= 0x01;
	if (reg32&BCT_D1) reg8 |= 0x02;
	if (reg32&BCT_D2) reg8 |= 0x04;
	if (reg32&BCT_D3) reg8 |= 0x08;
	if (reg32&BCT_D4) reg8 |= 0x10;
	if (reg32&BCT_D5) reg8 |= 0x20;
	if (reg32&BCT_D6) reg8 |= 0x40;
	if (reg32&BCT_D7) reg8 |= 0x80;
	//reg8 = (_BYTE)(reg32);

	/* DSC=1 */
    MY_PIO_SODR = BCT_DSC;
	return(reg8);
}

// 读取传感器采集的指纹图像
int BCTReadScreen(_BYTE * cpBuffer)
{
	int line, time,j;
	_DWORD reg32,Tmp,pAddress=0;

	/* ready for sampling start  */

	if ((BCT_END_SH|BCT_SED)== ((reg32=MY_PIO_PDSR) & (BCT_END_SH|BCT_SED))){
		BCTWriteReg(BCT_CRL, BCT_CRL_PDS|BCT_CRL_LDS,BCT_CRL_PDS|BCT_CRL_LDS);			// PDS = 1,LDS = 1
	}

	Delayms(2);

	for (line=0; line <BCTHEIGHT; line++) {
		time = BCT_SAMPLE_WAIT;
		reg32 = MY_PIO_PDSR;
		Tmp   = reg32 & (BCT_SED|BCT_END_SH);
		while (Tmp!= 0) {
			if( time-- <= 0 ){
			    MY_PIO_SODR = BCT_WE;			// BCT_WE = 1		
			   	MY_PIO_SODR = BCT_CE;			// BCT_CE = 1		
				return (C_NOTOK);
			}
			reg32 = MY_PIO_PDSR;
			Tmp   = reg32 & (BCT_SED|BCT_END_SH);
		}

		//BCTReadLine(cpBuffer + BCTWIDTH*line);
		for(j=0; j<BCTWIDTH; j++)
			cpBuffer[pAddress++]=~(BCTReadDPR());

		reg32 = MY_PIO_PDSR;
		if (reg32 & BCT_END_SH){
			/* End of screen */
			break;
		}

		/* Start next line */
		BCTWriteReg(BCT_CRL, BCT_CRL_LDS|BCT_CRL_PDS, BCT_CRL_LDS);
	}
	return(C_OK);
}


void CorrectImage(_BYTE * cpSourceImage,_BYTE *cpTragetImage)
{
	int i,j;
	int fy, fx;
	int y, x, y1, x1;
	int dy, dx, dy1, dx1;
	U8  *line1, *line2;
	for(i=0; i<IMG_HEIGHT; i++){
		fy = i*BCTHEIGHT*100 / IMG_HEIGHT;
		y = fy/100;  y1 = y+1;
		dy1 = fy - y*100;  dy = 100-dy1;
		if(dy1 == 0 && BCTHEIGHT != IMG_HEIGHT){
			dy = 50;  dy1 = 50;
		}
		if(y1 >= BCTHEIGHT)  y1 = BCTHEIGHT - 1;
		line1 = cpSourceImage + BCTWIDTH * y;
		line2 = cpSourceImage + BCTWIDTH * y1;
		for(j=0; j<IMG_WIDTH; j++){
			fx = j * BCTWIDTH * 100 / IMG_WIDTH;
			x = fx / 100;  x1 = x + 1;
			dx1 = fx - 100 * x;  dx = 100 - dx1;
			if(dx1 == 0 && BCTWIDTH != IMG_WIDTH){
				dx = 50;  dx1 = 50;
			}
			if(x1 >= BCTWIDTH)  x1 = BCTWIDTH - 1;
			cpTragetImage[i*IMG_WIDTH+j] = (U8)(int)((line1[x] * dy * dx + line1[x1] * dy * dx1 + line2[x] * dy1 * dx + line2[x1] * dy1 * dx1 + 5000) / 10000);
		}
	}
}

// 读SW1键的状态
// 有按键按下返回C_OK
// 否则返回C_NOTOK
_BYTE BCTSW1ReadStatus(void)
{
   	if((MY_PIO_PDSR & SW1_MASK) != SW1_MASK) {                           	// 有按键按下
      	Delayms(100);                              						// 延迟
      	if((MY_PIO_PDSR & SW1_MASK) != SW1_MASK){                         	// 有按键按下
      		return(C_OK);
      	}
      	else {
			return(C_NOTOK);
      	}
   	}
   	else {                                       // 无按键按下
		return(C_NOTOK);
   	}
}

// 等待SW1一段时间，以100MS为单位
_BYTE BCTWaitSW1(_DWORD dwTime)
{
	_BYTE cRetCode;
	while (dwTime!=0) {
		cRetCode = BCTSW1ReadStatus();
		if (cRetCode==C_OK)  {
			Delayms(300);
			return(C_OK);
		}	
		Delayms(100);
		dwTime--;
	}
	return(C_FINGERTIMEOUT);
}