main.c

一个编程器的下位机固件

#include "cmddefine.h"
#include "serial.h"
#include <reg51.h>
#include <stdio.h>
#include <string.h>
#include <intrins.h>



#define nop()  _nop_()

#define  _Nop()  {_nop_();_nop_();_nop_();} 
 


///////////////////////////////////////////////////////////////////////////
void clock_vDelay(INT32U u32Time)
{
   INT32U i;
   for(i=0; i<u32Time; i++);
}

/*
///////////////////////////////////////////////////////////////////////////////
void lcd_char(INT8U a)  
{
  // clock_vDelay(5);
   LCDRS = 1; 
  // clock_vDelay(5);
   LCDRW = 0;
   LCDPORT = a; 
   LCDEN = 1; 
   clock_vDelay(50);
   LCDEN = 0; 
}

///////////////////////////////////////////////////////////////////////////////
void lcd_comm(INT8U a) 
{ 
  // clock_vDelay(5);
   LCDRS = 0; 
 //  clock_vDelay(5);
   LCDRW = 0;
   LCDPORT = a; 
   LCDEN = 1; 
   clock_vDelay(50);
   LCDEN = 0; 
}


///////////////////////////////////////////////////////////////////////////////
void lcd_ini(void)
{
   lcd_comm(0x38);
   lcd_comm(0x04);
   lcd_comm(0x0c);
   lcd_comm(0x01);
   lcd_comm(0x02);
}


///////////////////////////////////////////////////////////////////////////////
void lcd_print_string(uchar pos, char *ptr, ...)
{
   INT8U i = 0;
  // clock_vDelay(50);
   lcd_comm(pos | 0x80);

   while( (*ptr != '\0') && (i < 16) )
   {    
     //clock_vDelay(5);
      lcd_char(*ptr ++);
      i++;
   }
   *ptr = 0;
}
*/



/////////////////////////////////////////////////////		
void SendPackHead()
{
    uchar code PackHead[7] = "$SEMICO";
    uchar i;
	for(i=0; i<7; i++)
	{
	   SBUF = PackHead[i];
	   TI = 0;
	   while(!TI);
	 //  serial_putch(PackHead[i]);
	}
}


void SendPackEnd()
{
	uchar code PackEnd[4] =  "END*";
    uchar i;
	for(i=0; i<4; i++)
	{	  
       SBUF = PackEnd[i];
	   TI = 0;
	   while(!TI);
	  // serial_putch(PackEnd[i]);
	}
}


void SendString(uchar *p, unsigned int length)
{
   unsigned int i;
   for(i=0; i<length; i++)
   {
       SBUF = p[i];
	   TI = 0;
	   while(!TI);
      //serial_putch(p[i]);
   }
}



/////////////////////////////////////////////////////////////
void SendPackage(uchar PackType, uchar PackLen, uchar* Pack)
{
	SendPackHead();
	serial_putch(0x00);
	serial_putch(PackType);  //package type
	serial_putch(0x00);
	serial_putch(PackLen);    //package length
	SendString(Pack, PackLen);  //readcounter + 2addr
	SendPackEnd();   
}



////////////////////////////////////////////////////////////
unsigned int Mult(uchar High, uchar Low)
{
   uint value;
   value = High;
   value <<= 8;
   value += Low;
   return (value);
}


//////////////////////////////////////////////////
void ProgModeCancle()
{   
  PGDCLR();
  PGCCLR(); 
  PW12V_OFF();
  PW5V_OFF(); 
}


//////////////////////////////////////////////////
void ProgModeSet()
{
  PW12V_ON();
  clock_vDelay(10);
  PW5V_ON();
}


//////////////////////////////////////////////////
void ProgCommandSet(uchar cmd)
{
   uchar i;
   for(i=0; i<6; i++)
   {
      PGCSET();   //clk = 1
 //  nop();
//   nop();
//   nop();
      if(cmd & 0x01)
	  {
	     PGDSET();  //dat = 1
	  }
	  else
	  {
	     PGDCLR();  //dat = 0
	  }
	  cmd >>= 1;
      PGCCLR();   //clk = 0
   }
}


//////////////////////////////////////////////////////////////
void ProgIncAddr(void)
{
   ProgCommandSet(PICCMD_INCADDR);
}



