📄 blksave.c

📁 在ARM7和UC/OSII的平台上实现了GPS自动报站的功能,涉及GPS模块LEA_4S的驱动,位置速寻算法,语音芯片ISD4004的录放音驱动,LED页面管理等等.从启动代码到操作系统的移植以及到业
💻 C
字号:
/*
 =========================================================================
 Description:       Blk Save
 Author:            Zealea_Kuethy
 change  by  qzc
 Date:              2003.08.11
 =========================================================================
*/
#define BLKSAVE_GLOBALS
#include "includes.h"
#include "bsp.h"
#include "structs.h"
#include "Public.h"
#include "Printer.h"
#include "tools.h"
#include "Flash.h"
#include "timetask.h"
#include "Systime.h"
#include "GpsRecer.h"
#include "BlkSave.h"
#include "blkQuery.h"
#include "BlkOpt.h"
#include "BlkSend.h"

#define SIMULATE_GPS  0

#if EN_BLACKBOX > 0

TMR_TSK *SBlkTmrId;
static INT8U SBlkPeriod[2]={0,10};
static DATUM_STRUCT SGpsBaseDot,CurDot;
static INT8U Latitude[4],Longitude[4];
static INT8U SBlkCount;
static BOOLEAN Carried;
static SPARSEBLK  SBlk;

#if SIMULATE_GPS
static INT8U Index=0;
typedef struct
{
   INT8U Lat_C[2];
   INT8U Long_C[2];
}SIMULATGPS;

static SIMULATGPS SimulateGps[10]=
{
71,83,68,58,
71,90,68,67,
71,45,68,33,
71,65,68,21,
71,60,68,30,
71,20,68,90,
71,30,68,80,
71,55,68,45,
71,42,68,70,
71,70,68,45
};

static void GetDatumData_(DATUM_STRUCT *datum)
{
   datum->hbit=0x60;
   datum->latitude[0]=24;
   datum->latitude[1]=30;
   datum->latitude[2]=SimulateGps[Index].Lat_C[0];
   datum->latitude[3]=SimulateGps[Index].Lat_C[1];
   datum->longitude[0]=118;
   datum->longitude[1]=05;
   datum->longitude[2]=SimulateGps[Index].Long_C[0];
   datum->longitude[3]=SimulateGps[Index].Long_C[1];;
   datum->vector=0;
   datum->direction=0;
   if(++Index>=10) Index=0;
}
#endif

BlkParaStruct BlkPara=
{
 BLKTOP,BLKBOTTOM,sizeof(SPARSEBLK),sizeof(S_BASEGPS),sizeof(S_GPS),&SBlkWr
};

static void SaveBlkOffset(DATUM_STRUCT *BaseDot,SPARSEBLK *SBlk,INT8U Count)
{

   #if DEBUG_UARTNo_BlkBOX<=3
   PrintFromUART(DEBUG_UARTNo_BlkBOX,"\nSaveBlkOffset");
   #endif
   if(Count>=MAXGPSNUM)
    {
    	PrintFromUART(DEBUG_UARTNo_BlkBOX,"\nCount>=MAXGPSNUM,err");
    	//ErrExit(ERR_BLK_GPSNUM);
    }

   GetDatumData(&CurDot);
    #if SIMULATE_GPS
   GetDatumData_(&CurDot);
   #endif
   Carried=DecGpsData(Latitude,CurDot.latitude,BaseDot->latitude);
   Latitude[1]+=Latitude[0]*60;
   if(Carried) Latitude[1]|=0x80;
   Carried=DecGpsData(Longitude,CurDot.longitude,BaseDot->longitude);
   Longitude[1]+=Longitude[0]*60;
   if(Carried) Longitude[1]|=0x80;
   memcpy(&SBlk->GpsDot[Count-1].Vla_D,&Latitude[1],3);
   memcpy(&SBlk->GpsDot[Count-1].Vlg_D,&Longitude[1],3);
   SBlk->GpsDot[Count-1].Vector=BaseDot->vector;
   memcpy((INT8U *)BaseDot,(INT8U *)&CurDot,sizeof(DATUM_STRUCT));
}

