writer.c File Reference

#include "includes.h"

Go to the source code of this file.

Defines

#define WRITER_DEBUG_ENABLE   0
#define WriterIdleState   0
#define WriterCheckHexfileState   1
#define WriterTransmitHexfileState   2
#define WRITER_HEXFILE_SIZE   200000
#define HexFindColonState   0
#define HexByteCountState   1
#define HexAddressState   2
#define HexRecordTypeState   3
#define HexDataState   4
#define HexChecksumState   5
#define FLASH_WRITE_SIZE   64
#define HEX_BYTE_COUNT   0
#define HEX_ADDRESS   1
#define HEX_RECORD_TYPE   3
#define HEX_DATA   4
#define ExtendedSegmentAddress   0
#define ExtendedLinearAddress   1
#define RecordType_Data   0
#define RecordType_EOF   1
#define RecordType_ESAR   2
#define RecordType_SSAR   3
#define RecordType_ELAR   4
#define RecordType_SLAR   5

Functions

U8 FL_Hexdigit2Hex (U8 Data)
BOOL F_WriterHexfileCheck (FILE *pStream)
void F_WriterHexfileWrite (void)
void F_WriterPageProgram (void)
void F_WriterInit (void)
void F_WriterSvc (void)
U8 F_WriterStateGet (void)
void F_WriterImageWrite (void)

Variables

WRITER_CONTROL WriterCtrl
U8 Counter
U32 HexStringNumber
U8 * pHexString
U8 WriterBuffer [WRITER_HEXFILE_SIZE]
U8 WriterFilename [] = "mypic.hex"
FILE * pWriterStream
UN_UL FlashAddress
U8 FlashBuffer [FLASH_WRITE_SIZE+16]

Define Documentation

#define ExtendedLinearAddress   1

Definition at line 230 of file writer.c.

#define ExtendedSegmentAddress   0

Definition at line 229 of file writer.c.

#define FLASH_WRITE_SIZE   64

Definition at line 222 of file writer.c.

#define HEX_ADDRESS   1

Definition at line 225 of file writer.c.

#define HEX_BYTE_COUNT   0

Definition at line 224 of file writer.c.

#define HEX_DATA   4

Definition at line 227 of file writer.c.

#define HEX_RECORD_TYPE   3

Definition at line 226 of file writer.c.

#define HexAddressState   2

Definition at line 97 of file writer.c.

#define HexByteCountState   1

Definition at line 96 of file writer.c.

#define HexChecksumState   5

Definition at line 100 of file writer.c.

#define HexDataState   4

Definition at line 99 of file writer.c.

#define HexFindColonState   0

Definition at line 95 of file writer.c.

#define HexRecordTypeState   3

Definition at line 98 of file writer.c.

#define RecordType_Data   0

Definition at line 232 of file writer.c.

#define RecordType_ELAR   4

Definition at line 236 of file writer.c.

#define RecordType_EOF   1

Definition at line 233 of file writer.c.

#define RecordType_ESAR   2

Definition at line 234 of file writer.c.

#define RecordType_SLAR   5

Definition at line 237 of file writer.c.

#define RecordType_SSAR   3

Definition at line 235 of file writer.c.

#define WRITER_DEBUG_ENABLE   0

Definition at line 11 of file writer.c.

#define WRITER_HEXFILE_SIZE   200000

Definition at line 19 of file writer.c.

#define WriterCheckHexfileState   1

Definition at line 14 of file writer.c.

#define WriterIdleState   0

Definition at line 13 of file writer.c.

#define WriterTransmitHexfileState   2

Definition at line 15 of file writer.c.

Function Documentation

BOOL F_WriterHexfileCheck ( FILE *  pStream  ) 

Definition at line 101 of file writer.c.

