File "DLL_interface.c"
Full Path: /home/analogde/www/PIC18F452/DLL_interface.c
File size: 28.36 KB
MIME-type: text/x-c
Charset: utf-8
/**********************************************************************/
/* */
/* File name: DLL_interface.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 <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <string.h>
#include "DLL_interface.h"
/***********************************************************************
* DEFINES.
**********************************************************************/
/******* Defines dedicated to this PIC ********************************/
#define _DEFAULT_PATTERN_ 0xFF
#define _MAX_PIC_SIZE 0x4000
/***********************************************************************
* Function prototypes.
**********************************************************************/
void ProgressWindow_Show(pHexFile_t p_hfFile, unsigned int Read_Write);
void DLLAboutWindow_Show(void);
void SettingsWindow_Show(void);
void ConfigWindow_Show(unsigned int uiFrom);
/***********************************************************************
* Global variables.
**********************************************************************/
/******* Structures for data from/to PIC or file **********************/
HexFile_t HEX_from_file;
HexFile_t HEX_from_PIC;
unsigned short MemFile[_MAX_PIC_SIZE];
unsigned short MemPIC[_MAX_PIC_SIZE];
ConfigWord_t CFG_File;
ConfigWord_t CFG_PIC;
extern unsigned int IsLocked;
/******* Structure related to statistics if necessary *****************/
Statistic_t Stat;
/******* Checksum computation from file or PIC content ****************/
unsigned char Checksum;
/***********************************************************************
* Only fill the SHexFile structure. Do not proceed to any programming
* sequences. This function fills the Hex_from_file structure, so it has
* to be called first to initialyze.
*
* @param char *ucFilename IN HEX filename to parse
* @return Status_t FILE_ERROR if something wrong appends
* (Hex larger than PIC memory size)
* ALL_RIGHT otherwise
**********************************************************************/
Status_t DLL_EXPORT ParseFile(char *ucFilename)
{
FILE *fd;
pHexFile_t p_hfFile;
pStatistic_t p_Stat;
unsigned short usChecksum;
/******* Build the HEX_file_file structure ****************************/
p_hfFile = &HEX_from_file;
p_Stat = &Stat;
p_hfFile->pusMemory = &MemFile[0];
p_hfFile->pConfig = &CFG_File;
p_hfFile->uiMemorySize = _MAX_PIC_SIZE;
memset(p_hfFile->pusMemory, 0xFF, _MAX_PIC_SIZE * sizeof(unsigned short));
/*memset(p_hfFile->pConfig, 0xFF, sizeof(ConfigWord_t));*/
if (IsLocked == 0)
{
p_hfFile->pConfig->szFosc = 0x07;
p_hfFile->pConfig->szOscsen = 0x00;
p_hfFile->pConfig->szPwrten = 0x00;
p_hfFile->pConfig->szBoren = 0x01;
p_hfFile->pConfig->szBorv = 0x03;
p_hfFile->pConfig->szWdten = 0x01;
p_hfFile->pConfig->szWdtps = 0x07;
p_hfFile->pConfig->szCcp2mx = 0x01;
p_hfFile->pConfig->szStvren = 0x01;
p_hfFile->pConfig->szLVP = 0x01;
p_hfFile->pConfig->szDebug = 0x00;
p_hfFile->pConfig->szCodeProtected = 0xCF;
p_hfFile->pConfig->szWriteProtected = 0xEF;
p_hfFile->pConfig->szTableReadProtected = 0x4F;
}
/*memset(p_hfFile->pConfig, 0xFF, sizeof(ConfigWord_t));*/
memset(p_hfFile->szIdValue, 0xFF, 8);
p_hfFile->SChipStatus = 0;
fd = fopen((const char*)ucFilename, "r");
if (fd == NULL)
{
p_hfFile->SChipStatus = 1;
fclose(fd);
return(p_hfFile->SChipStatus);
}
else
p_hfFile->SChipStatus = 0;
/******* Parse the HEX file and fill the memory field of the structure*/
if ( !HexParserMemory(fd, p_hfFile->pusMemory, &(p_Stat->uiNbWord2BeProgrammed) ))
{
p_hfFile->SChipStatus = 1;
fclose(fd);
return(p_hfFile->SChipStatus);
}
if (p_hfFile->uiMemorySize < p_Stat->uiNbWord2BeProgrammed)
p_hfFile->SChipStatus = 1;
/******* Parse the HEX file and fill the config field of the structure*/
if (IsLocked == 0)
{
fseek(fd, 0, SEEK_SET);
if ( !HexParserConfig(fd, p_hfFile->pConfig) )
{
p_hfFile->SChipStatus = 1;
fclose(fd);
return(p_hfFile->SChipStatus);
}
}
/******* Parse the HEX file and fill the ID field of the structure ****/
fseek(fd, 0, SEEK_SET);
if ( !HexParserID(fd, p_hfFile) )
{
p_hfFile->SChipStatus = 1;
fclose(fd);
return(p_hfFile->SChipStatus);
}
/******* Checksum computed from Memory + Config + ID ******************/
ComputeGeneralChecksum(&usChecksum, FromFile);
fclose(fd);
return(p_hfFile->SChipStatus);
}
/***********************************************************************
* Give the memory size of the chip (and not the memory size of usefull
* data inside the PIC), or the data size of the HEX file parsed.
*
* @param u_int *uiSize OUT PIC memory size
* @param u_int uiFrom IN Flag (PIC or File)
* @return Status_t Always ALL_RIGHT
**********************************************************************/
Status_t DLL_EXPORT GetMemorySize(unsigned int *uiSize, unsigned int uiFrom)
{
pHexFile_t p_hfFile;
if (uiFrom == FromPIC)
p_hfFile = &HEX_from_PIC;
else
p_hfFile = &HEX_from_file;
*uiSize = p_hfFile->uiMemorySize;
return(0);
}
/***********************************************************************
* Copy the memory content from the PIC or FILE structure to the buffer
* parameter.
*
* @param u_short *usMemory OUT Memory buffer
* @param u_int uiFrom IN Flag (PIC or File)
* @return Status_t Always ALL_RIGHT
**********************************************************************/
Status_t DLL_EXPORT GetMemoryBuffer(unsigned short *usMemory, unsigned int uiFrom)
{
pHexFile_t p_hfFile;
if (uiFrom == FromPIC)
p_hfFile = &HEX_from_PIC;
else
p_hfFile = &HEX_from_file;
memcpy(usMemory, p_hfFile->pusMemory, p_hfFile->uiMemorySize * sizeof(unsigned short));
return(0);
}
/***********************************************************************
* Copy the memory content from the buffer to the PIC or FILE structure.
*
* @param u_short *usMemory IN Memory buffer
* @param u_int uiFrom IN Flag (PIC or File)
* @return Status_t Always ALL_RIGHT
**********************************************************************/
Status_t DLL_EXPORT SetMemoryBuffer(unsigned short *usMemory, unsigned int uiFrom)
{
pHexFile_t p_hfFile;
if (uiFrom == FromPIC)
p_hfFile = &HEX_from_PIC;
else
p_hfFile = &HEX_from_file;
memcpy(p_hfFile->pusMemory, usMemory, p_hfFile->uiMemorySize * sizeof(unsigned short));
return(0);
}
/***********************************************************************
* Rebuil a HEX File from memory, config and ID. Do not proceed to any
* programming sequences. This function creats a new HEX file a replace
* an existing one.
*
* @param char *ucFilename IN HEX filename to build
* @param u_int uiFrom IN Flag (PIC or File)
* @return Status_t FILE_ERROR if something wrong appends
* (cannot creat a new file)
* ALL_RIGHT otherwise
**********************************************************************/
Status_t DLL_EXPORT UnParseFile(char *ucFilename, unsigned int uiFrom)
{
FILE *fd;
pHexFile_t p_hfFile;
if (uiFrom == FromPIC)
p_hfFile = &HEX_from_PIC;
else
p_hfFile = &HEX_from_file;
p_hfFile->SChipStatus = 0;
fd = fopen((const char*)ucFilename, "w");
if (fd == NULL)
{
p_hfFile->SChipStatus = 1;
return(p_hfFile->SChipStatus);
}
/******* Build HEX file from Memory, config and ID ********************/
HexUnParserMemory(fd, p_hfFile->pusMemory, p_hfFile->uiMemorySize * sizeof(unsigned short));
HexUnParserConfig(fd, p_hfFile->pConfig);
HexUnParserID(fd, p_hfFile);
/******* END_OF_FILE_RECORD *******************************************/
SetNextChar (fd, ':');
SetNextByte (fd, 0x00);
SetNextShortUnSwap(fd, 0x00);
SetNextByte (fd, END_OF_FILE_RECORD);
SetNextByte(fd, 0xFF);
SetCR(fd);
fclose(fd);
return(p_hfFile->SChipStatus);
}
/***********************************************************************
* Perform a programmation process to the hardware programmer and the
* chip on it concerning memory area only.
*
* @param u_int uiFrom IN Flag (PIC or File)
* @return Status_t BAD_PROGRAMMED if something wrong appends
* PROGRAMMED if not
* ALL_RIGHT otherwise
**********************************************************************/
Status_t DLL_EXPORT ProgramMem(unsigned int uiFrom)
{
pHexFile_t p_hfFile;
if (uiFrom == FromPIC)
p_hfFile = &HEX_from_PIC;
else
p_hfFile = &HEX_from_file;
p_hfFile->SChipStatus = 0;
BulkErase();
ProgressWindow_Show(p_hfFile, DISPLAY_WRITE);
return(p_hfFile->SChipStatus);
}
/***********************************************************************
* Perform a programmation process to the hardware programmer and the
* chip on it concerning config area only.
*
* @param u_int uiFrom IN Flag (PIC or File)
* @return Status_t BAD_PROGRAMMED if something wrong appends
* PROGRAMMED if not
* ALL_RIGHT otherwise
**********************************************************************/
Status_t DLL_EXPORT ProgramConfig(unsigned int uiFrom)
{
unsigned int total_try, word_programmed;
unsigned short word;
pHexFile_t p_hfFile;
pStatistic_t p_Stat;
if (uiFrom == FromPIC)
p_hfFile = &HEX_from_PIC;
else
p_hfFile = &HEX_from_file;
p_Stat = &Stat;
p_hfFile->SChipStatus = 0;
p_Stat->uiNbWord2BeProgrammed = 4;
word = 0x00;
ProgramBlockCfg(0x300000, &word, 1, &total_try, &word_programmed);
word = ((p_hfFile->pConfig->szOscsen ? 0 : 1) << 13) + (p_hfFile->pConfig->szFosc << 8);
ProgramBlockCfg(0x300001, &word, 1, &total_try, &word_programmed);
p_Stat->uiTotalTry = total_try;
p_Stat->uiNbWordProgrammed = word_programmed;
word = (p_hfFile->pConfig->szBorv << 2) + (p_hfFile->pConfig->szBoren << 1) + \
( (p_hfFile->pConfig->szPwrten) ? 0 : 1);
ProgramBlockCfg(0x300002, &word, 1, &total_try, &word_programmed);
p_Stat->uiTotalTry += total_try;
p_Stat->uiNbWordProgrammed += word_programmed;
word = (p_hfFile->pConfig->szWdtps << 9) + (p_hfFile->pConfig->szWdten << 8);
ProgramBlockCfg(0x300003, &word, 1, &total_try, &word_programmed);
p_Stat->uiTotalTry += total_try;
p_Stat->uiNbWordProgrammed += word_programmed;
word = 0x00;
ProgramBlockCfg(0x300004, &word, 1, &total_try, &word_programmed);
p_Stat->uiTotalTry += total_try;
p_Stat->uiNbWordProgrammed += word_programmed;
word = p_hfFile->pConfig->szCcp2mx << 8;
ProgramBlockCfg(0x300005, &word, 1, &total_try, &word_programmed);
p_Stat->uiTotalTry += total_try;
p_Stat->uiNbWordProgrammed += word_programmed;
word = (p_hfFile->pConfig->szStvren) + ((p_hfFile->pConfig->szDebug ? 0 : 1) << 7) + \
(p_hfFile->pConfig->szLVP << 2);
ProgramBlockCfg(0x300006, &word, 1, &total_try, &word_programmed);
p_Stat->uiTotalTry += total_try;
p_Stat->uiNbWordProgrammed += word_programmed;
word = 0x00;
ProgramBlockCfg(0x300007, &word, 1, &total_try, &word_programmed);
p_Stat->uiTotalTry += total_try;
p_Stat->uiNbWordProgrammed += word_programmed;
word = (p_hfFile->pConfig->szCodeProtected & 0x0F);
ProgramBlockCfg(0x300008, &word, 1, &total_try, &word_programmed);
p_Stat->uiTotalTry += total_try;
p_Stat->uiNbWordProgrammed += word_programmed;
word = (p_hfFile->pConfig->szCodeProtected & 0xC0) << 8;
ProgramBlockCfg(0x300009, &word, 1, &total_try, &word_programmed);
p_Stat->uiTotalTry += total_try;
p_Stat->uiNbWordProgrammed += word_programmed;
word = (p_hfFile->pConfig->szWriteProtected & 0x0F);
ProgramBlockCfg(0x30000A, &word, 1, &total_try, &word_programmed);
p_Stat->uiTotalTry += total_try;
p_Stat->uiNbWordProgrammed += word_programmed;
word = (p_hfFile->pConfig->szWriteProtected & 0xE0) << 8;
ProgramBlockCfg(0x30000B, &word, 1, &total_try, &word_programmed);
p_Stat->uiTotalTry += total_try;
p_Stat->uiNbWordProgrammed += word_programmed;
word = (p_hfFile->pConfig->szTableReadProtected & 0x0F);
ProgramBlockCfg(0x30000C, &word, 1, &total_try, &word_programmed);
p_Stat->uiTotalTry += total_try;
p_Stat->uiNbWordProgrammed += word_programmed;
word = (p_hfFile->pConfig->szTableReadProtected & 0x40) << 8;
ProgramBlockCfg(0x30000D, &word, 1, &total_try, &word_programmed);
p_Stat->uiTotalTry += total_try;
p_Stat->uiNbWordProgrammed += word_programmed;
if (p_Stat->uiNbWordProgrammed != p_Stat->uiNbWord2BeProgrammed)
p_hfFile->SChipStatus = 5;
else
p_hfFile->SChipStatus = 4;
return(p_hfFile->SChipStatus);
}
/***********************************************************************
* Perform a programmation process to the hardware programmer and the
* chip on it concerning ID area only.
*
* @param u_int uiFrom IN Flag (PIC or File)
* @return Status_t BAD_PROGRAMMED if something wrong appends
* PROGRAMMED if not
* ALL_RIGHT otherwise
**********************************************************************/
Status_t DLL_EXPORT ProgramID(unsigned int uiFrom)
{
unsigned int total_try, word_programmed, i;
unsigned short word[4];
pHexFile_t p_hfFile;
pStatistic_t p_Stat;
if (uiFrom == FromPIC)
p_hfFile = &HEX_from_PIC;
else
p_hfFile = &HEX_from_file;
p_Stat = &Stat;
p_hfFile->SChipStatus = 0;
p_Stat->uiNbWord2BeProgrammed = 4;
for (i = 0; i < p_Stat->uiNbWord2BeProgrammed; i++)
{
word[i] = (p_hfFile->szIdValue[i*2+1] << 8) + p_hfFile->szIdValue[i*2];
}
ProgramBlock(0x200000, word, 4, &total_try, &word_programmed);
p_Stat->uiTotalTry = total_try;
p_Stat->uiNbWordProgrammed = word_programmed;
if (p_Stat->uiNbWordProgrammed != p_Stat->uiNbWord2BeProgrammed)
p_hfFile->SChipStatus = 5;
else
p_hfFile->SChipStatus = 4;
return(p_hfFile->SChipStatus);
}
/***********************************************************************
* Download the code memory field from the PIC device, and update the
* PIC structure.
*
* @param void
* @return Status_t BLANK if all memory set to 0xFFFF
* NOT_BLANK if not
* ALL_RIGHT otherwise
**********************************************************************/
Status_t DLL_EXPORT ReadMem(void)
{
unsigned int i;
pHexFile_t p_hfFile;
p_hfFile = &HEX_from_PIC;
p_hfFile->SChipStatus = 0;
ProgressWindow_Show(p_hfFile, DISPLAY_READ);
if (p_hfFile->SChipStatus == 10) /* ABORTED */
return(p_hfFile->SChipStatus);
p_hfFile->SChipStatus = 3; /* BLANK */
for (i = 0; i < p_hfFile->uiMemorySize; i++)
{
if (p_hfFile->pusMemory[i] != 0xFFFF)
p_hfFile->SChipStatus = 2; /* NOT BLANK */
}
return(p_hfFile->SChipStatus);
}
/***********************************************************************
* Download the config field from the PIC device, and update the PIC
* structure.
*
* @param void
* @return Status_t LOCKED if Code Prection ON
* ALL_RIGHT otherwise
**********************************************************************/
Status_t DLL_EXPORT ReadConfig(void)
{
unsigned short word;
pHexFile_t p_hfFile;
pStatistic_t p_Stat;
p_hfFile = &HEX_from_PIC;
p_Stat = &Stat;
p_hfFile->SChipStatus = 0;
ReadBlock(0x300000, &word, 1);
p_hfFile->pConfig->szFosc = (word & 0x0700) >> 8;
p_hfFile->pConfig->szOscsen = (word & 0x2000) ? 0: 1;
ReadBlock(0x300002, &word, 1);
p_hfFile->pConfig->szPwrten = (word & 0x0001) ? 0: 1;
p_hfFile->pConfig->szBoren = (word & 0x0002) ? 1: 0;
p_hfFile->pConfig->szBorv = (word & 0x000C) >> 2;
p_hfFile->pConfig->szWdten = (word & 0x0100) >> 8;
p_hfFile->pConfig->szWdtps = (word & 0x0E00) >> 9;
ReadBlock(0x300004, &word, 1);
p_hfFile->pConfig->szCcp2mx = (word & 0x0100) >> 8;
ReadBlock(0x300006, &word, 1);
p_hfFile->pConfig->szDebug = (word & 0x0080) ? 0 : 1;
p_hfFile->pConfig->szLVP = (word & 0x0004) >> 2;
p_hfFile->pConfig->szStvren = word & 0x0001;
ReadBlock(0x300008, &word, 1);
p_hfFile->pConfig->szCodeProtected = (word & 0x000F) + ((word & 0xC000) >> 8);
ReadBlock(0x30000A, &word, 1);
p_hfFile->pConfig->szWriteProtected = (word & 0x000F) + ((word & 0xE000) >> 8);
ReadBlock(0x30000C, &word, 1);
p_hfFile->pConfig->szTableReadProtected = (word & 0x000F) + ((word & 0x4000) >> 8);
if (p_hfFile->pConfig->szCodeProtected != 0xCF)
p_hfFile->SChipStatus = 6;
return(p_hfFile->SChipStatus);
}
/***********************************************************************
* Download the ID field from the PIC device, and update the PIC
* structure.
*
* @param void
* @return Status_t Always ALL_RIGHT
**********************************************************************/
Status_t DLL_EXPORT ReadID(void)
{
unsigned short word;
pHexFile_t p_hfFile;
pStatistic_t p_Stat;
p_hfFile = &HEX_from_PIC;
p_Stat = &Stat;
ReadBlock(0x200000, &word, 1);
p_hfFile->szIdValue[0] = word & 0x00FF;
p_hfFile->szIdValue[1] = (word & 0xFF00) >> 8;
ReadBlock(0x200002, &word, 1);
p_hfFile->szIdValue[2] = word & 0x00FF;
p_hfFile->szIdValue[3] = (word & 0xFF00) >> 8;
ReadBlock(0x200004, &word, 1);
p_hfFile->szIdValue[4] = word & 0x00FF;
p_hfFile->szIdValue[5] = (word & 0xFF00) >> 8;
ReadBlock(0x200006, &word, 1);
p_hfFile->szIdValue[6] = word & 0x00FF;
p_hfFile->szIdValue[7] = (word & 0xFF00) >> 8;
return(0);
}
/***********************************************************************
* Download REV+DEV from the chip present in the device chip.
* This function fills the Hex_from_file structure, so it has
* to be called first to initialyze the PIC structure.
*
* @param char *PICname IN PIC name reference (name of DLL)
* @return Status_t PIC_DETECTED if right PIC detected
* HARDWARE_ERROR if not detected
**********************************************************************/
Status_t DLL_EXPORT ReadRevDev(char *PICname)
{
pHexFile_t p_hfFile;
pStatistic_t p_Stat;
unsigned short usWord, usRev, usDev;
static unsigned int uiDetected = 0;
char thePICname[10] = "PIC18F452";
p_hfFile = &HEX_from_PIC;
p_Stat = &Stat;
p_hfFile->SChipStatus = 0;
PowerOn();
ReadBlock(0x3FFFFE, &usWord, 1);
PowerOff();
usRev = usWord & 0x1F;
usDev = ((usWord & 0xE0) >> 5) + ((usWord & 0xFF00) >> 5);
if (usRev == 0x1F)
p_hfFile->SChipStatus = 8;
if ((usDev & 0x07FF) == 0x21)
{
p_hfFile->SChipStatus = 7;
if (uiDetected == 0)
{
p_hfFile->pusMemory = &MemPIC[0];
p_hfFile->pConfig = &CFG_PIC;
p_hfFile->uiMemorySize = _MAX_PIC_SIZE;
memset(p_hfFile->pusMemory, 0xFF, p_hfFile->uiMemorySize * sizeof(unsigned short));
memset(p_hfFile->pConfig, 0xFF, sizeof(pConfigWord_t));
memset(p_hfFile->szIdValue, 0xFF, 8);
p_hfFile->pConfig->szRev = (unsigned char)(usRev);
p_hfFile->pConfig->usDev = usDev;
strcpy(PICname, thePICname);
uiDetected = 1;
}
}
// else
// uiDetected = 0;
return(p_hfFile->SChipStatus);
}
/***********************************************************************
* Get the ID field of the structure specify by uiFrom with the ucValue.
* The field is 8 bytes long, so just the byte specified by ucIndex is
* modified.
*
* @param u_char *ucValue IN Value of the ID to get at ucIndex pos
* @param u_char ucIndex IN Index of the ID to get
* @param u_int uiFrom IN Flag (PIC or File)
* @return Status_t Always ALL_RIGHT
**********************************************************************/
Status_t DLL_EXPORT GetIDValue(unsigned char *ucValue, unsigned char ucIndex, unsigned int uiFrom)
{
pHexFile_t p_hfFile;
if (ucIndex > 7)
return(9);
if (uiFrom == FromPIC)
p_hfFile = &HEX_from_PIC;
else
p_hfFile = &HEX_from_file;
*ucValue = p_hfFile->szIdValue[ucIndex];
return(0);
}
/***********************************************************************
* Fill the ID field of the structure specify by uiFrom with the ucValue.
* The field is 8 bytes long, so just the byte specified by ucIndex is
* modified.
*
* @param u_char ucValue IN Value of the ID to set at ucIndex pos
* @param u_char ucIndex IN Index of the ID to set
* @param u_int uiFrom IN Flag (PIC or File)
* @return Status_t Always ALL_RIGHT
**********************************************************************/
Status_t DLL_EXPORT SetIDValue(unsigned char ucValue, unsigned char ucIndex, unsigned int uiFrom)
{
pHexFile_t p_hfFile;
if (ucIndex > 7)
return(9);
if (uiFrom == FromPIC)
p_hfFile = &HEX_from_PIC;
else
p_hfFile = &HEX_from_file;
p_hfFile->szIdValue[ucIndex] = ucValue;
return(0);
}
/***********************************************************************
* Extract the checksum info from every line of an INTEL HEX file.
* Compare it with the value computed by the HEX parser.
*
* @param u_short *usChecksum IN Reference to the checksum computed
* @param u_int uiFrom IN Flag (PIC or File)
* @return Status_t Always ALL_RIGHT
**********************************************************************/
Status_t DLL_EXPORT ComputeGeneralChecksum(unsigned short *usChecksum, unsigned int uiFrom)
{
unsigned short result;
pHexFile_t p_hfFile;
if (uiFrom == FromPIC)
p_hfFile = &HEX_from_PIC;
else
p_hfFile = &HEX_from_file;
result = 0;
/* if (p_hfFile->pConfig->szCodeProtected == 0xCF)*/
result += ComputeMemChecksum(p_hfFile);
result += ComputeConfigChecksum(p_hfFile);
/* if (p_hfFile->pConfig->szCodeProtected != 0xCF)*/
result += ComputeIDChecksum(p_hfFile);
p_hfFile->usChecksum = result;
*usChecksum = result;
return (0);
}
/***********************************************************************
* Check the presence of a programmer on LPT port.
* Hardware present if DATA_FROM_PIC == DATA_TO_PIC[0 or 1]
*
* @param void
* @return Status_t ALL_RIGHT if hardware present
* HARDWARE_ERROR if not present
**********************************************************************/
Status_t DLL_EXPORT IsHWPresent(void)
{
unsigned char ucHWTestON, ucHWTestOFF;
InitHardware();
PowerOn();
TestIO_ON(PL_DATA_TO_PIC);
ReadDataFromPic(&ucHWTestON);
TestIO_OFF(PL_DATA_TO_PIC);
ReadDataFromPic(&ucHWTestOFF);
PowerOff();
if ((ucHWTestON != 0) && (ucHWTestOFF == 0))
return(0);
else
return(8);
}
/***********************************************************************
* Stuck at 0 all of the signals (logical 0, not necessarily physical 0).
*
* @param void
* @return Status_t Always ALL_RIGHT
**********************************************************************/
Status_t DLL_EXPORT InitHardware(void)
{
_InitHardware();
return(0);
}
/***********************************************************************
* Stuck at 1 the VCC signal (logical 1, not necessarily physical 1).
*
* @param void
* @return Status_t Always ALL_RIGHT
**********************************************************************/
Status_t DLL_EXPORT PowerOn(void)
{
_PowerOn();
return(0);
}
/***********************************************************************
* Stuck at 0 the VCC signal (logical 0, not necessarily physical 0).
*
* @param void
* @return Status_t Always ALL_RIGHT
**********************************************************************/
Status_t DLL_EXPORT PowerOff(void)
{
_PowerOff();
return(0);
}
/***********************************************************************
* About window of the DLL.
*
* @param HWND hWnd IN Handle of the main window
* @return Status_t Always ALL_RIGHT
**********************************************************************/
Status_t DLL_EXPORT ShowDLL(HWND hWnd)
{
DLLAboutWindow_Show();
return(0);
}
/***********************************************************************
* Show Settings window.
*
* @param HWND hWnd IN Handle of the main window
* @return Status_t Always ALL_RIGHT
**********************************************************************/
Status_t DLL_EXPORT ShowSettings(HWND hWnd)
{
SettingsWindow_Show();
return(0);
}
/***********************************************************************
* Display the "Config" window of the DLL.
*
* @param HWND hWnd IN Handle of the main window
* @return Status_t Always ALL_RIGHT
**********************************************************************/
Status_t DLL_EXPORT ShowConfig(HWND hWnd, unsigned int uiFrom)
{
ConfigWindow_Show(uiFrom);
return(0);
}
/***********************************************************************
* Erase all the programmable bits of the PIC18.
*
* @param HWND hWnd IN Handle of the main window
* @return Status_t Always ALL_RIGHT
**********************************************************************/
Status_t DLL_EXPORT DoBulkErase(HWND hWnd)
{
BulkErase();
return(0);
}
/***********************************************************************
* Set /MCLR to VDD to start the target.
*
* @param HWND hWnd IN Handle of the main window
* @return Status_t Always ALL_RIGHT
**********************************************************************/
Status_t DLL_EXPORT RunTarget(void)
{
TestIO_ON(PL_VPP);
return(0);
}
/* End of File */