#if DEBUG_UARTNo_BlkBOX < 3
#define BUFSIZE 128
static INT8U Data[BUFSIZE];
static void ReadData(INT8U Sector)
{
	INT8U i,count;

	for(count=0;count<32;count++)
	 {
		for(i=0;i<BUFSIZE;i++) Data[i]=ReadByteFrom_Flash(Sector,count*BUFSIZE+i);
   	    FormatPrintDataBlock(FORMAT_HEX,DEBUG_UARTNo_BlkBOX,Data,sizeof(Data));
    	OSTimeDly(2);
    }
}
#endif
/*
 ====================================================================================
 Description:       modify Blk write parament
 ====================================================================================
*/
static void GetNextBlkWr(void)
{
   BlkParaStruct *Para;

   Para=&BlkPara;
   Para->BlkWr->WrOffset+=Para->Size;
   if((Para->BlkWr->WrOffset+Para->Size)>SIZE_FLASHSECTOR)
     {
      #if DEBUG_UARTNo_BlkBOX < 3
      ReadData(Para->BlkWr->WrSector);
      #endif
      Para->BlkWr->WrOffset=HEADOFFSET;							//need to change a new Sector
      Para->BlkWr->WrSector++;
      if(Para->BlkWr->WrSector>Para->Top) Para->BlkWr->WrSector=Para->Bottom;
     }
}

static void InitBlkWrPara(void)
{
   BlkParaStruct *Para;
   BLKHEAD *BlkHead;
   INT16U Offset;
   INT8U Sector,i;

   Para=&BlkPara;
   Sector=Para->Bottom;
   for(i=Para->Bottom;i<=Para->Top;i++)
     {
      if(!SectorWriteValid(i))//如果该扇区没有使用（时间值无效），则执行如下算法
        {
         Para->BlkWr->WrSector=i;
         Offset=HEADOFFSET;
         BlkHead=(BLKHEAD *)FlashAbsAddr(i,Offset);
         while(BlkHead->WrFlag==SUCCESS)
	      {
	        Offset+=Para->Size;
	        if((Offset+Para->Size)>SIZE_FLASHSECTOR) break;
	        else BlkHead=(BLKHEAD *)FlashAbsAddr(i,Offset);
	      }
         if(Offset+Para->Size>SIZE_FLASHSECTOR) Offset=HEADOFFSET;
         Para->BlkWr->WrOffset=Offset;
         return;
        }
      if(CmpData((INT8U *)(FlashAbsAddr(i,0)),(INT8U *)(FlashAbsAddr(Sector,0)),sizeof(BLKTIME),sizeof(BLKTIME))==STR_LESS)
        Sector=i;
     }
   Para->BlkWr->WrSector=Sector;
   Para->BlkWr->WrOffset=HEADOFFSET;
} 

static void StoreBlk(INT8U Sector,INT16U Offset,SPARSEBLK *Sptr,INT16U Len)
{
   INT8U 		*TempPtr;
   BLKTIME 		TempTm;
   BLKHEAD 		*BlkHead; 	
   #if DEBUG_UARTNo_BlkBOX<=3
   PrintFromUART(DEBUG_UARTNo_BlkBOX,"\n================StoreBlk Sector:");
   FormatPrintDataBlock(FORMAT_HEX,DEBUG_UARTNo_BlkBOX,&Sector,1);
   PrintFromUART(DEBUG_UARTNo_BlkBOX,"\n================StoreBlk Offset:");
   FormatPrintDataBlock(FORMAT_HEX,DEBUG_UARTNo_BlkBOX,(INT8U *)&Offset,2);
   #endif
  if((!IsInRange(Sector,BLKBOTTOM,BLKTOP))||(Offset+Len>SIZE_FLASHSECTOR))
   {
     #if DEBUG_UARTNo_BlkBOX<=3
     PrintFromUART(DEBUG_UARTNo_BlkBOX,"\nERR_BLK_SECTOR");
     #endif
     //ErrExit(ERR_BLK_SECTOR);
   }
   Sptr->WRSuccess = SUCCESS;
   TempPtr=(INT8U *)Sptr;
   #if DEBUG_UARTNo_BlkBOX<=3
   PrintFromUART(DEBUG_UARTNo_BlkBOX, "\nLen = ");
   SendFromUART_HEX(DEBUG_UARTNo_BlkBOX, Len);
   #endif
   FlashWrite(Sector, Offset, TempPtr, Len);

   BlkHead=(BLKHEAD *)Sptr;
   #if DEBUG_UARTNo_BlkBOX<=3
   PrintFromUART(DEBUG_UARTNo_BlkBOX, "\nBlkParaStruct=");
   FormatPrintDataBlock(FORMAT_HEX,DEBUG_UARTNo_BlkBOX,(INT8U *)Sptr,sizeof(SPARSEBLK));
   PrintFromUART(DEBUG_UARTNo_BlkBOX, "\nBLKHEAD=");
   FormatPrintDataBlock(FORMAT_HEX,DEBUG_UARTNo_BlkBOX,(INT8U *)BlkHead,sizeof(BLKHEAD));
   #endif
   if(Offset==HEADOFFSET)
     {
      TempPtr=(INT8U *)(&BlkHead->BaseTime);
      #if DEBUG_UARTNo_BlkBOX<=3
      PrintFromUART(DEBUG_UARTNo_BlkBOX, "\nBlkHead->BaseTime=");
      FormatPrintDataBlock(FORMAT_HEX,DEBUG_UARTNo_BlkBOX,TempPtr,sizeof(BLKTIME));
      #endif
	  FlashWrite(Sector, 0, TempPtr, sizeof(BLKTIME));
     }
   else if(Offset+2*Len>SIZE_FLASHSECTOR)
     {
      GetOffsetTime(&TempTm,&BlkHead->BaseTime,BlkHead->Interval,MAXGPSNUM-1);
      TempPtr=(INT8U *)&TempTm;
	  FlashWrite(Sector, sizeof(BLKTIME), TempPtr, sizeof(BLKTIME));
     }
}

