matthias/diplomarbeit
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Moved remotely

Browse Source 
git-svn-id: file:///srv/dev-disk-by-uuid-17e88007-4d0c-45e0-8757-cacfcc458630/repositories/svn/Diplomarbeit@113 9fe90eed-be63-e94b-8204-d34ff4c2ff93
This commit is contained in:
Matthias
2009-01-12 08:38:14 +00:00
parent 4e45654a5f
commit 6cc948eef8
204 changed files with 0 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Tester/SW/Eclipse/lib/Drivers/calibrateaio.c
+769
View File
@@ -0,0 +1,769 @@
/* ---------------------------------------------------------------------------
* calibrateaio.c (c) 2008 Micro-key bv
* ---------------------------------------------------------------------------
* Micro-key bv
* Industrieweg 28, 9804 TG Noordhorn
* Postbus 92, 9800 AB Zuidhorn
* The Netherlands
* Tel: +31 594 503020
* Fax: +31 594 505825
* Email: support@microkey.nl
* Web: www.microkey.nl
* ---------------------------------------------------------------------------
* Description:
* ---------------------------------------------------------------------------
* Version(s): 0.1, Mei 22, 2008, MMi
* Creation.
* ---------------------------------------------------------------------------
*/
/* APPLICATION NOTES:
* Voltage Input Calibration: All Inputs need to be connected to the defined,
* preset Voltage Value (e.g. 10 V).
*
* Voltage Output Calibration: Output 0-3 need to be connected to own Inputs
* 0-3.
*
* Current Input Calibration: All Inputs need to be connected to the defined,
* preset Current Value (e.g. 20 mA per channel)
*
* Current Output Calibration: Output 0-3 need to be connected to own Inputs
* 0-3. All other Connections must be removed.
*/
/* ---------------------------------------------------------------------------
* System include files
* ---------------------------------------------------------------------------
*/
#include <stdlib.h>
#include "lpc23xx.h"
#include "types.h"
/* FreeRTOS includes */
#include "FreeRTOS.h"
#include "Task.h"
#include "semphr.h"
/* ---------------------------------------------------------------------------
* Application include files
* ---------------------------------------------------------------------------
*/
#include "calibrateaio.h"
#include "adc.h"
#include "dac.h"
#include "dio.h"
#include "eeprom.h"
#include "ssp0.h"
#include "BusProtocol.h"
#include "serial.h"
#include "SerOut.h"
/* ---------------------------------------------------------------------------
* Local constant and macro definitions
* ---------------------------------------------------------------------------
*/
#define NumberOfOutputChannels maxDAC_Channels /* See dac.h */
#define NumberOfInputChannels maxADC_Channels /* See adc.h */
#define MaximumCurrent 20000 /* Maximum driveable Current */
#define MaximumVoltage 10000 /* Maximum driveable Voltage */
/* Addresses, where correction factors are stored in the EEPROM */
#define VI_Address 0x00 /* Adress of Voltage Input Factor */
#define CI_Address 0x10 /* Adress of Current Input Factor */
#define VO_Address 0x20 /* Adress of Voltage Output Factor */
// \MARK NEW PINSETTINGS FOR TESTER (2)
#if (PINSET_TESTER == 2)
#define CO_Address 0x30 /* Adress of Current Output Factor */
#else
#define CO_Address 0x28 /* Adress of Current Output Factor */
#endif
#define VI_ByteLength 0x10 /* Length of VI Entry in Bytes */
#define CI_ByteLength 0x10 /* Length of CI Entry in Bytes */
// \MARK NEW PINSETTINGS FOR TESTER (2)
#if (PINSET_TESTER == 2)
#define VO_ByteLength 0x10 /* Length of VO Entry in Bytes */
#define CO_ByteLength 0x10 /* Length of CO Entry in Bytes */
#else
#define VO_ByteLength 0x08 /* Length of VO Entry in Bytes */
#define CO_ByteLength 0x08 /* Length of CO Entry in Bytes */
#endif
// \MARK NEW PINSETTINGS FOR TESTER (2)
#if (PINSET_TESTER == 2)
#define ident_VoltageInput 0x40 /* Stat of Volt. Input Calibration */
#define ident_VoltageOutput 0x41 /* Stat of Volt. Output Calibration */
#define ident_CurrentInput 0x42 /* Stat of Curr. Input Calibration */
#define ident_CurrentOutput 0x43 /* Stat of Curr. Output Calibration */
#else
#define ident_VoltageInput 0x30 /* Stat of Volt. Input Calibration */
#define ident_VoltageOutput 0x31 /* Stat of Volt. Output Calibration */
#define ident_CurrentInput 0x32 /* Stat of Curr. Input Calibration */
#define ident_CurrentOutput 0x33 /* Stat of Curr. Output Calibration */
#endif
#define DAC_CHANNEL_A (0x8000)
#define DAC_CHANNEL_B (0x0000)
#define spiWriteBuffer ssp0WriteBuffer
#define spiReadBuffer ssp0ReadBuffer
/* ---------------------------------------------------------------------------
* Global variable definitions
* ---------------------------------------------------------------------------
*/
/* External Arrays where system stores calibration values for temporary use */
extern UINT16 OutputVoltageCorrection[NumberOfOutputChannels];
extern UINT16 OutputCurrentCorrection[NumberOfOutputChannels];
extern UINT16 InputVoltageCorrection[NumberOfInputChannels];
extern UINT16 InputCurrentCorrection[NumberOfInputChannels];
/* ---------------------------------------------------------------------------
* Local variable definitions
* ---------------------------------------------------------------------------
*/
/* ---------------------------------------------------------------------------
* Local function definitions
* ---------------------------------------------------------------------------
*/
void killStats (void)
{
eepromWrite(ident_VoltageInput, 0x00); /* Write 0x00 to EEPROM Adress */
eepromWrite(ident_VoltageOutput, 0x00);
eepromWrite(ident_CurrentInput, 0x00);
eepromWrite(ident_CurrentOutput, 0x00);
}
void defaultStats (void)
{
eepromWrite(ident_VoltageInput, ident_default); /* Write DEFAULT Value */
eepromWrite(ident_VoltageOutput, ident_default);
eepromWrite(ident_CurrentInput, ident_default);
eepromWrite(ident_CurrentOutput, ident_default);
}
void calibratedStats (void)
{
eepromWrite(ident_VoltageInput, ident_calibrated); /* Write CALIBRATED */
eepromWrite(ident_VoltageOutput, ident_calibrated);
eepromWrite(ident_CurrentInput, ident_calibrated);
eepromWrite(ident_CurrentOutput, ident_calibrated);
}
void calibrationInit (void)
{
UINT8 volin;
UINT8 volout;
UINT8 curin;
UINT8 curout;
/* Readout Stats from EEPROM */
eepromRead(ident_VoltageInput, &volin);
eepromRead(ident_VoltageOutput, &volout);
eepromRead(ident_CurrentInput, &curin);
eepromRead(ident_CurrentOutput, &curout);
/* If a Stat is not defined, delete the Values and reset them to DEFAULT*/
if ((volin != ident_default) && (volin != ident_calibrated))
{
deleteCorrectionValue(VoltageInput);
loadCorrectionValue_defaultTarget(VoltageInput);
}
if ((volout != ident_default) && (volout != ident_calibrated))
{
deleteCorrectionValue(VoltageOutput);
loadCorrectionValue_defaultTarget(VoltageOutput);
}
if ((curin != ident_default) && (curin != ident_calibrated))
{
deleteCorrectionValue(CurrentInput);
loadCorrectionValue_defaultTarget(CurrentInput);
}
if ((curout != ident_default) && (curout != ident_calibrated))
{
deleteCorrectionValue(CurrentOutput);
loadCorrectionValue_defaultTarget(CurrentOutput);
}
}
UINT8 returnCalibrationStatus (daadCorrection_t correctionType)
{
UINT8 readback;
/* read corresponding Stats from EEPROM */
switch (correctionType)
{
case VoltageInput: eepromRead(ident_VoltageInput, &readback);
break;
case VoltageOutput: eepromRead(ident_VoltageOutput, &readback);
break;
case CurrentInput: eepromRead(ident_CurrentInput, &readback);
break;
case CurrentOutput: eepromRead(ident_CurrentOutput, &readback);
break;
}
return (readback); /* Return read Value to Caller */
}
UINT8 showLocalCalibrationStatus (INT32 correctionType)
{
UINT8 readback;
readback = returnCalibrationStatus (correctionType);
if (readback & ident_default)
{
sendString (SerOutPort, FALSE, importantMessage,
"Values are in DEFAULT Mode", Dummy, Dummy);
}
else if (readback & ident_calibrated)
{
sendString (SerOutPort, FALSE, importantMessage,
"Values are in CALIBRATED Mode", Dummy, Dummy);
}
else
{
sendString (SerOutPort, FALSE, importantMessage,
"NO VALID VALUES IN EEPROM", Dummy, Dummy);
}
return (readback);
}
/* Calibration of Analogue Inputs in Voltage Mode:
* Attach Voltage Supply with Calibration Value (recommended: 10,000 V) to
* the Input(s) you want to calibrate. Software will read out the real,
* digital Value from the ADC and uses this as Point of Calibration. Value
* will be stored in EEPROM (Adresses see above).
*/
void calibrateVoltageInput(void)
{
/* Local Variable Declaration */
UINT32 adcResult;
UINT32 loopcnt;
UINT16 VoltageInputCorrection[8];
UINT8 spiAdcCommand[3];
UINT8 spiAdcResponse[3];
/* Delete/Reset old Calibration Values */
deleteCorrectionValue (VoltageInput);
/* Load default Calibration Values from EEPROM */
loadCorrectionValue(InputVoltageCorrection, VoltageInput);
adcModeAll (adcVOLTAGE); /* Set ADC to Mode VOLTAGE */
loopcnt = 0;
do /* Do single for every Input */
{
/* Reset readback Variables */
adcResult = 0;
spiAdcResponse[0] = 0;
spiAdcResponse[1] = 0;
spiAdcResponse[2] = 0;
/* Build SPI Command */
spiAdcCommand[0] = 0x06;
spiAdcCommand[0] |= (loopcnt >> 2) & 0x01;
spiAdcCommand[1] = (loopcnt << 6);
spiAdcCommand[2] = 0;
FIO1CLR = BIT( 25 ); /* Enable Chipselect of ADC */
spiWriteBuffer( spiAdcCommand, 3 ); /* send Command */
spiReadBuffer( spiAdcResponse, 3 ); /* receive Response */
FIO1SET = BIT( 25 ); /* Disbale Chipselect of ADC */
/* Build 12 Bit Result out of 8 and 4 Bit readBack */
adcResult = (UINT16)(spiAdcResponse[1] & 0x0F) << 8;
adcResult |= (UINT16)spiAdcResponse[2];
/* Store result in Array for Voltage Input Correction */
VoltageInputCorrection[loopcnt] = adcResult;
loopcnt++;
} while (loopcnt < NumberOfInputChannels);
/* Save Correction Values to EEPROM */
saveCorrectionValue(VoltageInputCorrection, VoltageInput);
/* Load new Calibration Values from EEPROM */
loadCorrectionValue(InputVoltageCorrection, VoltageInput);
}
/* Calibration of Analogue Outputs in Voltage Mode:
* Attach the Output you want to calibrate to its corresponding Input
* (e.g. Output 1 to Input 1). Software will set up In- and Outputs
* automatically. The Correction Value will be calculated and stored in
* the EEPROM (Adresses see above).
*/
void calibrateVoltageOutput (void)
{
UINT16 spiCommand;
UINT16 channel = 0;
UINT16 value = 0xF80;
UINT16 readVoltage;
UINT16 VoltageOutputCorrection[4];
BOOLEAN leaveloop = FALSE;
/* Delete/Reset old Calibration Values */
deleteCorrectionValue (VoltageOutput);
/* Load default Calibration Values from EEPROM */
loadCorrectionValue(OutputVoltageCorrection, VoltageOutput);
dacModeAll (dacVOLTAGE); /* Set Output Types to Voltage */
adcModeAll (dacVOLTAGE); /* Set Input Types to Voltage */
vTaskDelay (100);
do /* Single for every Channel */
{
do /* As long as false channel Result */
{
/* Build and send SPI Command */
spiCommand = 0x3000;
spiCommand |= ((channel & 0x01) ==
0x01 ? DAC_CHANNEL_B : DAC_CHANNEL_A);
spiCommand |= (UINT16) value;
WriteDacCommand( spiCommand, (channel >> 1));
vTaskDelay (50);
readVoltage = adcRead (0, channel);
/* Is Result exactly 10000?
* If so, wait for 1 Second and test again. If no change, Result
* is OK and Correction Value is stored. If not, test further
*/
if (readVoltage == 10000)
{
vTaskDelay (1000);
if ((readVoltage = adcRead (0, channel)) == 10000)
{
VoltageOutputCorrection[channel] = value;
leaveloop = TRUE;
}
}
/* If Readback is too:
* LOW: increase Output and try again
* HIGH: decrease Output and try again
*/
else if (readVoltage > 10000)
{
value -= 0x01;
}
else if (readVoltage < 10000)
{
value += 0x01;
}
} while (leaveloop == FALSE);
/* Reset loop Values for next Channel */
leaveloop = FALSE;
value = 0xF80;
channel++;
} while (channel < NumberOfOutputChannels);
/* Save Correction Values to EEPROM */
saveCorrectionValue(VoltageOutputCorrection, VoltageOutput);
/* Load new Calibration Values from EEPROM */
loadCorrectionValue(OutputVoltageCorrection, VoltageOutput);
}
/* Calibration of Analogue Inputs in Current Mode:
* Attach Current Supply with Calibration Value (recommended: 20,000 mA) to
* the first Input you want to calibrate. Software will read out the real,
* digital Value from the ADC and uses this as Point of Calibration. Continue
* with the next channel when software prompts to press enter.
* Value will be stored in EEPROM (Adresses see above).
* NEVER CONNECT MORE THAN ONE CHANNEL TO CURRENT SUPPLY ONCE
*/
void calibrateCurrentInput (void)
{
UINT32 channel = 0;
UINT16 adcResult;
UINT16 CurrentInputCorrection[8];
UINT8 buffer;
UINT8 spiAdcCommand[3];
UINT8 spiAdcResponse[3];
BOOLEAN receive;
/* Delete/Reset old Calibration Values */
deleteCorrectionValue (CurrentInput);
/* Load default Calibration Values from EEPROM */
loadCorrectionValue(InputCurrentCorrection, CurrentInput);
adcModeAll (adcCURRENT); /* Set ADC Mode to CURRENT */
vTaskDelay (100);
do /* Single for every Channel */
{
/* Just for Testing!!! */
receive = FALSE;
buffer = 0;
sendString (SerOutPort, TRUE, importantMessage,
"Press ENTER to continue with Channel ", ItoDStr (channel), Dummy);
do /* do-while loop for String input */
{
vTaskDelay (10);
receive = serGet(MenuPort, &buffer);
} while ((buffer != 13) && (buffer != 32));
/* Reset readback Variables */
adcResult = 0x00;
spiAdcResponse[0] = 0;
spiAdcResponse[1] = 0;
spiAdcResponse[2] = 0;
/* Build SPI Command */
spiAdcCommand[0] = 0x06;
spiAdcCommand[0] |= (channel >> 2) & 0x01;
spiAdcCommand[1] = (channel << 6);
spiAdcCommand[2] = 0;
FIO1CLR = BIT( 25 ); /* ADC chipselect enable */
spiWriteBuffer( spiAdcCommand, 3 ); /* Send SPI Command */
spiReadBuffer( spiAdcResponse, 3 ); /* Receive Response */
FIO1SET = BIT( 25 ); /* ADC Chipselect disable */
/* Build 12 Bit Result out of 8 and 4 Bit readBack */
adcResult = (UINT16)(spiAdcResponse[1] & 0x0F) << 8;
adcResult |= (UINT16)spiAdcResponse[2];
/* Store Value to Array */
CurrentInputCorrection[channel] = adcResult;
channel++; /* Test next Channel */
} while (channel < 8);
/* Save Correction Values to EEPROM */
saveCorrectionValue(CurrentInputCorrection, CurrentInput);
/* Load new Calibration Values from EEPROM */
loadCorrectionValue(InputCurrentCorrection, CurrentInput);
}
/* Connect Analogue Outputs to the corresponding analogue Inputs. Software
* will prevent of double-usage of channels.
* Values will be stored in EEPROM automatically
*/
void calibrateCurrentOutput (void)
{
UINT16 spiCommand;
UINT16 channel = 0;
UINT16 value = 0xF80;
UINT16 readCurrent;
UINT16 CurrentOutputCorrection[4];
BOOLEAN leaveloop = FALSE;
/* Delete/Reset old Calibration Values */
deleteCorrectionValue (CurrentOutput);
/* Load default Calibration Values from EEPROM */
loadCorrectionValue(OutputCurrentCorrection, CurrentOutput);
dacModeAll (dacCURRENT); /* Set Output Types to Voltage */
adcMode(0, adcCURRENT);
adcMode(1, adcCURRENT);
adcMode(2, adcCURRENT);
adcMode(3, adcCURRENT);
adcMode(4, adcVOLTAGE);
adcMode(5, adcVOLTAGE);
adcMode(6, adcVOLTAGE);
adcMode(7, adcVOLTAGE);
vTaskDelay (100);
do /* Single for every Channel */
{
do /* As long as false channel Result */
{
/* Build and send SPI Command */
spiCommand = 0x3000;
spiCommand |= ((channel & 0x01) ==
0x01 ? DAC_CHANNEL_B : DAC_CHANNEL_A);
spiCommand |= (UINT16) value;
WriteDacCommand( spiCommand, (channel >> 1));
vTaskDelay (50);
readCurrent = adcRead (0, channel);
/* Is Result exactly 20000?
* If so, wait for 1 Second and test again. If no change, Result
* is OK and Correction Value is stored. If not, test further
*/
if (readCurrent == 20000)
{
vTaskDelay (1000);
if ((readCurrent = adcRead (0, channel)) == 20000)
{
CurrentOutputCorrection[channel] = value;
leaveloop = TRUE;
}
}
/* If Readback is too:
* LOW: increase Output and try again
* HIGH: decrease Output and try again
*/
else if (readCurrent > 20000)
{
value -= 0x01;
}
else if (readCurrent < 20000)
{
value += 0x01;
}
} while (leaveloop == FALSE);
/* Reset loop Values for next Channel */
leaveloop = FALSE;
value = 0xF80;
channel++;
} while (channel < NumberOfOutputChannels);
/* Save Correction Values to EEPROM */
saveCorrectionValue(CurrentOutputCorrection, CurrentOutput);
/* Load new Calibration Values from EEPROM */
loadCorrectionValue(OutputCurrentCorrection, CurrentOutput);
}
void saveCorrectionValue(pUINT16 CorrectionValueArray,
daadCorrection_t correctionType)
{
UINT32 loopcnt = 0;
UINT8 sendBuffer[16];
switch (correctionType)
{
case VoltageInput: /* Voltage Input Correction */
while (loopcnt < NumberOfInputChannels)
{
/* Build 8Bit Array out of 16Bit Array */
sendBuffer [2*loopcnt] = (CorrectionValueArray[loopcnt]
& 0x00FF);
sendBuffer [2*loopcnt+1] = ((CorrectionValueArray[loopcnt]
& 0xFF00) >> 8);
loopcnt++;
}
/* Send built Array to EEPROM with specific Address and Length */
eepromWriteBuffer(VI_Address, sendBuffer, VI_ByteLength);
eepromWrite(ident_VoltageInput, ident_calibrated);
break;
case VoltageOutput: /* Voltage Output Correction */
while (loopcnt < NumberOfOutputChannels)
{
sendBuffer [2*loopcnt] = (CorrectionValueArray[loopcnt]
& 0x00FF);
sendBuffer [2*loopcnt+1] = ((CorrectionValueArray[loopcnt]
& 0xFF00) >> 8);
loopcnt++;
}
eepromWriteBuffer(VO_Address, sendBuffer, VO_ByteLength);
eepromWrite(ident_VoltageOutput, ident_calibrated);
break;
case CurrentInput: /* Current Input Correction */
while (loopcnt < NumberOfInputChannels)
{
sendBuffer [2*loopcnt] = (CorrectionValueArray[loopcnt]
& 0x00FF);
sendBuffer [2*loopcnt+1] = ((CorrectionValueArray[loopcnt]
& 0xFF00) >> 8);
loopcnt++;
}
eepromWriteBuffer(CI_Address, sendBuffer, CI_ByteLength);
eepromWrite(ident_CurrentInput, ident_calibrated);
break;
case CurrentOutput: /* Current Output Correction */
while (loopcnt < NumberOfOutputChannels)
{
sendBuffer [2*loopcnt] = (CorrectionValueArray[loopcnt]
& 0x00FF);
sendBuffer [2*loopcnt+1] = ((CorrectionValueArray[loopcnt]
& 0xFF00) >> 8);
loopcnt++;
}
eepromWriteBuffer(CO_Address, sendBuffer, CO_ByteLength);
eepromWrite(ident_CurrentOutput, ident_calibrated);
break;
}
}
void loadCorrectionValue_defaultTarget (daadCorrection_t correctionType)
{
UINT32 loopcnt = 0;
UINT8 receiveArray[16];
switch (correctionType)
{
case VoltageInput: /* Voltage Input Correction */
/* Read EEPROM entry on specific Address and Length */
eepromReadBuffer(VI_Address, receiveArray, VI_ByteLength);
/* Build 16 Bit Array out of 8 Bit Array */
while (loopcnt < NumberOfInputChannels)
{
InputVoltageCorrection[loopcnt] = (receiveArray[2*loopcnt]&0xFF)
| ((receiveArray[2*loopcnt+1]&0xFF) << 8);
loopcnt++;
}
break;
case VoltageOutput: /* Voltage Output Correction */
eepromReadBuffer(VO_Address, receiveArray, VO_ByteLength);
while (loopcnt < NumberOfOutputChannels)
{
OutputVoltageCorrection[loopcnt] = (receiveArray[2*loopcnt]&0xFF)
| ((receiveArray[2*loopcnt+1]&0xFF) << 8);
loopcnt++;
}
break;
case CurrentInput: /* Current Input Correction */
eepromReadBuffer(CI_Address, receiveArray, CI_ByteLength);
while (loopcnt < NumberOfInputChannels)
{
InputCurrentCorrection[loopcnt] = (receiveArray[2*loopcnt]&0xFF)
| ((receiveArray[2*loopcnt+1]&0xFF) << 8);
loopcnt++;
}
break;
case CurrentOutput: /* Current Output Correction */
eepromReadBuffer(CO_Address, receiveArray, CO_ByteLength);
while (loopcnt < NumberOfOutputChannels)
{
OutputCurrentCorrection[loopcnt] = (receiveArray[2*loopcnt]&0xFF)
| ((receiveArray[2*loopcnt+1]&0xFF) << 8);
loopcnt++;
}
break;
}
}
void loadCorrectionValue(pUINT16 CorrectionValueArray,
daadCorrection_t correctionType)
{
UINT32 loopcnt = 0;
UINT8 receiveArray[16];
switch (correctionType)
{
case VoltageInput: /* Voltage Input Correction */
/* Read EEPROM entry on specific Address and Length */
eepromReadBuffer(VI_Address, receiveArray, VI_ByteLength);
/* Build 16 Bit Array out of 8 Bit Array */
while (loopcnt < NumberOfInputChannels)
{
CorrectionValueArray[loopcnt] = (receiveArray[2*loopcnt]&0xFF)
| ((receiveArray[2*loopcnt+1]&0xFF) << 8);
loopcnt++;
}
break;
case VoltageOutput: /* Voltage Output Correction */
eepromReadBuffer(VO_Address, receiveArray, VO_ByteLength);
while (loopcnt < NumberOfOutputChannels)
{
CorrectionValueArray[loopcnt] = (receiveArray[2*loopcnt]&0xFF)
| ((receiveArray[2*loopcnt+1]&0xFF) << 8);
loopcnt++;
}
break;
case CurrentInput: /* Current Input Correction */
eepromReadBuffer(CI_Address, receiveArray, CI_ByteLength);
while (loopcnt < NumberOfInputChannels)
{
CorrectionValueArray[loopcnt] = (receiveArray[2*loopcnt]&0xFF)
| ((receiveArray[2*loopcnt+1]&0xFF) << 8);
loopcnt++;
}
break;
case CurrentOutput: /* Current Output Correction */
eepromReadBuffer(CO_Address, receiveArray, CO_ByteLength);
while (loopcnt < NumberOfOutputChannels)
{
CorrectionValueArray[loopcnt] = (receiveArray[2*loopcnt]&0xFF)
| ((receiveArray[2*loopcnt+1]&0xFF) << 8);
loopcnt++;
}
break;
}
}
void deleteCorrectionValue (daadCorrection_t correctionType)
{
UINT32 loopcnt;
UINT8 emptyBuffer[16];
/* Build NULL-Array */
for (loopcnt = 0; loopcnt < NumberOfInputChannels; loopcnt++)
{
emptyBuffer[2*loopcnt] = 0xFF;
emptyBuffer[2*loopcnt+1] = 0x0F;
}
switch (correctionType)
{
case VoltageInput:
eepromWriteBuffer (VI_Address, emptyBuffer, VI_ByteLength);
eepromWrite(ident_VoltageInput, ident_default);
break;
case VoltageOutput:
eepromWriteBuffer (VO_Address, emptyBuffer, VO_ByteLength);
eepromWrite(ident_VoltageOutput, ident_default);
break;
case CurrentInput:
eepromWriteBuffer (CI_Address, emptyBuffer, CI_ByteLength);
eepromWrite(ident_CurrentInput, ident_default);
break;
case CurrentOutput:
eepromWriteBuffer (CO_Address, emptyBuffer, CO_ByteLength);
eepromWrite(ident_CurrentOutput, ident_default);
break;
}
}