00101                                         {
00102     U32 i;
00103     U8 j;
00104     U8 Error;
00105     U8 Data;
00106     U8 Hex0,Hex1,Hexdata;
00107     U8 State;
00108     U8 ByteCount;
00109     U8 Checksum;
00110     U8 meetEOF;
00111     
00112     meetEOF=FALSE;
00113     i=0;
00114     Error=0;
00115     while(feof(pStream)==0){       // store file stream in buffer
00116         Data=(U8)fgetc(pStream);
00117         WriterBuffer[i]=Data;
00118         i++;
00119         if(i>=WRITER_HEXFILE_SIZE) break;   
00120     }
00121     if(i>=WRITER_HEXFILE_SIZE) return FALSE;
00122     WriterCtrl.HexStringNumber=0;
00123     WriterCtrl.StreamSize=i;
00124     State=HexFindColonState;
00125     for(i=0;i<WriterCtrl.StreamSize;){
00126         switch(State){
00127             case HexFindColonState:
00128                 if(WriterBuffer[i]!=':'){
00129                     WriterBuffer[i]=0;
00130                     i++;
00131                     break;
00132                 }
00133                 i++;
00134                 WriterCtrl.HexStringNumber++;
00135                 Checksum=0;
00136                 //printf("[%2x]",WriterCtrl.HexStringNumber);
00137                 State=HexByteCountState;
00138                 break;
00139             case HexByteCountState: // 2 hex digit
00140                 Hex0=WriterBuffer[i++];
00141                 if(((Hex0>'F')&&(Hex0<'A'))&&((Hex0>'9')&&(Hex0<'0'))) return FALSE; // not ascii value
00142                 Hex0=FL_Hexdigit2Hex(Hex0);
00143                 Hex1=WriterBuffer[i++];
00144                 if(((Hex1>'F')&&(Hex1<'A'))&&((Hex1>'9')&&(Hex1<'0'))) return FALSE; // not ascii value
00145                 Hex1=FL_Hexdigit2Hex(Hex1);
00146                 ByteCount=Hex0*16+Hex1;
00147                 //printf("[%2x]",ByteCount);
00148                 Checksum=Checksum+ByteCount;
00149                 State=HexAddressState;
00150                 break;
00151             case HexAddressState: // 4 hex digit
00152                 Hex0=WriterBuffer[i++];
00153                 if(((Hex0>'F')&&(Hex0<'A'))&&((Hex0>'9')&&(Hex0<'0'))) return FALSE; // not ascii value
00154                 Hex0=FL_Hexdigit2Hex(Hex0);             
00155                 Hex1=WriterBuffer[i++];
00156                 if(((Hex1>'F')&&(Hex1<'A'))&&((Hex1>'9')&&(Hex1<'0'))) return FALSE; // not ascii value
00157                 Hex1=FL_Hexdigit2Hex(Hex1);
00158                 Hexdata=Hex0*16+Hex1;
00159                 //printf("[%2x]",Hexdata);
00160                 Checksum=Checksum+Hexdata;
00161 
00162                 Hex0=WriterBuffer[i++];
00163                 if(((Hex0>'F')&&(Hex0<'A'))&&((Hex0>'9')&&(Hex0<'0'))) return FALSE; // not ascii value
00164                 Hex0=FL_Hexdigit2Hex(Hex0);             
00165                 Hex1=WriterBuffer[i++];
00166                 if(((Hex1>'F')&&(Hex1<'A'))&&((Hex1>'9')&&(Hex1<'0'))) return FALSE; // not ascii value
00167                 Hex1=FL_Hexdigit2Hex(Hex1);
00168                 Hexdata=Hex0*16+Hex1;
00169                 //printf("[%2x]",Hexdata);
00170                 Checksum=Checksum+Hexdata;              
00171                 State=HexRecordTypeState;
00172                 break;
00173             case HexRecordTypeState: // 2 hex digit
00174                 Hex0=WriterBuffer[i++];
00175                 if(((Hex0>'F')&&(Hex0<'A'))&&((Hex0>'9')&&(Hex0<'0'))) return FALSE; // not ascii value
00176                 Hex0=FL_Hexdigit2Hex(Hex0);             
00177                 Hex1=WriterBuffer[i++];
00178                 if(((Hex1>'F')&&(Hex1<'A'))&&((Hex1>'9')&&(Hex1<'0'))) return FALSE; // not ascii value
00179                 Hex1=FL_Hexdigit2Hex(Hex1);
00180                 Hexdata=Hex0*16+Hex1;
00181                 //printf("[%2x]",Hexdata);
00182                 if(Hexdata==0x01) meetEOF=TRUE;
00183                 else meetEOF=FALSE;
00184                 Checksum=Checksum+Hexdata;
00185                 State=HexDataState;
00186                 break;
00187             case HexDataState:
00188                 for(j=0;j<ByteCount;j++){
00189                     Hex0=WriterBuffer[i++];
00190                     if(((Hex0>'F')&&(Hex0<'A'))&&((Hex0>'9')&&(Hex0<'0'))) return FALSE; // not ascii value
00191                     Hex0=FL_Hexdigit2Hex(Hex0);             
00192                     Hex1=WriterBuffer[i++];
00193                     if(((Hex1>'F')&&(Hex1<'A'))&&((Hex1>'9')&&(Hex1<'0'))) return FALSE; // not ascii value
00194                     Hex1=FL_Hexdigit2Hex(Hex1);
00195                     Hexdata=Hex0*16+Hex1;
00196                     //printf("[%2x]",Hexdata);
00197                     Checksum=Checksum+Hexdata;                              
00198                 }
00199                 State=HexChecksumState;
00200                 break;
00201             case HexChecksumState:
00202                 Hex0=WriterBuffer[i++];
00203                 if(((Hex0>'F')&&(Hex0<'A'))&&((Hex0>'9')&&(Hex0<'0'))) return FALSE; // not ascii value
00204                 Hex0=FL_Hexdigit2Hex(Hex0);             
00205                 Hex1=WriterBuffer[i++];
00206                 if(((Hex1>'F')&&(Hex1<'A'))&&((Hex1>'9')&&(Hex1<'0'))) return FALSE; // not ascii value
00207                 Hex1=FL_Hexdigit2Hex(Hex1);
00208                 Hexdata=Hex0*16+Hex1;
00209                 //printf("[%2x]",Hexdata);
00210                 Checksum=Checksum+Hexdata;  
00211                 if(Checksum==0) State=HexFindColonState;
00212                 else return FALSE;
00213                 if(meetEOF==TRUE){
00214                     WriterBuffer[i]=0; // end last string with 0
00215                     return TRUE;
00216                 }
00217                 break;
00218         }
00219     }
00220     return FALSE;
00221 }