static void GatherSBlk(void)
{
   INT16U TimeSecondCount;
   #if DEBUG_UARTNo_BlkBOX<=3
   PrintFromUART(DEBUG_UARTNo_BlkBOX,"\nGatherSBLK");
   PrintFromUART(DEBUG_UARTNo_BlkBOX, "\nSBlkCount=");
   SendFromUART_HEX(DEBUG_UARTNo_BlkBOX, SBlkCount);
   #endif

   if(SBlkCount==0)
     {
       if(!GpsDataValid()||!SysTimeValid()) return;
       GetDatumData(&SGpsBaseDot);
       #if SIMULATE_GPS
       GetDatumData_(&SGpsBaseDot);
       #endif
      if(SGpsBaseDot.vector==0) return;

      #if DEBUG_UARTNo_BlkBOX<=3
      PrintFromUART(DEBUG_UARTNo_BlkBOX,"\nSBLK");
      #endif

      SBlk.GpsCount=MAXGPSNUM;
      if(PubParaValid(BBOXTCB_))
        {
         SBlkPeriod[0]=BBoxTCB.IntervalM;
         SBlkPeriod[1]=BBoxTCB.IntervalS;
         TimeSecondCount = SBlkPeriod[0]*60 + SBlkPeriod[1];
         StartTmr (SBlkTmrId, SECOND, TimeSecondCount);
        }
      SBlk.Interval[0]=SBlkPeriod[0];
      SBlk.Interval[1]=SBlkPeriod[1];
      GetSysTime((SYSTIME_STRUCT *)&SBlk.BaseTime);
      memcpy((INT8U *)&SBlk.BaseDot,SGpsBaseDot.latitude,sizeof(S_BASEGPS));
      SBlkCount++;
     }
   else
     {
      SaveBlkOffset(&SGpsBaseDot,&SBlk,SBlkCount);
      if(++SBlkCount>=MAXGPSNUM)
        {
	     SBlkCount=0;
         if(SBlkWr.WrOffset==HEADOFFSET)
           {
            if(ReadWriteConflict(SBlkWr.WrSector)) return;
            else
             {
             	if((SBlkWr.WrSector>=BLKBOTTOM)&&(SBlkWr.WrSector<=BLKTOP))//判断防止擦除错误扇区
             		SectorErase_Flash(SBlkWr.WrSector);
             }
           }
           
	     StoreBlk(SBlkWr.WrSector,SBlkWr.WrOffset,&SBlk,sizeof(SPARSEBLK));
      	 GetNextBlkWr();
        }
     }
}

static void SBlkSave(void)
{
   INT16U TimeSecondCount;
   SBlkCount=0;
   if(PubParaValid(BBOXTCB_))
     {
      SBlkPeriod[0]=BBoxTCB.IntervalM;
      SBlkPeriod[1]=BBoxTCB.IntervalS;
     }
   TimeSecondCount = SBlkPeriod[0]*60 + SBlkPeriod[1];
   StartTmr (SBlkTmrId, SECOND, TimeSecondCount);
}

