mywinchbeta.c

一种深度和拉力测量系统

	first_addr = first_addr * 64;

	MEM_CalAddr(sector_addr,block_addr,page_addr);// Cal address
	MEM_WeAddr();						// Write address

	TRISD = 0b11111111;					// Port D: input
	MEM_DIR = 0;

	for(i=0;i<=63;i++) {				// Read 64 bytes
		MEM_RE = 0;
		DataPack[i]= PORTD;
		MEM_RE = 1;
	}

	MEM_CE = 1;
	MEM_DIR = 1;

}
//---------------------------------------------------------------------------------
void MEM_WriteLine(unsigned char sector_addr,
	           	   unsigned char block_addr,
                   unsigned char page_addr,
                   unsigned char line_addr)
{
     unsigned char i,j;
	TRISD = 0x00;
	MEM_CE = 0;					// chip1

	MEM_COMD(0x80);						// Serial data mode
	MEM_CalAddr(sector_addr,block_addr,page_addr);	// Cal address
	first_addr = 0;
	MEM_WeAddr();

	MEM_DIR = 1;
	TRISD = 0b00000000;					// Port D: output

	for(i=0;i<line_addr;i++) {
		for(j=0;j<=63;j++) {			// Write 64 bytes "FF" to a line
			MEM_WE = 0;
			PORTD = 0xff;		 
			MEM_WE = 1;
		}
	}

	for(j=0;j<=63;j++) {				// Write 64 bytes data to a line
		MEM_WE = 0;
		PORTD = DataPack[j];		 
		MEM_WE = 1;
	}

	for(i=line_addr+1;i<8;i++) {
		for(j=0;j<=63;j++) {			// Write 64 bytes "FF" to a line
			MEM_WE = 0;
			PORTD = 0xff;		 
			MEM_WE = 1;
		}
	}

	for(j=0;j<=15;j++) {				// Write 16 bytes "FF" to a line
		MEM_WE = 0;
		PORTD = 0xff;		 
		MEM_WE = 1;
	}

	MEM_COMD(0x10);						// Auto program mode
	while(!(0x40 & MEM_status()));		// Test status: bit6=1 ready

	MEM_CE = 1;
	MEM_DIR = 1;
	TRISD = 0b11111111;

}
//------------------------------
void MEM_LoadBadBlock(unsigned char sector_addr)
{
   unsigned char i;

	MEM_ReadLine(0,0,0,sector_addr+1);
	
	for(i=0;i<32;i++) {
		BadBlock_Table[i] = DataPack[i];
	}
}

//-------------------------------------------------
void MEM_CWritePage(unsigned char sector_addr,
                    unsigned char block_addr,
                    unsigned char page_addr,
		    		unsigned char x)
{
   unsigned int i,a;
	MEM_CE=0;

	MEM_COMD(0x80);
	MEM_CalAddr(sector_addr,block_addr,page_addr);	// Cal address
	first_addr = 0;
	MEM_WeAddr();					// write address

	MEM_DIR = 1;
	TRISD = 0X00;				// Port D: output

	for(i=0;i<=255;i++) {			// write 256 bytes
		MEM_WE = 0;
		PORTD = x;
		MEM_WE = 1;
	}

	for(i=0;i<=255;i++) {			// write 256 bytes
		MEM_WE = 0;
		PORTD = x;
		MEM_WE = 1;
	}

	for(i=0;i<=15;i++) {			// write 16 bytes
		MEM_WE = 0;
		PORTD = 0xff;
		MEM_WE = 1;
	}

	MEM_COMD(0x10);				// Auto program mode

	while(!(0x40 & MEM_status()));

	MEM_CE = 1;
	MEM_DIR = 1;
	TRISD = 0XFF;

}
//------------------------------------------------
void MEM_CWriteBlock(unsigned char sector_addr,
                     unsigned char block_addr,
		     		 unsigned char x)
{
   unsigned char i;

	for(i=0;i<16;i++) {
		MEM_CWritePage(sector_addr,block_addr,i,x);
	}
}
//---
void Init_FLASH_MEM(void)
{
	MEM_LoadBadBlock(0);
}

