loaddata.c

在ST单片机上实现GPS交通警示器功能.

/****************************************************************
**                                                              *
**  FILE         :  LoadData.C                                  *
**  COPYRIGHT    :  (c) 2001 .Xiamen Yaxon NetWork CO.LTD       *
**                                                              *
**                                                              *
**  By : cyb 2006.10.16                                         *
****************************************************************/
#include "config.h"
#include "system.h"
#include "reg52.h"
#include "LoadData.h"
#include "stdio.h"
#include "uart.h"
#include "hardware.h"
#include "structs.h"
#include "flash.h"


static INT16U  checksum;

static void  InitLoadUART(void)
{
      InitUart0();
}

static INT8U ReadUART(void)
{
      while(RI == 0)
	  { 
	       ClearWatchdog();
	  }
	  
      RI = 0;
	  return  ReadUART_GSM();
}

static INT8U Load2Hex(void)
{
  	INT8U firstbyte, secondbyte, curhex;
    
    firstbyte = ReadUART();                    
    
	if(firstbyte < 'A') 
	{                      
    	firstbyte -= '0';
    } 
	else 
	{
        firstbyte  = firstbyte - 'A' + 10;      
    }
    
	firstbyte <<= 4;
    
    secondbyte = ReadUART();
                   
    if(secondbyte < 'A') 
	{
    	secondbyte -= '0';
    } 
	else 
	{
        secondbyte  = secondbyte - 'A' + 10;
    }
    
    curhex    = firstbyte + secondbyte;        
    checksum += curhex;                         
    return curhex;
}

static INT16U Load4Hex(void)
{
  	INT16U temp;
  	
  	temp   = Load2Hex();                 
  	temp <<= 8;
  	return (temp + Load2Hex());
}


static void SendFromUART_BYTE(INT8U dat)
{
     
	  WriteUART_GSM(dat);
      
	  while (TI == 0)
	  { 
	       ClearWatchdog();
	  }
	  
	  TI = 0;
}

static void SendFromUART_HEX_HALF(INT8U ch)
{
    ch &= 0x0f;
    if (ch < 10) ch += '0';
    else ch = ch - 0x0a + 'A';
    SendFromUART_BYTE(ch);
}

static void PrintFromUART( char *p)
{
     while(*p)
	 {
	     if (*p == '\n') 
		 {
            SendFromUART_BYTE(0x0D);
            SendFromUART_BYTE(0x0A);
            p++;
         } 
		 else 
		 {
            SendFromUART_BYTE(*p++);
         }
	 }
}

static void PrintStatBytes(INT32U total)
{
    BOOLEAN prezero;
    INT8U   format, d;
    INT32U  factor;
    
    factor  = 1000000;
    format  = 1;
    prezero = TRUE;
    
    
    PrintFromUART("\n共下载");

    for (;;) 
	{
        if (format == 0) 
		{
            if (!prezero)
			{
                SendFromUART_BYTE(',');
			}

            format = 3;
        }

        format--;

        if (factor < 10) 
		{
            SendFromUART_HEX_HALF(total);
            break;
        }
       
	    d       = total / factor;
        total  %= factor;
        factor /= 10;
        
		if (!prezero || d > 0) 
		{
            prezero = FALSE;
            SendFromUART_HEX_HALF(d);
        }
    }

    PrintFromUART("字节！\n");
}

static void PrintLoadHit(void)
{
      PrintFromUART("\n*************************************************\n");
	  PrintFromUART("\n*           确认更新布点数据?(Y/N)              *\n");
	  PrintFromUART("\n*************************************************\n");
}
static void Printendhit(INT8U type)
{
      switch(type)
	  {
		 case ZONE_LAT :
         PrintFromUART("\n纬度区间数据下载完毕！！！\n");
		 break;
    	 case ZONE_LONGT:
         PrintFromUART("\n经度区间数据下载完毕！！！\n");
		 break;
		 case VALID_ZONE:
		 PrintFromUART("\n有效区域筛网数据下载完毕！！！\n");
		 break;
	     case DOT_OFFSET:
         PrintFromUART("\n路口信息点偏移量数据下载完毕！！！\n");
		 break;
		 case ELEC_OFFSET:
         PrintFromUART("\n电子眼偏移量数据下载完毕！！！\n");
		 break;
		 case INFO_DOT:
		 PrintFromUART("\n路口信息点数据下载完毕！！！\n");
		 break;
	     case ELEC_EYE:
         PrintFromUART("\n电子眼数据下载完毕！！！\n");
		 break;
		 default:
	     break;
	 }


}
static void Delaytime(void)
{
    TR0   = 0;                              /* 停止定时器 */
    TMOD &= 0xf0;                           /* 设置TMOD */
    TMOD |= 0x01;
    ET0   = 0;                              /* 禁止中断 */
        
    TH0   = 0;
    TL0   = 0;
    TR0   = 1;
   
	for(;;)
	{
	   if (( TH0 == _W_TH) && ( TL0 == _W_TL)) break;

	}
}

static BOOLEAN WaitInputYes(INT16U time)
{
     INT8U i;
     INT8U temp;
  
     time *= 50;
     
     for( i=0;i<time;i++ )
     {
        
          
         temp = ReadUART();
  		 
		 if ( (temp == 'Y')||(temp == 'y'))
 		 {
			       return  TRUE;
		 }
      	 else if ( (temp == 'N')||(temp == 'n'))
		 {
			       return FALSE;
		 }
	    

         Delaytime();
             
     }

	 return FALSE;
     
     
}