void F_WriterHexfileWrite ( void   ) 

Definition at line 241 of file writer.c.

00241                                {
00242     U32 StreamBufferIndex;
00243     U8 u8Temp,i,Data,Data2,Data3,Data4,HasData,MeetEof;
00244     U8 HexBuffer[FLASH_WRITE_SIZE];
00245     U8 FlashBufferIndex;
00246     U8 HexBufferIndex;
00247     U8 ExtendedType;       // segment or linear
00248     U16 u16Temp;
00249     U16 CS;                // for 80x86 CS:IP
00250     U16 IP;                // for 80x86 CS:IP 
00251     UN_UI Address;
00252     UN_UL ExtendedAddress;
00253     UN_UL EIP; // for 80x86 use
00254     
00255     Address.u16=0;
00256     ExtendedAddress.u32=0;
00257     FlashAddress.u32=0;   
00258     ExtendedType=0;  
00259     HasData=FALSE; 
00260     HexBufferIndex=0;
00261     FlashBufferIndex=0;
00262     i=0;
00263     StreamBufferIndex=0;
00264     MeetEof=0;
00265     while(1){
00266         if(MeetEof==1) break;
00267         while(WriterBuffer[StreamBufferIndex]!=':') StreamBufferIndex++;
00268         StreamBufferIndex++; // skip ':'
00269         Data=FL_Hexdigit2Hex(WriterBuffer[StreamBufferIndex++]);
00270         Data2=FL_Hexdigit2Hex(WriterBuffer[StreamBufferIndex++]);
00271         HexBuffer[HEX_BYTE_COUNT]=(Data<<4)+Data2;
00272 
00273         Data=FL_Hexdigit2Hex(WriterBuffer[StreamBufferIndex++]);  // get address
00274         Data2=FL_Hexdigit2Hex(WriterBuffer[StreamBufferIndex++]);
00275         HexBuffer[HEX_ADDRESS]=(Data<<4)+Data2;
00276         Data=FL_Hexdigit2Hex(WriterBuffer[StreamBufferIndex++]);  // get address
00277         Data2=FL_Hexdigit2Hex(WriterBuffer[StreamBufferIndex++]);
00278         HexBuffer[HEX_ADDRESS+1]=(Data<<4)+Data2;
00279 
00280         Data=FL_Hexdigit2Hex(WriterBuffer[StreamBufferIndex++]);  // get record type
00281         Data2=FL_Hexdigit2Hex(WriterBuffer[StreamBufferIndex++]);
00282         HexBuffer[HEX_RECORD_TYPE]=(Data<<4)+Data2;
00283         HexBufferIndex=HEX_RECORD_TYPE;
00284         for(u8Temp=0;u8Temp<HexBuffer[HEX_BYTE_COUNT];u8Temp++){
00285             Data=FL_Hexdigit2Hex(WriterBuffer[StreamBufferIndex++]);  // get address
00286             Data2=FL_Hexdigit2Hex(WriterBuffer[StreamBufferIndex++]);
00287             HexBuffer[HEX_DATA+u8Temp]=(Data<<4)+Data2;
00288             HexBufferIndex++;
00289         }
00290 
00291         Data=FL_Hexdigit2Hex(WriterBuffer[StreamBufferIndex++]);  // get checksum
00292         Data2=FL_Hexdigit2Hex(WriterBuffer[StreamBufferIndex++]);
00293         u8Temp=(Data<<4)+Data2; // no use checksum...it is already checked 
00294         //printf("\n ");
00295         //for(i=0;i<=HexBufferIndex;i++) printf(" %2x",HexBuffer[i]);
00296 
00297         switch(HexBuffer[HEX_RECORD_TYPE]){ 
00298             case RecordType_Data: // data record                
00299                 if(HasData==FALSE){
00300                     for(i=0;i<FLASH_WRITE_SIZE;i++) FlashBuffer[i]=0xff;
00301                     Address.u8[1]=HexBuffer[HEX_ADDRESS];
00302                     Address.u8[0]=HexBuffer[HEX_ADDRESS+1]&0xc0; // take bits 7.6...address is page address
00303                     FlashBufferIndex=HexBuffer[HEX_ADDRESS+1]&0x3f;    // take bits 5.4.3.2.1.0
00304                     for(i=0;i<HexBuffer[HEX_BYTE_COUNT];i++){
00305                         FlashBuffer[FlashBufferIndex++]=HexBuffer[HEX_DATA+i]; // move data in hex buffer to flash buffer
00306                     }
00307                     if(FlashBufferIndex<64){
00308                         HasData=TRUE;
00309                         break; // continue to receive data
00310                     }
00311                     else if(FlashBufferIndex==64){
00312                         FlashAddress.u32=ExtendedAddress.u32+((U32)Address.u16&0x0000ffc0);
00313                         F_WriterPageProgram();
00314                         for(i=0;i<FLASH_WRITE_SIZE;i++) FlashBuffer[i]=0xff; // reset FlashBuffer[0~63]
00315                         //FlashBufferIndex=0; //no need
00316                         HasData=FALSE;
00317                         break;
00318                     }
00319                     else if(FlashBufferIndex>64){
00320                         FlashAddress.u32=ExtendedAddress.u32+((U32)Address.u16&0x0000ffc0);
00321                         F_WriterPageProgram();
00322                         for(i=0;i<FLASH_WRITE_SIZE;i++) FlashBuffer[i]=0xff; // reset FlashBuffer[0~63]
00323                         for(i=0;i<(FlashBufferIndex-64);i++) FlashBuffer[i]=FlashBuffer[64+i];
00324                         Address.u16=Address.u16+FLASH_WRITE_SIZE;   // advance to next page, but if 0xffc0?? address reset to 0
00325                         FlashBufferIndex=FlashBufferIndex-64;
00326                         HasData=TRUE;
00327                         break;
00328                     }
00329                 }
00330                 else{
00331                     u16Temp=((U16)HexBuffer[HEX_ADDRESS]<<8)+(HexBuffer[HEX_ADDRESS+1]&0xc0);
00332                     u8Temp=HexBuffer[HEX_ADDRESS+1]&0x3f;
00333                     if(u16Temp==Address.u16){ //in same page
00334                         FlashBufferIndex=u8Temp;  
00335                         for(i=0;i<HexBuffer[HEX_BYTE_COUNT];i++){ // copy data from hexbuffer to flashbuffer
00336                             FlashBuffer[FlashBufferIndex++]=HexBuffer[HEX_DATA+i];
00337                         }
00338                         if(FlashBufferIndex<64) break; // continue to receive data
00339                         else if(FlashBufferIndex==64){
00340                             FlashAddress.u32=ExtendedAddress.u32+((U32)Address.u16&0x0000ffc0);
00341                             F_WriterPageProgram();
00342                             for(i=0;i<FLASH_WRITE_SIZE;i++) FlashBuffer[i]=0xff; // reset FlashBuffer[0~63]
00343                             //FlashBufferIndex=0; //no need
00344                             HasData=FALSE;
00345                             break;
00346                         }
00347                         else if(FlashBufferIndex>64){
00348                             FlashAddress.u32=ExtendedAddress.u32+((U32)Address.u16&0x0000ffc0);
00349                             F_WriterPageProgram();
00350                             for(i=0;i<FLASH_WRITE_SIZE;i++) FlashBuffer[i]=0xff; // reset FlashBuffer[0~63]
00351                             for(i=0;i<(FlashBufferIndex-64);i++) FlashBuffer[i]=FlashBuffer[64+i];
00352                             Address.u16=Address.u16+FLASH_WRITE_SIZE;   // advance to next page, but if 0xffc0?? address reset to 0
00353                             FlashBufferIndex=FlashBufferIndex-64;
00354                             HasData=TRUE;
00355                             break;
00356                         }
00357                     }
00358                     else{ // in different page
00359                         FlashAddress.u32=ExtendedAddress.u32+((U32)Address.u16&0x0000ffc0);
00360                         F_WriterPageProgram();
00361                         for(i=0;i<FLASH_WRITE_SIZE;i++) FlashBuffer[i]=0xff; // reset FlashBuffer[0~63]
00362                         Address.u8[1]=HexBuffer[HEX_ADDRESS];
00363                         Address.u8[0]=HexBuffer[HEX_ADDRESS+1]&0xc0; // take bits 7.6
00364                         FlashBufferIndex=HexBuffer[HEX_ADDRESS+1]&0x3f;    // take bits 5.4.3.2.1.0
00365                         for(i=0;i<HexBuffer[HEX_BYTE_COUNT];i++){
00366                             FlashBuffer[FlashBufferIndex++]=HexBuffer[HEX_DATA+i];
00367                         }
00368                         if(FlashBufferIndex<64){
00369                             HasData=TRUE;
00370                             break; // continue to receive data
00371                         }
00372                         else if(FlashBufferIndex==64){
00373                             FlashAddress.u32=ExtendedAddress.u32+((U32)Address.u16&0x0000ffc0);
00374                             F_WriterPageProgram();
00375                             for(i=0;i<FLASH_WRITE_SIZE;i++) FlashBuffer[i]=0xff; // reset FlashBuffer[0~63]
00376                             //FlashBufferIndex=0; //no need
00377                             HasData=FALSE;
00378                             break;
00379                         }
00380                         else if(FlashBufferIndex>64){
00381                             FlashAddress.u32=ExtendedAddress.u32+((U32)Address.u16&0x0000ffc0);
00382                             F_WriterPageProgram();
00383                             for(i=0;i<FLASH_WRITE_SIZE;i++) FlashBuffer[i]=0xff; // reset FlashBuffer[0~63]
00384                             for(i=0;i<(FlashBufferIndex-64);i++) FlashBuffer[i]=FlashBuffer[64+i];
00385                             Address.u16=Address.u16+FLASH_WRITE_SIZE;   // advance to next page, but if 0xffc0?? address reset to 0
00386                             FlashBufferIndex=FlashBufferIndex-64;
00387                             HasData=TRUE;
00388                             break;
00389                         }
00390                         break;
00391                     }
00392                 }
00393                 break;
00394             case RecordType_EOF: // end of file
00395                 if(HasData==TRUE){
00396                     FlashAddress.u32=ExtendedAddress.u32+((U32)Address.u16&0x0000ffc0);
00397                     F_WriterPageProgram();
00398                     for(i=0;i<FLASH_WRITE_SIZE;i++) FlashBuffer[i]=0xff; // reset FlashBuffer[0~63]
00399                     //FlashIndex=0; //no need
00400                     HasData=FALSE;
00401                 }
00402                 MeetEof=1;
00403                 break;
00404             case RecordType_ESAR: // extended segment address record
00405                 if(HasData==TRUE){
00406                     FlashAddress.u32=ExtendedAddress.u32+((U32)Address.u16&0x0000ffc0);
00407                     F_WriterPageProgram();
00408                     for(i=0;i<FLASH_WRITE_SIZE;i++) FlashBuffer[i]=0xff;  // reset FlashBuffer[0~63]
00409                     //FlashIndex=0; //no need
00410                     HasData=FALSE;
00411                 }
00412                 ExtendedAddress.u8[1]=HexBuffer[HEX_DATA];
00413                 ExtendedAddress.u8[0]=HexBuffer[HEX_DATA+1];
00414                 ExtendedAddress.u8[3]=0;
00415                 ExtendedAddress.u8[2]=0;
00416                 ExtendedAddress.u32=ExtendedAddress.u32<<4;
00417                 ExtendedType=ExtendedSegmentAddress;
00418                 break;
00419             case RecordType_SSAR: // start segment address record
00420                 if(HasData==TRUE){
00421                     FlashAddress.u32=ExtendedAddress.u32+((U32)Address.u16&0x0000ffc0);
00422                     F_WriterPageProgram();
00423                     for(i=0;i<FLASH_WRITE_SIZE;i++) FlashBuffer[i]=0xff;  // reset FlashBuffer[0~63]
00424                     //FlashIndex=0; //no need
00425                     HasData=FALSE;
00426                 }
00427                 Data=HexBuffer[HEX_DATA];
00428                 Data2=HexBuffer[HEX_DATA+1];
00429                 Data3=HexBuffer[HEX_DATA+2];
00430                 Data4=HexBuffer[HEX_DATA+3];
00431                 CS=((U16)Data<<12)
00432                    +((U16)Data2<<8)
00433                    +((U16)Data3<<4)
00434                    +((U16)Data4);
00435                 Data=HexBuffer[HEX_DATA+4];
00436                 Data2=HexBuffer[HEX_DATA+5];
00437                 Data3=HexBuffer[HEX_DATA+6];
00438                 Data4=HexBuffer[HEX_DATA+7];
00439                 IP=((U16)Data<<12)
00440                    +((U16)Data2<<8)
00441                    +((U16)Data3<<4)
00442                    +((U16)Data4);
00443                 break;
00444             case RecordType_ELAR: // extended linear address record
00445                 if(HasData==TRUE){
00446                     FlashAddress.u32=ExtendedAddress.u32+((U32)Address.u16&0x0000ffc0);
00447                     F_WriterPageProgram();
00448                     for(i=0;i<FLASH_WRITE_SIZE;i++) FlashBuffer[i]=0xff; // reset FlashBuffer[0~63]
00449                     //FlashIndex=0; //no need
00450                     HasData=FALSE;
00451                 }
00452                 ExtendedAddress.u8[1]=HexBuffer[HEX_DATA];
00453                 ExtendedAddress.u8[0]=HexBuffer[HEX_DATA+1];
00454                 ExtendedAddress.u8[3]=0;
00455                 ExtendedAddress.u8[2]=0;
00456                 ExtendedAddress.u32=ExtendedAddress.u32<<16;
00457                 ExtendedType=ExtendedLinearAddress;
00458                 //printf("\n RecordType_ELAR ExtendedAddress: %8x ",ExtendedAddress.u32);
00459                 break;
00460             case RecordType_SLAR: // start linear address record
00461                 if(HasData==TRUE){
00462                     FlashAddress.u32=ExtendedAddress.u32+((U32)Address.u16&0x0000ffc0);
00463                     F_WriterPageProgram();
00464                     for(i=0;i<FLASH_WRITE_SIZE;i++) FlashBuffer[i]=0xff;  // reset FlashBuffer[0~63]
00465                     //FlashIndex=0; //no need
00466                     HasData=FALSE;
00467                 }
00468                 Data=HexBuffer[HEX_DATA];
00469                 Data2=HexBuffer[HEX_DATA+1];
00470                 EIP.u8[3]=(Data<<4)+Data2;
00471                 Data=HexBuffer[HEX_DATA];
00472                 Data2=HexBuffer[HEX_DATA+1];
00473                 EIP.u8[2]=(Data<<4)+Data2;
00474                 Data=HexBuffer[HEX_DATA];
00475                 Data2=HexBuffer[HEX_DATA+1];
00476                 EIP.u8[1]=(Data<<4)+Data2;
00477                 Data=HexBuffer[HEX_DATA+2];
00478                 Data2=HexBuffer[HEX_DATA+3];
00479                 EIP.u8[0]=(Data<<4)+Data2;
00480                 break;
00481         }
00482     }
00483 }