//////////////////////////////////////////////////////////////
uint ProgReadCode(void)
{   
   uchar i;
   uint  b;
   uint codedata = 0;

   ProgCommandSet(PICCMD_READCODE);   //send command
   clock_vDelay(1);                   //delay

   ////////////first clock////////////////////////
   PGCSET();   //clk = 1
   nop();
   nop();
   nop();
   PGCCLR();   //clk = 0    

   for(i=0; i<14; i++)
   {	  
      PGCSET();   //clk = 1
	  b = PGDREAD();
	  b <<= i;
      codedata += b;
      PGCCLR();   //clk = 0  
   }
   
   ////////////last clock////////////////////////
   PGCSET();   //clk = 1
   nop();
   nop();
   nop();
   PGCCLR();   //clk = 0    
   return codedata;
}

///////////////////////////////////////////////////////
uchar ProgReadEEP(void)
{
   uchar i;
   uchar  b;
   uchar codedata = 0;

   ProgCommandSet(PICCMD_READEEP);   //send command
   clock_vDelay(5);                   //delay

   ////////////first clock////////////////////////
   PGCSET();   //clk = 1
   nop();
   nop();
   nop();
   PGCCLR();   //clk = 0    

   for(i=0; i<8; i++)
   {	  
      PGCSET();   //clk = 1
//   nop();
//   nop();
//   nop();
	  b = PGDREAD();
	  b <<= i;
      codedata += b;
      PGCCLR();   //clk = 0  
   }
   
   ////////////last clock////////////////////////
   for(i=0; i<7; i++)
   {
	   PGCSET();   //clk = 1
	   nop();
	   nop();
	   nop();
	   PGCCLR();   //clk = 0   
   }
   return codedata;   
}

//////////////////////////////////////////////////////////
void ProgWriteCode(uint codedata)
{
   uchar i;
   ProgCommandSet(PICCMD_LDPMEM);
   clock_vDelay(1);                   //delay

   ////////////first clock////////////////////////
   PGDCLR();  //dat = 0
   PGCSET();   //clk = 1
   nop();
   nop();
   nop();
   PGCCLR();   //clk = 0   
 
   for(i=0; i<14; i++)
   {	  
      PGCSET();   //clk = 1
      if(codedata & 0x0001)
	  {
	     PGDSET();  //dat = 1
	  }
	  else
	  {
	     PGDCLR();  //dat = 0
	  }
      codedata >>= 1;
      PGCCLR();   //clk = 0  
   }

   ////////////last clock////////////////////////
   PGDCLR();  //dat = 0
   PGCSET();   //clk = 1
   nop();
   nop();
   nop();
   PGCCLR();   //clk = 0   

   ProgCommandSet(PICCMD_PROGRAM);
   clock_vDelay(50);                   //delay
}


//////////////////////////////////////////////////////////////////////////
void ProgWriteConfig(uint value)
{
   uchar i;
   ProgCommandSet(PICCMD_LDCONFIG);   //send command
   clock_vDelay(1);                   //delay
   ////////////first clock////////////////////////
   PGDCLR();  //dat = 0
   PGCSET();   //clk = 1
   nop();
   nop();
   nop();
   PGCCLR();   //clk = 0   

   for(i=0; i<14; i++)
   {	  
      PGCSET();   //clk = 1
      if(value & 0x0001)
	  {
	     PGDSET();  //dat = 1
	  }
	  else
	  {
	     PGDCLR();  //dat = 0
	  }
      value >>= 1;
      PGCCLR();   //clk = 0  
   }

   PGDCLR();  //dat = 0
   PGCSET();   //clk = 1
   nop();
   nop();
   nop();
   PGCCLR();   //clk = 0        
}

//////////////////////////////////////////////////////////////////////////
void ProgWriteEEProm(uchar eedata)
{
   uchar i;
   ProgCommandSet(PICCMD_LDEEPROM);
   clock_vDelay(1);                   //delay   

   ////////////first clock////////////////////////
   PGDCLR();  //dat = 0
   PGCSET();   //clk = 1
   nop();
   nop();
   nop();
   PGCCLR();   //clk = 0   
 
   for(i=0; i<8; i++)
   {	  
      PGCSET();   //clk = 1
      if(eedata & 0x01)
	  {
	     PGDSET();  //dat = 1
	  }
	  else
	  {
	     PGDCLR();  //dat = 0
	  }
      eedata >>= 1;
      PGCCLR();   //clk = 0  
   }

   for(i=0; i<7; i++)
   {
      PGDCLR();  //dat = 0
	  PGCSET();   //clk = 1
      nop();
	  nop();
	  nop();
	  PGCCLR();   //clk = 0        
   }

   ProgCommandSet(PICCMD_PROGRAM);
   clock_vDelay(100);                   //delay
}