static INT32U GetBaseAddr(INT8U type)
{
      
           
	  switch(type)
	  {
		 case ZONE_LAT :
         return ZONELAT_MEMBASE;
    	 case ZONE_LONGT:
         return ZONELONGT_MEMBASE;
		 case VALID_ZONE:
		 return  VALIDZONE_MEMBASE;
	     case DOT_OFFSET:
         return  DOTOFFSET_MEMBASE;
		 case ELEC_OFFSET:
         return ELECOFFSET_MEMBASE;
		 case INFO_DOT:
		 return INFODOT_MEMBASE;
	     case ELEC_EYE:
         return  ELECEYE_MEMBASE;
		 default:
	     return ZONELAT_MEMBASE;
	 }

}

static INT32U GetEndAddr(INT8U type)
{
        switch(type)
	    {
		  case ZONE_LAT :
          return ZONELAT_MEMEND;
    	  case ZONE_LONGT:
          return ZONELONGT_MEMEND;
		  case VALID_ZONE:
		  return  VALIDZONE_MEMEND;
	      case DOT_OFFSET:
          return  DOTOFFSET_MEMEND;
		  case ELEC_OFFSET:
          return ELECOFFSET_MEMEND;
		  case INFO_DOT:
		  return INFODOT_MEMEND;
	      case ELEC_EYE:
          return  ELECEYE_MEMEND;
		  default:
	      return ZONELAT_MEMEND;
	   }   
}
static INT8U  LoadDataFile(void)
{
       
       INT8U type;
	   INT32U address,baseaddr,endaddr;
	   INT16U curaddr;
	   INT8U  temp;
       INT8U   rectype;
  	   INT16U  offset, len, readbytes;
  	   INT32U  segaddr,  totalbytes;
	  
	   
       for(;;)
	   {
	       
	        while (ReadUART() != ':')                           /* wait for : (start record) */
            ;
		
			checksum = 0;
			
			len      = Load2Hex();                              
            offset   = Load4Hex();                              
            rectype  = Load2Hex();

			switch (rectype)                                    
            {
            case 0:                                         
                if (segaddr == 0) 
				{
                   address = baseaddr + offset;
                } 
				else 
				{
                   address = segaddr + offset;
                }
                break;
            case 1:                                        
                Load2Hex();                                 
                
				if (checksum != 0) 
				{ 
                    return LOAD_ERROR_CHKSUM;               
                } 
				else 
				{
                     Printendhit(type);
                                            
                }
            case 2:                                        
                segaddr   = Load4Hex();
                segaddr <<= 4;
                len      -= 2;
                break;
            case 3:                                         
                return LOAD_ERROR_TYPE;                     
            case 4:                                         
                segaddr   = Load4Hex();
                segaddr <<= 16;
                len      -= 2;
                break;
			case 8:
			    type = Load2Hex();
			    baseaddr = GetBaseAddr(type);
                endaddr  = GetEndAddr(type);
                len   -= 1;
				break;
			case 9:
			    Load2Hex();
                
				if (checksum != 0) 
				{ 
                    return LOAD_ERROR_CHKSUM;               
                } 
				else 
				{

                    PrintStatBytes(totalbytes);
                    return LOAD_OK;                         
                }

            default:
                return LOAD_ERROR_TYPE;                    
           }

		
            for( ; len>0 ; len--)
		    {
		      if (rectype == 0) 
			  {
                 readbytes++;
                 totalbytes++; 
		 		 
				 if((address>= baseaddr)&&(address <= endaddr))
  		         {
		            curaddr =  SELFlashBank(address++);
			        temp =  Load2Hex(); 
			        
					if(!WriteFlash_BYTE(curaddr,temp))
					{
					    return LOAD_ERROR_WRITE;
					}
			     }
			     else
			     {
			        return LOAD_ERROR_RANGE;
			     }
			  }
			  else
			  {
			      Load2Hex(); 
			  }
		    }

            Load2Hex();
			  
			if(checksum != 0)
            {
			     return LOAD_ERROR_CHKSUM; 
			}


	   }
}

BOOLEAN LoadData(void)
{
       
       INT8U result;

       InitLoadUART();
       PrintLoadHit();
	   
	   if(!WaitInputYes(3))
	   {
	      return FALSE;
	   }
       
	   PrintFromUART("\n正在擦除数据区.........\n");
       EraseFlash_Entire();
       PrintFromUART("\n擦除数据区完毕！！！\n");

       PrintFromUART("\n请传送布点数据HEX文件.........\n");
      
	   result = LoadDataFile();

       switch (result)
       {
        case LOAD_OK:
            PrintFromUART( "文件下载成功！\n");
            PrintFromUART( "现在转入正常工作状态！\n");
            return TRUE;
        case LOAD_ERROR_CHKSUM:
            PrintFromUART( "对不起，校验码出错！！！\n");
            return FALSE;
        case LOAD_ERROR_TYPE:
            PrintFromUART( "对不起，文件记录类型!!！\n");
            return FALSE;
        case LOAD_ERROR_WRITE:
            PrintFromUART( "对不起，写FLASH出错！！！\n");
            return FALSE;
        case LOAD_ERROR_RANGE:
            PrintFromUART( "对不起，地址超出允许范围！！！\n");
            return FALSE;
        default:
            return FALSE;
     }

        
}