//--------------------------------------------------
unsigned char MEM_CompPage(unsigned char sector_addr,
		           		   unsigned char block_addr,
			   			   unsigned char page_addr,		
			   			   unsigned char x)
{
     unsigned int i;
     unsigned char data_byte;
	MEM_CE=0;

	MEM_COMD(0x00);				// Write command: Read mode 0
	MEM_CalAddr(sector_addr,block_addr,page_addr);	// Cal address
	first_addr = 0;
	MEM_WeAddr();

	TRISD = 0XFF;			// Port D: input
	MEM_DIR = 0;

	for(i=0;i<512;i++) {		// Read 512 bytes
		MEM_RE = 0;
		data_byte = PORTD;
		MEM_RE = 1;
		if(data_byte != x) {
			MEM_CE = 1;
			return(1);			// return=1 : the block is bad
		}	
	}

	MEM_CE = 0;
	MEM_DIR = 1;
	return(0);
}

//---------------------------------------------

unsigned char MEM_CompBlock(unsigned char sector_addr,
		            		unsigned char block_addr,
			    			unsigned char x)
{
  unsigned char i;
  unsigned char result;

	for(i=0;i<=15;i++) {
		result = MEM_CompPage(sector_addr,block_addr,i,x);
		if(result==1) return(1); 
	}
	return (0);
}
//-----------------------------------------------
void MEM_GetMark(unsigned char block_addr,unsigned char *temp1,unsigned char *temp2)
{
  unsigned char temp3;

	*temp1 = block_addr/8;///
	temp3  = block_addr & 0x07;///

	*temp2 = 1;

	while(temp3) {
		*temp2 = (*temp2) * 2;
		temp3 = temp3 - 1;
	}
}
//------------------------------------------------
unsigned char MEM_CheckBlock(unsigned block_addr)
{
  unsigned char temp1,temp2;			// temp1: offset of byte in Bad Block
										// temp2: mask

	MEM_GetMark(block_addr,&temp1,&temp2);
	if(BadBlock_Table[temp1] & temp2 ==0) {
		return 0;
	}
	else {
		return 1;
	} 
}
//---------------------------------------------
void MEM_MarkBad(unsigned char block_addr)
{
  unsigned char temp1,temp2;

	MEM_GetMark(block_addr,&temp1,&temp2);		// temp1,temp2
	temp2 = ~temp2;
	BadBlock_Table[temp1] = BadBlock_Table[temp1] & temp2;
}
//---------------
void MEM_FormatSector(unsigned char sector_addr)
{
  unsigned int i;
  unsigned char result;

	for(i=0;i<=31;i++) {
		BadBlock_Table[i] = 0xff;		// Bad block table: 32 btyes
	}

	for(i=4;i<=255;i++) {
		result = MEM_CompBlock(sector_addr,i,0xff);		// check "FF"
		if(result==1) MEM_MarkBad(i);
	}

	for(i=4;i<=255;i++) {

		MEM_CWriteBlock(sector_addr,i,0x55);
		result = MEM_CompBlock(sector_addr,i,0x55);		// check "0x55"

		if(result==1) {
			MEM_MarkBad(i);
		}
		else {
			MEM_EraseBlock(sector_addr,i,0);
			MEM_CWriteBlock(sector_addr,i,0xaa);
			result = MEM_CompBlock(sector_addr,i,0xaa); 	// check "0xaa"
			if(result==1) {
				MEM_MarkBad(i);
			} 
			else {
				MEM_EraseBlock(sector_addr,i,0);
			}
		}
	}

}
//-----------------------------------------
void MEM_Format(void)
{
  unsigned char i,j;


	MEM_EraseBlock(0,0,0);

	DataPack[0]= 0x88;
	for(i=1;i<=63;i++) {
		DataPack[i] = 0xff;
	}

	MEM_WriteLine(0,0,0,0);		// write a mark "88"

	for(j=0;j<=3;j++) {						// 4 sectors
		MEM_FormatSector(j);

		for(i=0;i<=31;i++) {
			DataPack[i] = BadBlock_Table[i];
			DataPack[i+32] = 0;
		}
		MEM_WriteLine(0,0,0,j+1);	// write the badblock table
	}
}
//=====================
//=====================
//
//----存储模式的PPS---
//
//=====================
void MEM_LableFirst(void)
{
			DataPack[0] = 0x37;
			DataPack[1] = 0;
			DataPack[2] = 0;
			DataPack[3] = 0;
			DataPack[4] = 0xff;
			DataPack[5] = 0xff;
			DataPack[6] = 0xff;
			DataPack[7] = 0xff;

			DataPack[8]  = 0x00;
			DataPack[9]  = 0x00;
			DataPack[10] = 0x00;
			DataPack[11] = 0x00;
			DataPack[12] = 0x00;
			DataPack[13] = 0x00;
			DataPack[14] = 0x00;

			DataPack[15] = 0xff;

	SCNTR = SCNTR + 16;
}
//----------------------------------------------
void MEM_LableData(void)
{

			DataPack[0] = 0x37;
			DataPack[1] = time.c[2];
			DataPack[2] = time.c[1];
			DataPack[3] = time.c[0];

			DataPack[4] = 0;
			DataPack[5] = 0;
			DataPack[6] = 0;
			DataPack[7] = 0;

			DataPack[8]  = 0x00;
			DataPack[9]  = 0x00;
			DataPack[10] = 0x00;
			DataPack[11] = 0x00;
			DataPack[12] = 0x00;
			DataPack[13] = 0x00;
			DataPack[14] = 0x00;

			DataPack[15] = 0xff;	

	SCNTR = SCNTR + 16;
}
//-----------------------------------------------------------------------------
void MEM_FindNext(void)			//find next good block
{
	MEM_LoadBadBlock(MEM_sector);

	do {
		if(MEM_block==255) {
			MEM_sector = MEM_sector + 1;
			if(MEM_sector==4) {
				Out_MEM = 1;
				return;
			}
			MEM_LoadBadBlock(MEM_sector);
			MEM_block = 0;
			MEM_page = 0;
			MEM_line = 0;
		}
		if(MEM_CheckBlock(MEM_block)==1) return;	// This block is good
		MEM_block = MEM_block + 1;					// Check next block
	} while(1);
}
//-------------------------------------------------------------------------------
void MEM_FindFirst(void)
{

	MEM_sector = 0;
	MEM_block  = 3;
	MEM_page   = 0;
	MEM_line   = 0;

	do {
		MEM_block = MEM_block + 1;
		MEM_FindNext();
		if(Out_MEM==1) return;
		MEM_ReadLine(MEM_sector,MEM_block,MEM_page,MEM_line);
	} while(DataPack[0]==0x37);
}
//---------------------------------------------------------------------------------
void DataSave(void)
{
	DataPack[SCNTR + 0] = time.c[3];				// Real timer high 
	DataPack[SCNTR + 1] = time.c[2];
	DataPack[SCNTR + 2] = time.c[1];	
	DataPack[SCNTR + 3] = time.c[0];		
	DataPack[SCNTR + 4] = depth.c[3];		// DH
	DataPack[SCNTR + 5] = depth.c[2];		// 
	DataPack[SCNTR + 6] = depth.c[1];		// 
	DataPack[SCNTR + 7] = depth.c[0];		// DL

	SCNTR = SCNTR + 8;
	if(SCNTR==0x40) {

	SCNTR = 0;
	
	MEM_WriteLine(MEM_sector,MEM_block,MEM_page,MEM_line);

	MEM_line = MEM_line + 1;

	if(MEM_line==8) {
		MEM_line=0;
		MEM_page=MEM_page + 1;

		if(MEM_page==16) {
			MEM_page=0;
			MEM_block=MEM_block + 1;
			MEM_FindNext();
			MEM_LableData();
		}
	}
 }
}
//-------------------------
void Init_MEM(void)							// Init memory chips
{
	Res1 = 0;
	Res2 = 0;

	PSEG  = 0;
	line=0;
	SCNTR = 0;

	Init_FLASH_MEM();						// Get badblock table of chip0

	MEM_ReadLine(0,2,0,0);				// Read programming
	SMU = DataPack[0];
	SMV = DataPack[1];
	SMH = DataPack[2];
	SML = DataPack[3];
	AMH = DataPack[4];
	AML = DataPack[5];

	Alarm_Time = (unsigned int)AMH*256 + 
	       		  (unsigned int)AML;

	AD_CYC = Alarm_Time;

	Prog_Time = (unsigned long)SMU*65536*256 + 
	       	  	 (unsigned long)SMV*65536 + 
	       		 (unsigned long)SMH*256 + 
	       		 (unsigned long)SML;

	Prog_Time=Prog_Time+time.l;

	MEM_FindFirst();						// find first unused data block
	if(Out_MEM==1) return;
	MEM_LableFirst();						// label first record of block
//	Save_MEM_STS(0);						// save status of the 1st chip
}
//=====================
//------LCD显示-----
//=====================
void lcd_write(unsigned char c)
{
	Delay10TCYx(4); // delay 40us

	PORTD = c;
	LCD_STROBE;
}
/// Clear and home the LCD 
void lcd_clear(void)
{
	LCD_RS = 0;
	lcd_write(0x1);
	Delay10KTCYx(50);
}
/// write a rom string of chars to the LCD 
void lcd_putrs(unsigned rom char *s)
{
	LCD_RS = 1;	// write characters
	while(*s)
		lcd_write(*s++);
}
/// write a string of chars to the LCD 
void lcd_puts(unsigned char *s)
{
	static char n;

	LCD_RS = 1;	// write characters

	lcd_write(' ');
	n = 7;
	while(*s) {
		lcd_write(*s++);
		n--;
	}

	if (n > 0)
	while(n--) 
		lcd_write(' ');
	
}
/// Go to the specified position 
void lcd_goto(unsigned char pos)
{
	LCD_RS = 0;
	lcd_write(0x80 + pos);
}
/// initialise the LCD - put into 4 bit mode 
void lcd_init(void)
{
	TRISD = 0x00;

	LCD_RW = 0;
	LCD_RS = 0;			// write control bytes

	Delay1KTCYx(40);	// power on delay, 40ms
	lcd_write(0x30);	// 8 bit mode, 1/16 duty, 5x8 font

	Delay10TCYx(10);	// 100us
	LCD_STROBE;

	Delay10TCYx(4);		// 40us
	lcd_write(0x08);	// display off
	lcd_write(0x0C);	// display on, blink curson on
	lcd_write(0x06);	// entry mode;
}
/// format a long number to ascii code with dot inside  
void format(long l, unsigned char *buf, char d) 
{
	unsigned long r;
	unsigned char i, *s, n;
// sign	
	if (l < 0) {
		*buf++ = '-';
		l = -l;
	}
	s = buf;
	n = 0;
// tail	
	for(i=0; i<d; i++) {
		n++;
		r = l % 10;
		*s++ = r + '0';
		l /= 10;;
	}
	*s++ = '.';
	n++;
// head
	if (l == 0) {
		n++;
		*s++ = '0';
	} 
	else {	
		while (l) {
			++n;
			r = l % 10;
			*s++ = r + '0';
			l /= 10;
		}
	}
// re-order	
	for(i=0; i<n/2; i++) {
		*(buf+n) = *(buf+i);
		*(buf+i) = *(buf+(n-i-1));
		*(buf+(n-i-1)) = *(buf+n);
	}
	*s=0;
}
///-------------------
///----CMD-----
///-------------------
void eeput(char adr, char val)
{
 	EEADRH = 0x00;
	EEADR = adr;
	EEDATA = val;

	EECON1bits.EEPGD = 0;
	EECON1bits.CFGS = 0;
	EECON1bits.WREN = 1;

	EECON2=0x55;
	EECON2=0xAA;
	EECON1bits.WR=1;
	while(EECON1bits.WR==1);

	EECON1bits.WREN=0;
}
char eeget(char adr)
{
	EEADRH = 0x00;
	EEADR = adr;

	EECON1bits.EEPGD = 0;
	EECON1bits.CFGS = 0;
	EECON1bits.RD = 1;

    return EEDATA;
}
void cmdinit(void) {