//////////////////////////////////////////////////////////////////////////
//  TINY PROGRAM 
//
//////////////////////////////////////////////////////////////////////////

uchar Tiny_SendByte(uchar Cmd)
{
   uchar i;
   uchar retdata = 0;

   SCK_CLR();
   for(i=0; i<8; i++)
   {   
       retdata <<= 1;
	   if(Cmd & 0x80)
	   {
	      MOSI_SET();
	   }
	   else
	   {
	      MOSI_CLR();
	   }
       SCK_SET();
	   nop();
	   nop();
	   if(MISO_READ() == 1)   //bit=1
	   {
         retdata |= 1;
	   }
	   Cmd <<= 1;
       SCK_CLR();
   }
   return retdata;
}



/////////////////////////////////////////////////////////////
uchar Tiny_ReadProgram(uchar highlow, uint addr)
{
   uchar cmd[3];
   uint  temp = addr;
   uchar retdata;

   highlow <<= 3;
   cmd[0] = 0x20 + highlow;
   cmd[1] = (uchar)(temp >> 8);
   cmd[2] = (uchar)(addr);
   Tiny_SendByte(cmd[0]);
   Tiny_SendByte(cmd[1]);
   Tiny_SendByte(cmd[2]);
   retdata = Tiny_SendByte(0);
   return (retdata);
}

////////////////////////////////////////////////////////
uchar Tiny_ReadEepRom(uchar addr)
{   
   uchar retdata;
   Tiny_SendByte(0xa0);
   Tiny_SendByte(0);
   Tiny_SendByte(addr);
   retdata = Tiny_SendByte(0);  
   return  retdata;
}

////////////////////////////////////////////////////////////////
void Tiny_WriteEepRom(uchar addr, uchar eepdata)
{
   Tiny_SendByte(0xc0);
   Tiny_SendByte(0);
   Tiny_SendByte(addr);
   Tiny_SendByte(eepdata);  
}

////////////////////////////////////////////////////////////////
uchar Tiny_TestBusy()
{
   uchar ret;
   Tiny_SendByte(0xf0);     //
   Tiny_SendByte(0);
   Tiny_SendByte(0);  
   ret = Tiny_SendByte(0);   //send low byte  
   return ret;
}

//////////////////////////////////////////////////////////////////
void Tiny_Erase()
{
   Tiny_SendByte(0xac);     //
   Tiny_SendByte(0x80);
   Tiny_SendByte(0);  
   Tiny_SendByte(0);   //send low byte     
}

////////////////////////////////////////////////////////////////
void Tiny_WriteProgram(uint addr, uchar* progdata)
{
   uint temp = addr;

   Tiny_SendByte(0x40);     //
   Tiny_SendByte(0);
   Tiny_SendByte((uchar)(addr & 0x000f));  
   Tiny_SendByte(*progdata++);   //send low byte

   Tiny_SendByte(0x48);     //
   Tiny_SendByte(0);
   Tiny_SendByte((uchar)(temp & 0x000f));  
   Tiny_SendByte(*progdata);   //send high byte

   Tiny_SendByte(0x4c);     //program
   Tiny_SendByte((uchar)(temp >> 8));
   Tiny_SendByte((uchar)(temp & 0x00f0));  
   Tiny_SendByte(0);   //send high byte
}

////////////////////////////////////////////////////////////////
uchar Tiny_ReadLockBit(void)
{
   uchar temp;
   Tiny_SendByte(0x58);     
   Tiny_SendByte(0);
   Tiny_SendByte(0);  
   temp = Tiny_SendByte(0);   //send low byte  
   return(temp & 0x3f);
}

////////////////////////////////////////////////////////////////
void Tiny_ReadFuseBit(uchar* fusebit)