void InitBlkSave(void)
{
   #if DEBUG_UARTNo_BlkBOX<=3
   BlkParaStruct *Para;;
   Para=&BlkPara;
   #endif
   InitBlkWrPara();
   #if DEBUG_UARTNo_BlkBOX<=3
   PrintFromUART(DEBUG_UARTNo_BlkBOX, "\nPara->BlkWr->WrSector=");
   SendFromUART_HEX(DEBUG_UARTNo_BlkBOX, Para->BlkWr->WrSector);
   PrintFromUART(DEBUG_UARTNo_BlkBOX, "\nPara->BlkWr->WrOffset=");
   SendFromUART_HEX(DEBUG_UARTNo_BlkBOX, Para->BlkWr->WrOffset>>8);
   SendFromUART_HEX(DEBUG_UARTNo_BlkBOX, Para->BlkWr->WrOffset);   
   #endif
   SBlkTmrId = CreateTimer (GatherSBlk, 0);
   SBlkSave();
}

BOOLEAN SectorWriteValid(INT8U Sector)
{
   INT8U *Boot;
   INT8U i;

   Boot=(INT8U *)FlashAbsAddr(Sector,0);
   for(i=0;i<2*sizeof(BLKTIME);i++)
     {
      if(!IsInRange(*Boot++,0,60)) return FALSE;
     }
   return TRUE;
}

INT8U GetBlkReadSector(void)
{
   INT8U Sector;

   Sector=BlkPara.BlkWr->WrSector+1;
   if(Sector>BlkPara.Top) Sector=BlkPara.Bottom;
   if(!SectorWriteValid(Sector)) Sector=BlkPara.Bottom;
   return Sector;
}

#if DEBUG_UARTNo_BlkBOX<=3
static void PrintStructSize(void)
{
	INT8U templen;
	templen = sizeof(TimeStruct);
	PrintFromUART(DEBUG_UARTNo_BlkBOX, "\nsizeof(TimeStruct)=");
	SendFromUART_HEX(DEBUG_UARTNo_BlkBOX, templen);
	
	templen = sizeof(DateStruct);
	PrintFromUART(DEBUG_UARTNo_BlkBOX, "\nsizeof(DateStruct)=");
	SendFromUART_HEX(DEBUG_UARTNo_BlkBOX, templen);
	
	templen = sizeof(BLKTIME);
	PrintFromUART(DEBUG_UARTNo_BlkBOX, "\nsizeof(BLKTIME)=");
	SendFromUART_HEX(DEBUG_UARTNo_BlkBOX, templen);	
	
	templen = sizeof(BLKHEAD);
	PrintFromUART(DEBUG_UARTNo_BlkBOX, "\nsizeof(BLKHEAD)=");
	SendFromUART_HEX(DEBUG_UARTNo_BlkBOX, templen);
	
	templen = sizeof(S_BASEGPS);
	PrintFromUART(DEBUG_UARTNo_BlkBOX, "\nsizeof(S_BASEGPS)=");
	SendFromUART_HEX(DEBUG_UARTNo_BlkBOX, templen);
	
	templen = sizeof(S_GPS);
	PrintFromUART(DEBUG_UARTNo_BlkBOX, "\nsizeof(S_GPS)=");
	SendFromUART_HEX(DEBUG_UARTNo_BlkBOX, templen);
	
	templen = sizeof(SPARSEBLK);
	PrintFromUART(DEBUG_UARTNo_BlkBOX, "\nsizeof(SPARSEBLK)=");
	SendFromUART_HEX(DEBUG_UARTNo_BlkBOX, templen);
	
	templen = sizeof(SectorBootStruct);
	PrintFromUART(DEBUG_UARTNo_BlkBOX, "\nsizeof(SectorBootStruct)=");
	SendFromUART_HEX(DEBUG_UARTNo_BlkBOX, templen);
	
	templen = sizeof(BlkWrStruct);
	PrintFromUART(DEBUG_UARTNo_BlkBOX, "\nsizeof(BlkWrStruct)=");
	SendFromUART_HEX(DEBUG_UARTNo_BlkBOX, templen);
	
	templen = sizeof(BlkParaStruct);
	PrintFromUART(DEBUG_UARTNo_BlkBOX, "\nsizeof(BlkParaStruct)=");
	SendFromUART_HEX(DEBUG_UARTNo_BlkBOX, templen);							
}
#endif

void InitBlkBox(void)
{
   #if DEBUG_UARTNo_BlkBOX<=3
   PrintStructSize();
   //ReadData(0x4c);
   #endif
   InitBlkSave();
   InitBlkQuery();
   InitBlkSend();
}

#endif
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -