File "Com.c"
Full Path: /home/analogde/www/PIC18F452/Com.c
File size: 28.51 KB
MIME-type: text/x-c
Charset: utf-8
/**********************************************************************/
/* */
/* 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)