void F_WriterImageWrite ( void   ) 

Definition at line 86 of file writer.c.

00086                              {
00087     WriterCtrl.State=WriterCheckHexfileState;
00088 }

void F_WriterInit ( void   ) 

Definition at line 31 of file writer.c.

00031                        {
00032     WriterCtrl.HexStringNumber=0;
00033     WriterCtrl.StreamSize=0;
00034     WriterCtrl.State=WriterIdleState;
00035     WriterCtrl.Status=0;
00036 }

void F_WriterPageProgram ( void   ) 

Definition at line 504 of file writer.c.

00504                                   {
00505         //U8 i,j;
00506 
00507         IcspCtrl.Address=FlashAddress.u32;
00508         IcspCtrl.pData=&FlashBuffer[0];
00509         F_IcspPageProgram();
00510     }

U8 F_WriterStateGet ( void   ) 

Definition at line 83 of file writer.c.

00083                          {
00084     return WriterCtrl.State;
00085 }

void F_WriterSvc ( void   ) 

Definition at line 37 of file writer.c.

00037                       {
00038     U32 i;
00039 
00040     switch(WriterCtrl.State){
00041         case WriterIdleState:
00042             break;
00043         case WriterCheckHexfileState:
00044             pWriterStream=NULL;
00045             if(WriterFilename[0]!=0) pWriterStream=fopen((char *)WriterFilename,"rb");
00046             if(pWriterStream==NULL){                            
00047                 printf("\n Can not open file %15s.",WriterFilename);                                
00048                 WriterCtrl.State=WriterIdleState;
00049                 break;
00050             }
00051             for(i=0;i<WRITER_HEXFILE_SIZE;i++) WriterBuffer[i]=0xff;
00052             if(F_WriterHexfileCheck(pWriterStream)==TRUE){
00053                 printf("\n hex file check ok.");
00054             }
00055             else{
00056                 printf("\n hex file check fail.");
00057             }
00058             fclose(pWriterStream);
00059             //WriterCtrl.State=WriterIdleState;
00060             WriterCtrl.State=WriterTransmitHexfileState;
00061             break;
00062         case WriterTransmitHexfileState:
00063             #if(WRITER_DEBUG_ENABLE==1)
00064                 //F_WriterHexfileWrite();
00065                 F_IcspProgramModeEnter(); 
00066                 F_IcspBulkErase();           
00067                 //F_WriterHexfileWrite();
00068                 F_IcspProgramModeExit();
00069                 F_IcspReset();
00070             #else 
00071                 F_IcspProgramModeEnter(); 
00072                 F_IcspBulkErase();           
00073                 F_WriterHexfileWrite();
00074                 F_IcspProgramModeExit();
00075                 F_IcspReset();
00076             #endif
00077                 
00078             printf("\n write done. ");
00079             WriterCtrl.State=WriterIdleState;
00080             break;
00081     }
00082 }

U8 FL_Hexdigit2Hex ( U8  Data  ) 

Definition at line 89 of file writer.c.

00089                            {
00090     if(Data>='A') Data=Data-'A'+10;
00091     else Data=Data-'0';
00092     return Data;
00093 }

Variable Documentation

U8 Counter

Definition at line 20 of file writer.c.

UN_UL FlashAddress

Definition at line 239 of file writer.c.

U8 FlashBuffer[FLASH_WRITE_SIZE+16]

Definition at line 240 of file writer.c.

U32 HexStringNumber

Definition at line 21 of file writer.c.

U8* pHexString

Definition at line 22 of file writer.c.

FILE* pWriterStream

Definition at line 25 of file writer.c.

U8 WriterBuffer[WRITER_HEXFILE_SIZE]

Definition at line 23 of file writer.c.

WRITER_CONTROL WriterCtrl

Definition at line 17 of file writer.c.

U8 WriterFilename[] = "mypic.hex"

Definition at line 24 of file writer.c.

Generated on Sun Jul 19 00:50:40 2009 for PROGRAMER FOR PIC18F87J10 USING LPT PORT by  doxygen 1.5.9