Create New Item
Item Type
File
Folder
Item Name
Search file in folder and subfolders...
Are you sure want to rename?
File Manager
/
PIC18F452
:
Com.c
Advanced Search
Upload
New Item
Settings
Back
Back Up
Advanced Editor
Save
/**********************************************************************/ /* */ /* File name: COM.c */ /* */ /* Since: 2002/12/03 */ /* */ /* Version: 1.02 */ /* */ /* Author: MONTAGNE Xavier [XM] {link xavier.montagne@wanadoo.fr} */ /* */ /* Purpose: Offer high level interface for PIC programming operations:*/ /* parsing or creat an HEX file, updating the PIC structures */ /* after parsing, reading or programming the PIC,... */ /* */ /* Distribution: This file is part of PP18. */ /* PP18 is free software; you can redistribute it */ /* and/or modify it under the terms of the GNU General */ /* Public License as published by the Free Software */ /* Foundation; either version 2, or (at your option) */ /* any later version. */ /* */ /* PP18 is distributed in the hope that it will be */ /* useful, but WITHOUT ANY WARRANTY; without even the */ /* implied warranty of MERCHANTABILITY or FITNESS FOR A */ /* PARTICULAR PURPOSE. See the GNU General Public */ /* License for more details. */ /* */ /* You should have received a copy of the GNU General */ /* Public License along with PP18; see the file */ /* COPYING.txt. If not, write to the Free Software */ /* Foundation, 59 Temple Place - Suite 330, */ /* Boston, MA 02111-1307, USA. */ /* */ /* History: */ /* 2002/12/03 [XM] Create this file */ /* */ /**********************************************************************/ /*********************************************************************** * INCLUDES **********************************************************************/ #include "driver.h" #include "com.h" /*********************************************************************** * Avoid warning generate by this 'adaptation' for compilation **********************************************************************/ #pragma warning (disable: 4700) /*********************************************************************** * DEFINES. **********************************************************************/ /******* Expected value of Record_type in HEX file ********************/ #define DATA_RECORD 0x00 #define EXTENDED_SEGMENT_ADRESS_RECORD 0x02 #define START_SEGMENT_ADRESS_RECORD 0x03 #define EXTENDED_LINEAR_ADRESS_RECORD 0x04 #define START_LINEAR_ADRESS_RECORD 0x05 /******* For HEX file parser ******************************************/ #define END_OF_LINE 0xDF #define END_OF_FILE 0xEF /******* Defines dedicated to this PIC *********************************/ #define _DEFAULT_PATTERN_ 0xFF #define _MAX_PIC_SIZE 0x4000 /*********************************************************************** * MACROS **********************************************************************/ #define REACH_END_OF_LINE(Record_Type,next,fd) do \ { \ next = GetNextChar(fd); \ /* EOF without END_OF_FILE_RECORD */ \ if (next == END_OF_FILE) \ if (Record_Type == END_OF_FILE_RECORD) \ { \ break; \ } \ else \ /* EOF without END_OF_FILE_RECORD */ \ return(0); \ }while (next != END_OF_LINE); /*********************************************************************** * Global variables. **********************************************************************/ /******* Structures for data from/to PIC or file **********************/ extern HexFile_t HEX_from_file; extern HexFile_t HEX_from_PIC; extern unsigned short MemFile[_MAX_PIC_SIZE]; extern unsigned short MemPIC[_MAX_PIC_SIZE]; extern ConfigWord_t CFG_File; extern ConfigWord_t CFG_PIC; /******* Structure related to statistics if necessary *****************/ extern Statistic_t Stat; /******* Checksum computation from file or PIC content ****************/ extern unsigned char Checksum; /*********************************************************************** * Parse an INTEL HEX file to fill a memory buffer. * Verify checksum for every line of the file. * * @param FILE *fd IN HEX filename to write in * @param u_short *DataBytes IN Reference to the memory buffer * @param u_int uiAddressMax IN Number of addresses parsed * @return void **********************************************************************/ int HexParserMemory(FILE *fd, unsigned short *Data_Bytes, unsigned int *uiAddressMax) { unsigned char Record_Marker; unsigned char Record_Lenght; unsigned int Adress; unsigned int AdressExtended; unsigned char Record_Type; unsigned int the_size; unsigned short *Bookmark; unsigned short temp, temp2; unsigned char i, next, done, inc; Bookmark = Data_Bytes; AdressExtended = 0; Record_Marker = ':'; Checksum = 0; the_size = 0; Record_Type = DATA_RECORD; while (Record_Type != END_OF_FILE_RECORD) { Record_Marker = GetNextChar(fd); while (Record_Marker == ';') REACH_END_OF_LINE(Record_Type,next,fd); if (Record_Marker != ':') return (0); Checksum = 0; done = 0; inc = 0; Record_Lenght = GetNextByte(fd); Adress = GetNextShortUnSwap(fd); Record_Type = GetNextByte(fd); Adress = AdressExtended + Adress; /******* Program code or extended address only **********************/ if ((Adress < 0x200000) || (Record_Type == EXTENDED_LINEAR_ADRESS_RECORD)) { for (i = 0; i < (Record_Lenght / 2); i++) { if (Record_Type == DATA_RECORD) { if ((Adress % 2) && (done == 0)) { Data_Bytes = Bookmark + (Adress / 2) + i; *Data_Bytes &= (unsigned short)((GetNextByte(fd) << 8) + 0x00FF); the_size++; done = 1; inc = 1; if (Record_Lenght % 2) { Record_Lenght++; inc = 0; } } else { Data_Bytes = Bookmark + (Adress / 2) + i; *Data_Bytes = GetNextShort(fd); the_size++; } } if (Record_Type == EXTENDED_LINEAR_ADRESS_RECORD) { temp = GetNextShort(fd); AdressExtended = (temp & 0xFF00) >> 8; AdressExtended = AdressExtended + ((temp & 0xFF) << 8); AdressExtended = AdressExtended << 16; } } if ((i * 2) < (Record_Lenght + inc)) { Data_Bytes = Bookmark + (Adress / 2) + i; *Data_Bytes = 0xFF00 + (unsigned short)(GetNextByte(fd)); } Checksum = 0xFF - Checksum + 1; if (CompareChecksum(fd) == KO) return(KO); } else { /******* We don't need the content but just to read it **********/ for (i = 0; i < (Record_Lenght / 2); i++) GetNextShort(fd); CompareChecksum(fd); } REACH_END_OF_LINE(Record_Type,next,fd); } *uiAddressMax = the_size; return (OK); } /*********************************************************************** * Build a INTEL HEX file from memory buffer. * Compute checksum for every line of the file. * * @param FILE *fd IN HEX filename to write in * @param u_short *DataBytes IN Reference to the memory buffer * @param u_int uiAddressMax IN Address Max = buffer_size x 2 * @return void **********************************************************************/ void HexUnParserMemory(FILE *fd, unsigned short *DataBytes, unsigned int uiAddressMax) { unsigned char Record_Marker; unsigned char Record_Lenght; unsigned short Address; unsigned char Record_Type; unsigned char i; Checksum = 0; /******* Set EXTENDED_LINEAR_ADRESS_RECORD to 0x200000 ****************/ SetNextChar (fd, ':'); SetNextByte (fd, 0x02); SetNextShortUnSwap(fd, 0x00); SetNextByte (fd, EXTENDED_LINEAR_ADRESS_RECORD); SetNextShortUnSwap(fd, 0x0000); Checksum = 0xFF - Checksum + 1; SetNextByte(fd, Checksum); SetCR(fd); Record_Marker = ':'; Record_Type = DATA_RECORD; Address = 0; /******* Fill the file with all the memory buffer *********************/ while (Address < uiAddressMax) { Checksum = 0; Record_Lenght = 0x10; SetNextChar (fd, Record_Marker); SetNextByte (fd, Record_Lenght); SetNextShortUnSwap(fd, Address); SetNextByte (fd, Record_Type); for (i = 0; i < (Record_Lenght / 2); i++) { SetNextShort(fd, (unsigned short)(*DataBytes)); DataBytes++; Address = Address + 2; } Checksum = 0xFF - Checksum + 1; SetNextByte(fd, Checksum); SetCR(fd); } } /*********************************************************************** * Parse a INTEL HEX file to extract the config values. * * @param FILE *fd IN HEX filename to write in * @param pConfigWord_t config IN Config structure reference * @return int OK if sucessfull * KO if checksum error occurs **********************************************************************/ int HexParserConfig(FILE *fd, pConfigWord_t config) { unsigned char Record_Marker; unsigned char Record_Lenght; unsigned int Address; unsigned int AddressExtended; unsigned char Record_Type; unsigned short Data_Bytes; unsigned char i, next; AddressExtended = 0; Record_Marker = ':'; Checksum = 0; Record_Type = DATA_RECORD; while (Record_Type != END_OF_FILE_RECORD) { Record_Marker = GetNextChar(fd); while (Record_Marker == ';') REACH_END_OF_LINE(Record_Type,next,fd); if (Record_Marker != ':') return (0); Checksum = 0; Record_Lenght = GetNextByte(fd); Address = GetNextShortUnSwap(fd); Record_Type = GetNextByte(fd); Address = AddressExtended + Address; /******* Program code or extended address only **********************/ if ((Address >= 0x300000) || (Record_Type == EXTENDED_LINEAR_ADRESS_RECORD)) { for (i = 0; i < (Record_Lenght / 2); i++) { Data_Bytes = GetNextShort(fd); if (Record_Type == DATA_RECORD) switch(Address) { case 0x300000: config->szFosc = (Data_Bytes & 0x0700) >> 8; config->szOscsen = (Data_Bytes & 0x2000) ? 0 : 1; break; case 0x300002: config->szPwrten = (Data_Bytes & 0x0001) ? 0: 1; config->szBoren = (Data_Bytes & 0x0002) ? 1: 0; config->szBorv = (Data_Bytes & 0x000C) >> 2; config->szWdten = (Data_Bytes & 0x0100) >> 8; config->szWdtps = (Data_Bytes & 0x0E00) >> 9; break; case 0x300004: config->szCcp2mx = (Data_Bytes & 0x0100) >> 8; break; case 0x300006: config->szStvren = Data_Bytes & 0x0001; config->szLVP = (Data_Bytes & 0x0004) ? 1 : 0; config->szDebug = (Data_Bytes & 0x0080) ? 0 : 1; break; case 0x300008: config->szCodeProtected = (Data_Bytes & 0xC000) >> 8; config->szCodeProtected += (Data_Bytes & 0x000F); break; case 0x30000A: config->szWriteProtected = (Data_Bytes & 0xE000) >> 8; config->szWriteProtected += (Data_Bytes & 0x000F); break; case 0x30000C: config->szTableReadProtected = (Data_Bytes & 0x4000) >> 8; config->szTableReadProtected += (Data_Bytes & 0x000F); break; } Address += 2; } if (Record_Type == EXTENDED_LINEAR_ADRESS_RECORD) { AddressExtended = ((Data_Bytes) & 0xFF00) >> 8; AddressExtended = AddressExtended + (((Data_Bytes) & 0xFF) << 8); AddressExtended = AddressExtended << 16; } Checksum = 0xFF - Checksum + 1; if (CompareChecksum(fd) == KO) return(KO); } REACH_END_OF_LINE(Record_Type,next,fd); } return(OK); } /*********************************************************************** * Build a INTEL HEX file from config structure. * Compute checksum for only one line. * * @param FILE *fd IN HEX filename to write in * @param pConfigWord_t cfg IN Reference to the config structure * @return void **********************************************************************/ void HexUnParserConfig(FILE *fd, pConfigWord_t cfg) { unsigned char Record_Marker; unsigned char Record_Lenght; unsigned short Address; unsigned char Record_Type; unsigned short word; Checksum = 0; /******* Set EXTENDED_LINEAR_ADRESS_RECORD to 0x300000 ****************/ SetNextChar (fd, ':'); SetNextByte (fd, 0x02); SetNextShortUnSwap(fd, 0x00); SetNextByte (fd, EXTENDED_LINEAR_ADRESS_RECORD); SetNextShortUnSwap(fd, 0x0030); Checksum = 0xFF - Checksum + 1; SetNextByte(fd, Checksum); SetCR(fd); Record_Marker = ':'; Record_Type = DATA_RECORD; Checksum = 0; Address = 0; Record_Lenght = 0x0E; SetNextChar (fd, Record_Marker); SetNextByte (fd, Record_Lenght); SetNextShortUnSwap(fd, Address); SetNextByte (fd, Record_Type); word = ((((cfg->szOscsen ? 0 : 1) << 13) + (cfg->szFosc << 8)) & (0x2700)); ((cfg->szCodeProtected) & (0x00FF)); SetNextShort(fd, word); word = (((cfg->szWdtps << 9) + (cfg->szWdten << 8)) & (0x0F00)) + \ (((cfg->szBorv << 2) + (cfg->szBoren << 1)) & (0x000E))+ \ ( (cfg->szPwrten) ? 0 : 1); SetNextShort(fd, word); word = (cfg->szCcp2mx << 8) & (0x0100); SetNextShort(fd, word); word = ((cfg->szStvren) & (0x0001)) + ((cfg->szLVP << 2) & (0x0004)) + \ (((cfg->szDebug ? 0 : 1) << 7) & (0x0080)); SetNextShort(fd, word); word = ((cfg->szCodeProtected) & (0x000F)) + (((cfg->szCodeProtected) & (0x00C0)) << 8); SetNextShort(fd, word); word = ((cfg->szWriteProtected) & (0x000F)) + (((cfg->szWriteProtected) & (0x00E0)) << 8); SetNextShort(fd, word); word = ((cfg->szTableReadProtected) & (0x000F)) + (((cfg->szTableReadProtected) & (0x0040)) << 8); SetNextShort(fd, word); Checksum = 0xFF - Checksum + 1; SetNextByte(fd, Checksum); SetCR(fd); } /*********************************************************************** * Build a INTEL HEX file from ID structure. * Compute checksum for only one line. * * @param FILE *fd IN HEX filename to write in * @param pHexFile_t p_hfFile IN HEX structure reference * @return void **********************************************************************/ void HexUnParserID(FILE *fd, pHexFile_t p_hfFile) { unsigned char Record_Marker; unsigned char Record_Lenght; unsigned short Address; unsigned char Record_Type; unsigned short word; unsigned char i; Checksum = 0; /******* Set EXTENDED_LINEAR_ADRESS_RECORD to 0x200000 ****************/ SetNextChar (fd, ':'); SetNextByte (fd, 0x02); SetNextShortUnSwap(fd, 0x00); SetNextByte (fd, EXTENDED_LINEAR_ADRESS_RECORD); SetNextShortUnSwap(fd, 0x0020); Checksum = 0xFF - Checksum + 1; SetNextByte(fd, Checksum); SetCR(fd); Record_Marker = ':'; Record_Type = DATA_RECORD; Checksum = 0; Address = 0; Record_Lenght = 0x08; SetNextChar (fd, Record_Marker); SetNextByte (fd, Record_Lenght); SetNextShortUnSwap(fd, Address); SetNextByte (fd, Record_Type); for (i = 0; i < 4; i++) { word = (p_hfFile->szIdValue[i*2+1] << 8) + p_hfFile->szIdValue[i*2]; SetNextShort(fd, word); } Checksum = 0xFF - Checksum + 1; SetNextByte(fd, Checksum); SetCR(fd); } /*********************************************************************** * Parse a INTEL HEX file to extract the ID values. * * @param FILE *fd IN HEX filename to write in * @param pHexFile_t p_hfFile IN HEX structure reference * @return int OK if sucessfull * KO if checksum error occurs **********************************************************************/ int HexParserID(FILE *fd, pHexFile_t p_hfFile) { unsigned char Record_Marker; unsigned char Record_Lenght; unsigned int Address; unsigned int AddressExtended; unsigned char Record_Type; unsigned short Data_Bytes; unsigned char i, next; AddressExtended = 0; Record_Marker = ':'; Checksum = 0; Record_Type = DATA_RECORD; while (Record_Type != END_OF_FILE_RECORD) { Record_Marker = GetNextChar(fd); while (Record_Marker == ';') REACH_END_OF_LINE(Record_Type,next,fd); if (Record_Marker != ':') return (0); Checksum = 0; Record_Lenght = GetNextByte(fd); Address = GetNextShortUnSwap(fd); Record_Type = GetNextByte(fd); Address = AddressExtended + Address; /******* Program code or extended address only **********************/ if ((Address >= 0x200000) || (Record_Type == EXTENDED_LINEAR_ADRESS_RECORD)) { for (i = 0; i < (Record_Lenght / 2); i++) { Data_Bytes = GetNextShort(fd); if (Record_Type == DATA_RECORD) if ((Address >= 0x200000) && (Address <= 0x200008)) { p_hfFile->szIdValue[Address - 0x200000] = Data_Bytes & 0x00FF; p_hfFile->szIdValue[Address - 0x200000 + 1] = (Data_Bytes & 0xFF00) >> 8; } Address += 2; } if (Record_Type == EXTENDED_LINEAR_ADRESS_RECORD) { AddressExtended = ((Data_Bytes) & 0xFF00) >> 8; AddressExtended = AddressExtended + (((Data_Bytes) & 0xFF) << 8); AddressExtended = AddressExtended << 16; } Checksum = 0xFF - Checksum + 1; if (CompareChecksum(fd) == KO) return(KO); } REACH_END_OF_LINE(Record_Type,next,fd); } return(OK); } /*********************************************************************** * Switch on an IO pin of the parallel port. * * @param PIN_LABEL name IN Signal name * @return void **********************************************************************/ void TestIO_ON(PIN_LABEL name) { SetBit(name); } /*********************************************************************** * Switch off an IO pin of the parallel port. * * @param PIN_LABEL name IN Signal name * @return void **********************************************************************/ void TestIO_OFF(PIN_LABEL name) { ClearBit(name); } /*********************************************************************** * Assign an IO pin of the parallel port as an ICSP IO. * * @param PIN_LABEL name IN Signal name * @param u_char ucMask IN Signal mask * @param u_char ucStatus IN Signal status * @return void **********************************************************************/ void Settings(PIN_LABEL name, unsigned char mask, unsigned char status) { ConfigBit(name, mask, status); } /*********************************************************************** * Get the mask and status of a signal. * * @param PIN_LABEL name IN Signal name * @param u_char *ucMask IN Signal mask * @param u_char *ucStatus IN Signal status * @return void **********************************************************************/ void ReadSettings(PIN_LABEL name, unsigned char *ucMask, unsigned char *ucStatus) { *ucMask = GetMask(name); *ucStatus = GetStatus(name); } /*********************************************************************** * Read Data From Pic signal from parallel port. * * @param u_char *p_puszValue IN Reference to the checksum computed * @return void **********************************************************************/ void ReadDataFromPic(unsigned char *pucValue) { if(!pucValue) return; *pucValue = (unsigned char)(ReadBit(PL_DATA_FROM_PIC)); } /*********************************************************************** * Extract the checksum info from every line of an INTEL HEX file. * Compare it with the value computed by the HEX parser. * * @param FILE *fd IN file descriptor * @return unsigned char OK if sucessfull * KO if checksum error occurs **********************************************************************/ unsigned char CompareChecksum(FILE *fd) { if (((GetNextChar(fd) << 4) + GetNextChar(fd)) != Checksum) return (KO); else return (OK); } /*********************************************************************** * Read the next short from an INTEL HEX file line. * Swap the low and hight bytes of the short. * * @param FILE *fd IN file descriptor * @return u_short value Data read from the file **********************************************************************/ unsigned short GetNextShort(FILE *fd) { unsigned short value; value = GetNextByte(fd) + (GetNextByte(fd) << 8); return (value); } /*********************************************************************** * Read the next short from an INTEL HEX file line. * Do not swap the low and hight bytes of the short. * * @param FILE *fd IN file descriptor * @return u_short value Data read from the file **********************************************************************/ unsigned short GetNextShortUnSwap(FILE *fd) { unsigned short value; value = (GetNextByte(fd) << 8) + GetNextByte(fd); return (value); } /*********************************************************************** * Write the next short into an INTEL HEX file. * Swap the low and hight bytes of the short. * * @param FILE *fd IN file descriptor * @param u_short value IN Data to write into the file * @return void **********************************************************************/ void SetNextShort(FILE *fd, unsigned short value) { SetNextByte(fd, (unsigned char)(value & 0xFF)); SetNextByte(fd, (unsigned char)((value >> 8) & 0xFF)); return; } /*********************************************************************** * Write the next short into an INTEL HEX file. * Do not swap the low and hight bytes of the short. * * @param FILE *fd IN file descriptor * @param u_short value IN Data to write into the file * @return void **********************************************************************/ void SetNextShortUnSwap(FILE *fd, unsigned short value) { SetNextByte(fd, (unsigned char)((value >> 8) & 0xFF)); SetNextByte(fd, (unsigned char)(value & 0xFF)); return; } /*********************************************************************** * Read the next char from an INTEL HEX file line. * * @param FILE *fd IN file descriptor * @return u_char value Data read from the file **********************************************************************/ unsigned char GetNextByte(FILE *fd) { unsigned char value; value = (GetNextChar(fd) << 4) + GetNextChar(fd); Checksum += value; return (value); } /*********************************************************************** * Write the next char into an INTEL HEX file. * * @param FILE *fd IN file descriptor * @param u_char value IN Data to write into the file * @return void **********************************************************************/ void SetNextByte(FILE *fd, unsigned char value) { SetNextChar(fd, (unsigned char)((value >> 4) & 0x0F)); SetNextChar(fd, (unsigned char)(value & 0x0F)); Checksum += value; return; } /*********************************************************************** * Extract 8 bits data from a file. * Convert data from dec to hex. * * @param FILE *fd IN file descriptor * @return u_char value Data read from the file **********************************************************************/ unsigned char GetNextChar(FILE *fd) { unsigned char value; value = fgetc(fd); if ((value >= '0') && (value <= '9')) return (value - '0'); if ((value >= 'a') && (value <= 'f')) return (value - 'a' + 10); if ((value >= 'A') && (value <= 'F')) return (value - 'A' + 10); if (value == '\n') value = END_OF_LINE; if (feof(fd)) value = END_OF_FILE; return (value); } /*********************************************************************** * Write 8 bits data into a file. * Convert data from dec to hex. * * @param FILE *fd IN file descriptor * @param u_char value IN Data to write into the file * @return void **********************************************************************/ void SetNextChar(FILE *fd, unsigned char value) { if (value <= 9) value = (value + '0'); if ((value >= 0x0a) && (value <= 0x0f)) value = (value + 'A' - 10); putc(value, fd); return; } /*********************************************************************** * Write a CR to the end of a file. * * @param FILE *fd IN file descriptor * @return void **********************************************************************/ void SetCR(FILE *fd) { putc('\n', fd); return; } /*********************************************************************** * Compute a checksum of all the program memory. * * @param pHexFile_t p_hfFile IN HEX structure reference * @return unsigned short Checksum computed (16 bits long) **********************************************************************/ unsigned short ComputeMemChecksum(pHexFile_t p_hfFile) { unsigned int i; unsigned short temp1, temp2; unsigned short result; unsigned short *pusMem; pusMem = p_hfFile->pusMemory; result = 0; for (i = 0; i < p_hfFile->uiMemorySize; i++) { temp1 = *(pusMem) & 0x00FF; temp2 = *(pusMem++) & 0xFF00; result += (temp1 + (temp2 >> 8)); } return(result); } /*********************************************************************** * Compute a checksum of all the config memory. * * @param pHexFile_t p_hfFile IN HEX structure reference * @return unsigned short Checksum computed (16 bits long) **********************************************************************/ unsigned short ComputeConfigChecksum(pHexFile_t p_hfFile) { unsigned short config1L, config2L, config3L, config4L, config5L, config6L, config7L; unsigned short config1H, config2H, config3H, config4H, config5H, config6H, config7H; unsigned short result; config1L = 0x00; config1H = (((p_hfFile->pConfig->szOscsen ? 0 : 1) << 5) + \ p_hfFile->pConfig->szFosc) & 0x27; config2L = ((p_hfFile->pConfig->szBorv << 2) + (p_hfFile->pConfig->szBoren << 1) + \ ( (p_hfFile->pConfig->szPwrten) ? 0 : 1)) & 0x0F; config2H = ((p_hfFile->pConfig->szWdtps << 1) + p_hfFile->pConfig->szWdten) & 0x0F; config3L = 0x00; config3H = (p_hfFile->pConfig->szCcp2mx) & 0x01; config4L = ((p_hfFile->pConfig->szStvren) & 0x01) + \ ((p_hfFile->pConfig->szLVP) << 2 ) + \ ((p_hfFile->pConfig->szDebug ? 0 : 1) << 7 ); config4H = 0x00; config5L = p_hfFile->pConfig->szCodeProtected & 0x0F; config5H = p_hfFile->pConfig->szCodeProtected & 0xC0; config6L = p_hfFile->pConfig->szWriteProtected & 0x0F; config6H = p_hfFile->pConfig->szWriteProtected & 0xE0; config7L = p_hfFile->pConfig->szTableReadProtected & 0x0F; config7H = p_hfFile->pConfig->szTableReadProtected & 0x40; result = config1L + config1H + config2L + config2H + config3L + config3H + \ config4L + config4H + config5L + config5H + config6L + config6H + \ config7L + config7H; return(result); } /*********************************************************************** * Compute a checksum of 4 lower bits of the ID location. * * @param pHexFile_t p_hfFile IN HEX structure reference * @return unsigned short Checksum computed (16 bits long) **********************************************************************/ unsigned short ComputeIDChecksum(pHexFile_t p_hfFile) { unsigned int i; unsigned char temp; unsigned short result; result = 0; for (i = 0; i < 8; i++) { temp = p_hfFile->szIdValue[i] & 0x0F; result += temp; } return(result); } #pragma warning(default: 4700)