UL/TX
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects 1 Releases Wiki Activity

Lots of refactoring

Browse Source
This commit is contained in:
Brent Perteet
2025-06-11 10:55:00 -05:00
parent a437bcf8b5
commit aaa7f0dc29
35 changed files with 1165 additions and 809 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
.vscode/settings.json vendored
View File

@@ -10,6 +10,9 @@
"ports.h": "c",
"mode.h": "c",
"arm_math.h": "c",
"io.h": "c"
"io.h": "c",
"spi.h": "c",
"system.h": "c",
"pwr_level.h": "c"
}
}

53
source/System/system.h
View File

@@ -8,18 +8,53 @@
#ifndef SYSTEM_SYSTEM_H_
#define SYSTEM_SYSTEM_H_
#include <stdbool.h>
#include "ports.h"
#include "adc.h"
#define SW_VERSION "1.10A"
#define SYS_INFO_LENGTH 24 //max string length for setup parameters (model, mfg, etc.)
#define POWER_LIMIT_LITHIUM 10.0f
#define POWER_LIMIT_ALKALINE 5.0f
#define POWER_LIMIT_EXT_DC 10.0f
typedef enum
{
GUI_MODE_NORMAL = 0,
GUI_MODE_MENU
} GuiMode_t;
typedef struct ClampData_s
{
float slope;
uint8_t pot;
float voltage;
float current;
float impedance;
float power;
float maxPower;
float targetPower;
uint32_t timeout;
bool regulate;
uint8_t prevPowerLevel;
} ClampData_t;
typedef enum
{ USB_CONNECTED = 0,
SAFE_MODE,
OVERVOLTAGE,
ESTOP,
BYPASS,
NUM_STATUS_FLAGS
} StatusFlags_t;
//System data
typedef struct
@@ -36,8 +71,26 @@ typedef struct
uint32_t systemTime; // system time in milliseconds since boot
bool safeMode; // output is disabled
bool usbConnected;
GuiMode_t guiMode;
ClampData_t clamp;
uint8_t currentMode;
ACCESSORY_t ports[NUM_PORTS];
float32_t maxPowerLimit;
ADC_t adc;
bool status[NUM_STATUS_FLAGS];
} SYSTEM_DATA_t;

252
source/adc.c
View File

@@ -1,5 +1,5 @@
/*
* adc.c
* _adc->c
*
* Created on: Mar 31, 2023
* Author: Keith.Lloyd
@@ -22,11 +22,9 @@
#include "adc.h"
#include "frq.h"
#include "ports.h"
#include "measure.h"
#include "utils.h"
#include "hwFixes.h"
#include "adc.h"
#include "System/system.h"
/*******************************************************************************
* Definitions
@@ -51,11 +49,13 @@ extern float32_t Watts_Filt;
extern HARDWARE_FIX_t hwf;
extern SYSTEM_DATA_t sys;
/*******************************************************************************
* Variables
******************************************************************************/
ADC_t adc;
static ADC_t *_adc;
adc_result_info_t adcResultInfoStruct;
/*
@@ -383,8 +383,8 @@ static float32_t ScaleLowGainCurrent(float32_t input)
scale = y1 + (x - x1) * (y2 - y1) / (x2 - x1);
}
//Update adc.currentClipping
adc.currentClipping = (input > ADC_LOW_GAIN_CURR_CLIP_THRESH);
//Update _adc->currentClipping
_adc->currentClipping = (input > ADC_LOW_GAIN_CURR_CLIP_THRESH);
return (input * scale);
}
@@ -439,8 +439,8 @@ static float32_t ScaleHighGainCurrent(float32_t input)
scale = y1 + (x - x1) * (y2 - y1) / (x2 - x1);
}
//Update adc.currentClipping
adc.currentClipping = (input > ADC_HIGH_GAIN_CURR_CLIP_THRESH);
//Update _adc->currentClipping
_adc->currentClipping = (input > ADC_HIGH_GAIN_CURR_CLIP_THRESH);
return (input * scale);
}
@@ -495,8 +495,8 @@ static float32_t ScaleLowGainVoltage(float32_t input)
scale = y1 + (x - x1) * (y2 - y1) / (x2 - x1);
}
//Update adc.votageClipping
adc.voltageClipping = (input > ADC_LOW_GAIN_VOLT_CLIP_THRESH);
//Update _adc->votageClipping
_adc->voltageClipping = (input > ADC_LOW_GAIN_VOLT_CLIP_THRESH);
return (input * scale);
}
@@ -552,8 +552,8 @@ static float32_t ScaleLowGainCurrent208023(float32_t input)
scale = y1 + (x - x1) * (y2 - y1) / (x2 - x1);
}
//Update adc.currentClipping
adc.currentClipping = (input > ADC_LOW_GAIN_CURR_CLIP_THRESH);
//Update _adc->currentClipping
_adc->currentClipping = (input > ADC_LOW_GAIN_CURR_CLIP_THRESH);
return (input * scale);
}
@@ -608,8 +608,8 @@ static float32_t ScaleHighGainCurrent208023(float32_t input)
scale = y1 + (x - x1) * (y2 - y1) / (x2 - x1);
}
//Update adc.currentClipping
adc.currentClipping = (input > ADC_HIGH_GAIN_CURR_CLIP_THRESH);
//Update _adc->currentClipping
_adc->currentClipping = (input > ADC_HIGH_GAIN_CURR_CLIP_THRESH);
return (input * scale);
}
@@ -664,8 +664,8 @@ static float32_t ScaleLowGainVoltage208023(float32_t input)
scale = y1 + (x - x1) * (y2 - y1) / (x2 - x1);
}
//Update adc.votageClipping
adc.voltageClipping = (input > ADC_LOW_GAIN_VOLT_CLIP_THRESH);
//Update _adc->votageClipping
_adc->voltageClipping = (input > ADC_LOW_GAIN_VOLT_CLIP_THRESH);
return (input * scale);
}
@@ -731,8 +731,8 @@ static float32_t ScaleLowGainCurrent208025(float32_t input)
offset = y1 + (x - x1) * (y2 - y1) / (x2 - x1);
}
//Update adc.currentClipping
adc.currentClipping = (input > ADC_LOW_GAIN_CURR_CLIP_THRESH);
//Update _adc->currentClipping
_adc->currentClipping = (input > ADC_LOW_GAIN_CURR_CLIP_THRESH);
return ((input * scale) + offset);
}
@@ -798,8 +798,8 @@ static float32_t ScaleHighGainCurrent208025(float32_t input)
offset = y1 + (x - x1) * (y2 - y1) / (x2 - x1);
}
//Update adc.currentClipping
adc.currentClipping = (input > ADC_HIGH_GAIN_CURR_CLIP_THRESH);
//Update _adc->currentClipping
_adc->currentClipping = (input > ADC_HIGH_GAIN_CURR_CLIP_THRESH);
return ((input * scale) + offset);
}
@@ -811,8 +811,10 @@ static float32_t ScaleHighGainCurrent208025(float32_t input)
/*!
* @brief Main function
*/
void ADC_Init2(void)
void ADC_SysInit(void)
{
_adc = &sys.adc;
/* Enable the power and clock for ADC. */
ADC_ClockPower_Configuration();
@@ -839,7 +841,7 @@ void ADC_Init2(void)
ADC_MeasureCurrentOffset();
//Start automatic ADC measurements (ctimer callback)
adc.measure = true;
_adc->measure = true;
}
//Measure offset for current measurement channel
@@ -847,7 +849,7 @@ void ADC_Init2(void)
void ADC_MeasureCurrentOffset(void)
{
//Measure current 8x and average
//Store as adc.I_Offset
//Store as _adc->I_Offset
Delay_Ticks(7); //70mS for current signal to stabilize
@@ -863,39 +865,39 @@ void ADC_MeasureCurrentOffset(void)
Delay_Ticks(2); //20mS
currentOffsetSum += adc.rawCurrent;
voltageOffsetSum += adc.rawVoltage;
currentOffsetSum += _adc->rawCurrent;
voltageOffsetSum += _adc->rawVoltage;
test[i] = adc.rawVoltage; //collect samples for testing
test[i] = _adc->rawVoltage; //collect samples for testing
}
adc.I_OffsetAdc = currentOffsetSum >> 3; //average of 8 samples
_adc->I_OffsetAdc = currentOffsetSum >> 3; //average of 8 samples
#if ADC_USE_NOISE_OFFSET
adc.I_OffsetAdc -= ADC_NOISE_OFFSET_COUNTS;
_adc->I_OffsetAdc -= ADC_NOISE_OFFSET_COUNTS;
#endif
#if 0 //TESTING: Allow larger offset
if(abs((int32_t)(adc.I_OffsetAdc) - ADC_HALF_COUNTS) <= 50)
if(abs((int32_t)(_adc->I_OffsetAdc) - ADC_HALF_COUNTS) <= 50)
#else
if(abs((int32_t)(adc.I_OffsetAdc) - ADC_HALF_COUNTS) <= ADC_OFFSET_MAX_ERROR) //offset within 30 counts of mid scale
if(abs((int32_t)(_adc->I_OffsetAdc) - ADC_HALF_COUNTS) <= ADC_OFFSET_MAX_ERROR) //offset within 30 counts of mid scale
#endif
{
adc.iosOK = true;
_adc->iosOK = true;
}
else
{
adc.iosOK = false; //This will NOT be needed after keith removes the restart when USB is disconnected
_adc->iosOK = false; //This will NOT be needed after keith removes the restart when USB is disconnected
}
adc.V_OffsetAdc = voltageOffsetSum >> 3; //average of 8 samples
if(abs((int32_t)(adc.V_OffsetAdc) - ADC_HALF_COUNTS) <= ADC_OFFSET_MAX_ERROR) //offset within 30 counts of mid scale
_adc->V_OffsetAdc = voltageOffsetSum >> 3; //average of 8 samples
if(abs((int32_t)(_adc->V_OffsetAdc) - ADC_HALF_COUNTS) <= ADC_OFFSET_MAX_ERROR) //offset within 30 counts of mid scale
{
adc.vosOK = true;
_adc->vosOK = true;
}
else
{
adc.vosOK = false;
_adc->vosOK = false;
}
}
@@ -915,39 +917,39 @@ void ADC_Update(void)
while(!ADC_GetChannelConversionResult(DEMO_ADC_BASE, 10, &adcResultInfoStruct));
//Add measurement to adc struct
adc.V_BID_RAW += adcResultInfoStruct.result; //ch10
_adc->V_BID_RAW += adcResultInfoStruct.result; //ch10
//CURRENT
ADC_GetChannelConversionResult(DEMO_ADC_BASE, 0, &adcResultInfoStruct);
adc.rawCurrent = adcResultInfoStruct.result;
adc.I_OUT_RAW = adc.rawCurrent;
adc.I_OUT = adc.rawCurrent; //route raw current measurement to testIout
_adc->rawCurrent = adcResultInfoStruct.result;
_adc->I_OUT_RAW = _adc->rawCurrent;
_adc->I_OUT = _adc->rawCurrent; //route raw current measurement to testIout
#if 0 //TESTING: Don't use offset
adc.I_OUT -= ADC_HALF_COUNTS;
_adc->I_OUT -= ADC_HALF_COUNTS;
#else
if(adc.iosOK) {adc.I_OUT -= adc.I_OffsetAdc; }
else {adc.I_OUT -= ADC_HALF_COUNTS; }
if(_adc->iosOK) {_adc->I_OUT -= _adc->I_OffsetAdc; }
else {_adc->I_OUT -= ADC_HALF_COUNTS; }
#endif
#if 1 //Testing filtered raw value
adc.IRaw = adc.I_OUT; //ADC value with offset applied
adc.IRawFilt = adc.I_OUT; //filtered ADC counts w/ offset
adc.IRawFilt = FILT_ExpAvgF32(adc.IRawFilt,&adc.IRawDelay,0.02);
_adc->IRaw = _adc->I_OUT; //ADC value with offset applied
_adc->IRawFilt = _adc->I_OUT; //filtered ADC counts w/ offset
_adc->IRawFilt = FILT_ExpAvgF32(_adc->IRawFilt,&_adc->IRawDelay,0.02);
#endif
#if ADC_CORRECT_FOR_CURRENT_NOISE
//signal = SQRT( measurement^2 - noise^2)
if(adc.I_OUT > ADC_NOISE_OFFSET_COUNTS) //avoid sqrt(negative number)
if(_adc->I_OUT > ADC_NOISE_OFFSET_COUNTS) //avoid sqrt(negative number)
{
adc.I_OUT = sqrtf(adc.I_OUT * adc.I_OUT - ADC_NOISE_OFFSET_COUNTS * ADC_NOISE_OFFSET_COUNTS);
_adc->I_OUT = sqrtf(_adc->I_OUT * _adc->I_OUT - ADC_NOISE_OFFSET_COUNTS * ADC_NOISE_OFFSET_COUNTS);
}
else
{
adc.I_OUT = 0;
_adc->I_OUT = 0;
}
#endif
@@ -957,50 +959,50 @@ void ADC_Update(void)
{
if(hwf.mainPcbaPN >= 208025)
{
adc.I_OUT = ScaleHighGainCurrent208025(adc.I_OUT);
_adc->I_OUT = ScaleHighGainCurrent208025(_adc->I_OUT);
}
else if(hwf.mainPcbaPN == 208023)
{
adc.I_OUT = ScaleHighGainCurrent208023(adc.I_OUT);
_adc->I_OUT = ScaleHighGainCurrent208023(_adc->I_OUT);
}
else
{
adc.I_OUT = ScaleHighGainCurrent(adc.I_OUT);
_adc->I_OUT = ScaleHighGainCurrent(_adc->I_OUT);
}
}
else //Low Current Gain
{
if(hwf.mainPcbaPN >= 208025)
{
adc.I_OUT = ScaleLowGainCurrent208025(adc.I_OUT);
_adc->I_OUT = ScaleLowGainCurrent208025(_adc->I_OUT);
}
else if(hwf.mainPcbaPN == 208023)
{
adc.I_OUT = ScaleLowGainCurrent208025(adc.I_OUT);
_adc->I_OUT = ScaleLowGainCurrent208025(_adc->I_OUT);
}
else
{
adc.I_OUT = ScaleLowGainCurrent(adc.I_OUT);
_adc->I_OUT = ScaleLowGainCurrent(_adc->I_OUT);
}
}
//VOLTAGE
ADC_GetChannelConversionResult(DEMO_ADC_BASE, 1, &adcResultInfoStruct);
adc.rawVoltage = adcResultInfoStruct.result;
adc.V_OUT_RAW = adc.rawVoltage;
adc.V_OUT = adc.rawVoltage;
_adc->rawVoltage = adcResultInfoStruct.result;
_adc->V_OUT_RAW = _adc->rawVoltage;
_adc->V_OUT = _adc->rawVoltage;
#if 0 //TESTING: Don't use offset
adc.V_OUT -= ADC_HALF_COUNTS;
_adc->V_OUT -= ADC_HALF_COUNTS;
#else
if(adc.vosOK) {adc.V_OUT -= adc.V_OffsetAdc; } //use offset if in range
else {adc.V_OUT -= ADC_HALF_COUNTS; } //otherwise, use ADC_HALF_COUNTS
if(_adc->vosOK) {_adc->V_OUT -= _adc->V_OffsetAdc; } //use offset if in range
else {_adc->V_OUT -= ADC_HALF_COUNTS; } //otherwise, use ADC_HALF_COUNTS
#endif
#if 1 //Testing filtered raw value
adc.VRaw = adc.V_OUT; //ADC value with offset applied. Snapshot since V_OUT gets modified later
adc.VRawFilt = FILT_ExpAvgF32(adc.VRaw,&adc.VRawDelay,0.02); //filtered ADC counts w/ offset
_adc->VRaw = _adc->V_OUT; //ADC value with offset applied. Snapshot since V_OUT gets modified later
_adc->VRawFilt = FILT_ExpAvgF32(_adc->VRaw,&_adc->VRawDelay,0.02); //filtered ADC counts w/ offset
#endif
#if 1
@@ -1008,25 +1010,25 @@ void ADC_Update(void)
if((Port_State[BOTTOM_SR] & 0x80) > 0) //High Voltage Gain
{
//Not implemented
//adc.V_OUT = MeasureHighGainVoltage(adc.V_OUT);
//_adc->V_OUT = MeasureHighGainVoltage(_adc->V_OUT);
}
else //Low Current Gain
{
if(hwf.mainPcbaPN >= 208023) //208023 and 208025 use the same table
{
adc.V_OUT = ScaleLowGainVoltage208023(adc.V_OUT);
_adc->V_OUT = ScaleLowGainVoltage208023(_adc->V_OUT);
}
else
{
adc.V_OUT = ScaleLowGainVoltage(adc.V_OUT);
_adc->V_OUT = ScaleLowGainVoltage(_adc->V_OUT);
}
}
#else
adc.V_OUT = adc.V_OUT / 4096.0 * ADC_VREF; //scale to input voltage
//adc.V_OUT = adc.V_OUT * (804.0 + 10.0) / 10.0; //Scale for external voltage divider
_adc->V_OUT = _adc->V_OUT / 4096.0 * ADC_VREF; //scale to input voltage
//_adc->V_OUT = _adc->V_OUT * (804.0 + 10.0) / 10.0; //Scale for external voltage divider
adc.V_OUT = CompensateVout(adc.V_OUT); //divider scaling sucked because AC...
_adc->V_OUT = CompensateVout(_adc->V_OUT); //divider scaling sucked because AC...
Measure_Volts();
#endif
@@ -1034,24 +1036,24 @@ void ADC_Update(void)
ADC_GetChannelConversionResult(DEMO_ADC_BASE, 3, &adcResultInfoStruct);
adc.V_PSU_RAW += adcResultInfoStruct.result;
_adc->V_PSU_RAW += adcResultInfoStruct.result;
ADC_GetChannelConversionResult(DEMO_ADC_BASE, 4, &adcResultInfoStruct);
adc.V_BAT_RAW += adcResultInfoStruct.result;
_adc->V_BAT_RAW += adcResultInfoStruct.result;
while(!ADC_GetChannelConversionResult(DEMO_ADC_BASE, 5, &adcResultInfoStruct));
adc.V_ID2_RAW += adcResultInfoStruct.result;
_adc->V_ID2_RAW += adcResultInfoStruct.result;
what_val2 = adcResultInfoStruct.result;
while(!ADC_GetChannelConversionResult(DEMO_ADC_BASE, 6, &adcResultInfoStruct));
adc.V_ID1_RAW += adcResultInfoStruct.result;
_adc->V_ID1_RAW += adcResultInfoStruct.result;
what_val1 = adcResultInfoStruct.result;
ADC_GetChannelConversionResult(DEMO_ADC_BASE, 7, &adcResultInfoStruct);
adc.V_CHK_RAW += adcResultInfoStruct.result;
_adc->V_CHK_RAW += adcResultInfoStruct.result;
ADC_GetChannelConversionResult(DEMO_ADC_BASE, 8, &adcResultInfoStruct);
adc.V_TMP_RAW += adcResultInfoStruct.result;
_adc->V_TMP_RAW += adcResultInfoStruct.result;
static uint32_t index = 0;
@@ -1062,70 +1064,70 @@ void ADC_Update(void)
index = 0;
//CHANNEL 5
adc.V_ID1 = adc.V_ID1_RAW / ADC_NUM_AVERAGES; //average
adc.V_ID1 = adc.V_ID1 / 4096.0 * ADC_VREF; //scaling
_adc->V_ID1 = _adc->V_ID1_RAW / ADC_NUM_AVERAGES; //average
_adc->V_ID1 = _adc->V_ID1 / 4096.0 * ADC_VREF; //scaling
//CHANNEL 6
adc.V_ID2 = adc.V_ID2_RAW / ADC_NUM_AVERAGES; //average
adc.V_ID2 = adc.V_ID2 / 4096.0 * ADC_VREF; //scaling
_adc->V_ID2 = _adc->V_ID2_RAW / ADC_NUM_AVERAGES; //average
_adc->V_ID2 = _adc->V_ID2 / 4096.0 * ADC_VREF; //scaling
//CHANNEL 4
adc.V_BAT = adc.V_BAT_RAW / ADC_NUM_AVERAGES; //average
adc.diag_bat = (adc.V_BAT);
_adc->V_BAT = _adc->V_BAT_RAW / ADC_NUM_AVERAGES; //average
_adc->diag_bat = (_adc->V_BAT);
adc.V_BAT = adc.V_BAT / 4096.0 * 3.3;//ADC_VREF; //scaling
_adc->V_BAT = _adc->V_BAT / 4096.0 * 3.3;//ADC_VREF; //scaling
float temp;
temp = 10000.0/59900.0;
adc.V_BAT = adc.V_BAT / temp;
_adc->V_BAT = _adc->V_BAT / temp;
//CHANNEL 3
adc.V_PSU = adc.V_PSU_RAW / ADC_NUM_AVERAGES; //average
adc.V_PSU = adc.V_PSU / 4096.0 * ADC_VREF; //scaling
_adc->V_PSU = _adc->V_PSU_RAW / ADC_NUM_AVERAGES; //average
_adc->V_PSU = _adc->V_PSU / 4096.0 * ADC_VREF; //scaling
//CHANNEL 8
adc.V_TMP = adc.V_TMP_RAW / ADC_NUM_AVERAGES; //average
adc.V_TMP = adc.V_TMP / 4096.0 * ADC_VREF; //scaling
_adc->V_TMP = _adc->V_TMP_RAW / ADC_NUM_AVERAGES; //average
_adc->V_TMP = _adc->V_TMP / 4096.0 * ADC_VREF; //scaling
//CHANNEL 10 - Battery ID
adc.V_BID = adc.V_BID_RAW / ADC_NUM_AVERAGES; //average
adc.V_BID = adc.V_BID / 4096.0 * 3.3;//ADC_VREF; //scaling
_adc->V_BID = _adc->V_BID_RAW / ADC_NUM_AVERAGES; //average
_adc->V_BID = _adc->V_BID / 4096.0 * 3.3;//ADC_VREF; //scaling
//############# Added 2/5/24
// adc.V_BID = adc.V_BID * 1.09; // additional scaling factor
// _adc->V_BID = _adc->V_BID * 1.09; // additional scaling factor
temp = 10000.0/59900.0;
adc.V_BID = adc.V_BID / temp;
_adc->V_BID = _adc->V_BID / temp;
//##############
//CHANNEL 7
adc.V_CHK = adc.V_CHK_RAW / ADC_NUM_AVERAGES; //average
volts_check = adc.V_CHK;
_adc->V_CHK = _adc->V_CHK_RAW / ADC_NUM_AVERAGES; //average
volts_check = _adc->V_CHK;
//scaling
adc.V_PSU = adc.V_PSU * (1000+47.5)/47.5; // vratio;
_adc->V_PSU = _adc->V_PSU * (1000+47.5)/47.5; // vratio;
adc.V_CHK = adc.V_CHK / 4096.0 * ADC_VREF; //ADC bits & ref voltage
_adc->V_CHK = _adc->V_CHK / 4096.0 * ADC_VREF; //ADC bits & ref voltage
#if 1 //HV scaling
adc.V_CHK *= 2.0; //Divider in the LPF
adc.V_CHK += 0.7; //diode drop from rectifier
adc.V_CHK = adc.V_CHK * (402.0 + 3.92) / 3.92; //voltage divider
_adc->V_CHK *= 2.0; //Divider in the LPF
_adc->V_CHK += 0.7; //diode drop from rectifier
_adc->V_CHK = _adc->V_CHK * (402.0 + 3.92) / 3.92; //voltage divider
#else
adc.V_CHK *= 599.0 / 100.0; // Vin = Vadc* (R1+R2) / R2
_adc->V_CHK *= 599.0 / 100.0; // Vin = Vadc* (R1+R2) / R2
adc.V_CHK *= 100; //rough scale factor needs to be re done later
_adc->V_CHK *= 100; //rough scale factor needs to be re done later
#endif
//clear raw sums
adc.V_ID1_RAW = 0;
adc.V_ID2_RAW = 0;
adc.V_CHK_RAW = 0;
adc.V_PSU_RAW = 0;
adc.V_BAT_RAW = 0;
adc.V_TMP_RAW = 0;
adc.V_BID_RAW = 0;
_adc->V_ID1_RAW = 0;
_adc->V_ID2_RAW = 0;
_adc->V_CHK_RAW = 0;
_adc->V_PSU_RAW = 0;
_adc->V_BAT_RAW = 0;
_adc->V_TMP_RAW = 0;
_adc->V_BID_RAW = 0;
}
@@ -1138,48 +1140,48 @@ float temp;
float32_t fast_k=0.0951;
adc.V_OUT_SlowFilt = FILT_ExpAvgF32(adc.V_OUT,&adc.V_OUT_Delay,k);
adc.I_OUT_SlowFilt = FILT_ExpAvgF32(adc.I_OUT,&adc.I_OUT_Delay,k);
_adc->V_OUT_SlowFilt = FILT_ExpAvgF32(_adc->V_OUT,&_adc->V_OUT_Delay,k);
_adc->I_OUT_SlowFilt = FILT_ExpAvgF32(_adc->I_OUT,&_adc->I_OUT_Delay,k);
adc.V_OUT_FastFilt = FILT_ExpAvgF32(adc.V_OUT,&adc.V_OUT_FastDelay,fast_k);
adc.I_OUT_FastFilt = FILT_ExpAvgF32(adc.I_OUT,&adc.I_OUT_FastDelay,fast_k);
_adc->V_OUT_FastFilt = FILT_ExpAvgF32(_adc->V_OUT,&_adc->V_OUT_FastDelay,fast_k);
_adc->I_OUT_FastFilt = FILT_ExpAvgF32(_adc->I_OUT,&_adc->I_OUT_FastDelay,fast_k);
if(adc.I_OUT_FastFilt > 0)
if(_adc->I_OUT_FastFilt > 0)
{
adc.Ohms_slowfilt = FILT_ExpAvgF32(adc.V_OUT_FastFilt/adc.I_OUT_FastFilt,&adc.Ohms_SlowDelay,k);
_adc->Ohms_slowfilt = FILT_ExpAvgF32(_adc->V_OUT_FastFilt/_adc->I_OUT_FastFilt,&_adc->Ohms_SlowDelay,k);
if(isnanf(adc.Ohms_SlowDelay)) //Fix nan delay line
if(isnanf(_adc->Ohms_SlowDelay)) //Fix nan delay line
{
adc.Ohms_SlowDelay = 0.00001;
_adc->Ohms_SlowDelay = 0.00001;
}
}
//##########################################################################
Watts_Filt = adc.V_OUT_FastFilt * (adc.I_OUT_FastFilt);
// Ohms_filt = adc.V_OUT_Filt/adc.I_OUT_Filt;
Watts_Filt = _adc->V_OUT_FastFilt * (_adc->I_OUT_FastFilt);
// Ohms_filt = _adc->V_OUT_Filt/_adc->I_OUT_Filt;
#if ADC_MEASUREMENT_TEST
//USAGE: Set adc.testCollectData = 1; to start data collection
//USAGE: Set _adc->testCollectData = 1; to start data collection
//adc.testIout = FILT_ExpAvgF32(adc.testIout,&adc.testIoutDelay,fast_k);
//adc.testVout = FILT_ExpAvgF32(adc.testVout,&adc.testVoutDelay,fast_k);
//_adc->testIout = FILT_ExpAvgF32(_adc->testIout,&_adc->testIoutDelay,fast_k);
//_adc->testVout = FILT_ExpAvgF32(_adc->testVout,&_adc->testVoutDelay,fast_k);
//Test data collection for measuring filter responses
static uint32_t idx = 0;
static bool measure = 1;
if(adc.testCollectData && measure)
if(_adc->testCollectData && measure)
{
adc.testData1[idx] = adc.V_OUT_FastFilt;
adc.testData2[idx] = adc.I_OUT_FastFilt * 1000.0; //convert to mA
_adc->testData1[idx] = _adc->V_OUT_FastFilt;
_adc->testData2[idx] = _adc->I_OUT_FastFilt * 1000.0; //convert to mA
idx++;
if(idx >= ADC_NUM_TEST)
{
adc.testCollectData = 0; //stop data collection
_adc->testCollectData = 0; //stop data collection
idx = 0; //reset idx
measure = 0; //DO NOT take another measurement (Don't clear and it'll measure again)
}

2
source/adc.h
View File

@@ -132,7 +132,7 @@ typedef struct {
}ADC_t;
void ADC_Init2(void);
void ADC_SysInit(void);
void ADC_MeasureCurrentOffset(void);
void ADC_Update(void);
float32_t FILT_ExpAvgF32(float32_t input, float32_t *temp, float32_t k);

43
source/battery.c
View File

@@ -16,17 +16,17 @@
#include "amps.h"
#include "ports.h"
#include "hwFixes.h"
#include "System/system.h"
uint8_t Bat_Type;
extern uint8_t Task, Error;
extern ADC_t adc;
extern float32_t Max_Power_Limit;
extern uint16_t Low_Bat_timer;
extern uint16_t battery;
//uint16_t Bat_Level[] = {100,200,300,400,500,125,225,325,425,525}; // Battery life levels 5 Alkaline and 5 Lithium.
extern HARDWARE_FIX_t hwf;
extern SYSTEM_DATA_t sys;
bool Compare_With_Limit(float32_t V1 ,float32_t V2,float32_t limit)
{
@@ -55,35 +55,40 @@ bool result;
void battery_checkId(void)
{
}
void Check_Bat_Id(void)
{
float32_t Battery;
float32_t Bat_Mid_Point;
if(adc.V_BID > LITHIUM_MID_POINT) // BAT_ID = 0V for lithium, mid point for Alkaline
if(sys.adc.V_BID > LITHIUM_MID_POINT) // BAT_ID = 0V for lithium, mid point for Alkaline
{
if(Compare_With_Limit(adc.V_BID,adc.V_BAT,5.0))
if(Compare_With_Limit(sys.adc.V_BID,sys.adc.V_BAT,5.0))
{
Bat_Type = EXT_DC;
Max_Power_Limit = 10.0; // Limit max power to 5W.
sys.maxPowerLimit = POWER_LIMIT_EXT_DC; // Limit max power to 5W.
}
else
{
Bat_Type = ALKALINE;
Max_Power_Limit = 5.0; // Limit max power to 5W.
sys.maxPowerLimit = POWER_LIMIT_ALKALINE; // Limit max power to 5W.
Battery = adc.V_BAT; // Calculate mid-point for alkaline
Battery = sys.adc.V_BAT; // Calculate mid-point for alkaline
Bat_Mid_Point = Battery / 2;
if ((adc.V_BID > (Bat_Mid_Point * 1.1)) || (adc.V_BID < (Bat_Mid_Point * 0.9)) ) // Check if not at mid-point
if ((sys.adc.V_BID > (Bat_Mid_Point * 1.1)) || (sys.adc.V_BID < (Bat_Mid_Point * 0.9)) ) // Check if not at mid-point
Bat_Type = BAT_ERROR; // indicate battery insertion error
}
}
else
{
Bat_Type = LITHIUM;
Max_Power_Limit = 10.0; // Limit max power to 5W. 1.7 = 10.0 1.7X = 25.0
sys.maxPowerLimit = POWER_LIMIT_LITHIUM; // Limit max power to 5W. 1.7 = 10.0 1.7X = 25.0
}
if(Bat_Type == BAT_ERROR)
@@ -122,17 +127,17 @@ void Chk_Bat_Level(void)
void Test_Bat_Level(float32_t Bat_Cut_Off)
{
if(adc.V_BAT < Bat_Cut_Off && Task != LOW_BATTERY_TASK)
if(sys.adc.V_BAT < Bat_Cut_Off && Task != LOW_BATTERY_TASK)
{
if(Task != PWR_OFF_TASK)
{
All_Amps_Off();
Disable_BC(); //Disable BC
Select_Estop(ON);
Select_Estop(ISOLATED);
Delay_Ticks(25); //wait for battery voltage to rise
// if(adc.V_BAT <= Bat_Cut_Off)
// if(sys.adc.V_BAT <= Bat_Cut_Off)
// {
Task = LOW_BATTERY_TASK;
Low_Bat_timer = DELAY_2S;
@@ -151,20 +156,20 @@ float32_t Adjust_Battery_For_Load() // adjust to true battery voltage due to bat
//drop and current demand
{ // assumed frequency and efficiency may need table for frequency adjust
float32_t battery; //assumes taps are correct
battery = adc.V_BAT;
battery = sys.adc.V_BAT;
if(Bat_Type == LITHIUM)
{
if(adc.I_OUT_SlowFilt < DEMAND1)
if(sys.adc.I_OUT_SlowFilt < DEMAND1)
battery = battery + 1.1;
else if(adc.I_OUT_SlowFilt < DEMAND2)
else if(sys.adc.I_OUT_SlowFilt < DEMAND2)
battery = battery + 1.2;
else if(adc.I_OUT_SlowFilt < DEMAND3)
else if(sys.adc.I_OUT_SlowFilt < DEMAND3)
battery = battery + 1.3;
else if(adc.I_OUT_SlowFilt < DEMAND4)
else if(sys.adc.I_OUT_SlowFilt < DEMAND4)
battery = battery + 1.4;
else if(adc.I_OUT_SlowFilt < DEMAND5)
else if(sys.adc.I_OUT_SlowFilt < DEMAND5)
battery = battery + 1.5;
else if(adc.I_OUT_SlowFilt < DEMAND6)
else if(sys.adc.I_OUT_SlowFilt < DEMAND6)
battery = battery + 1.6;
else
battery = battery + 2;

113
source/display.c
View File

@@ -48,7 +48,6 @@ float32_t Watts_Filt;
extern SYSTEM_DATA_t sys;
extern ADC_t adc;
extern uint8_t Bat_Type, Cur_Mode, Task, Over_Voltage_Flag, Error;
extern MODE_REC_t mode_Array[];
extern uint8_t Bcast_Pwr_Level;
@@ -139,18 +138,12 @@ void Display_Volts(void)
if((( Cur_Mode != BROADCAST) && (!Is_Clamp_Detected())))
Display_Line_Voltage();
else
{
if((Is_Clamp_Detected()) && (Test_Mode) && (Cur_Mode != BROADCAST))
{
Display_Clamp_Power();
}
}
#if 0// testing the new averager
sprintf(tempString,"%.2fmA",adc.I_OUT_SlowFilt* 1000.0);
sprintf(tempString,"%.2fmA",sys.adc.I_OUT_SlowFilt* 1000.0);
FL_DrawString( tempString, X_POS_MA+50, 18, font16Bold, LCD_DRAW_SET, FL_ALIGN_LEFT);
#endif
@@ -160,7 +153,7 @@ void Display_Volts(void)
void Display_Line_Voltage(void)
{
Volts = adc.V_OUT_FastFilt;
Volts = sys.adc.V_OUT_FastFilt;
if(Volts < 0)
Volts = 0;
@@ -177,11 +170,11 @@ void Display_Clamp_Power(void)
float power = 0.0f;
Volts = adc.V_OUT_FastFilt;
Volts = sys.adc.V_OUT_FastFilt;
if(Volts < 0)
Volts = 0;
power = Volts * adc.I_OUT_FastFilt;
power = Volts * sys.adc.I_OUT_FastFilt;
sprintf(tempString,"%.1fW", power);
FL_DrawString( tempString, LCD_X_MID -10, 60, font18Bold, LCD_DRAW_SET, FL_ALIGN_LEFT);
@@ -191,7 +184,7 @@ void Display_Clamp_Power(void)
void Display_Clamp_Volts(void)
{
Volts = adc.V_OUT_FastFilt;
Volts = sys.adc.V_OUT_FastFilt;
if(Volts < 0)
Volts = 0;
@@ -206,11 +199,7 @@ void Display_Current(void)
if(( Cur_Mode != BROADCAST) && (!Is_Clamp_Detected()))
Display_Line_Current();
else
{
if((Is_Clamp_Detected()) && (Test_Mode))
Display_Line_Current();
}
}
@@ -218,18 +207,14 @@ void Display_Ohms(void)
{
if(( Cur_Mode != BROADCAST) && (!Is_Clamp_Detected()))
Display_Line_Ohms();
else
{
if((Is_Clamp_Detected()) && (Test_Mode))
Display_Line_Ohms();
}
}
void Display_Line_Current(void)
{
Milli_amps = adc.I_OUT_SlowFilt;
Milli_amps = sys.adc.I_OUT_SlowFilt;
if(Milli_amps < 0)
@@ -242,20 +227,20 @@ void Display_Line_Current(void)
void Display_Line_Ohms(void)
{
if(adc.Ohms_slowfilt < 0)
adc.Ohms_slowfilt = 0;
if(sys.adc.Ohms_slowfilt < 0)
sys.adc.Ohms_slowfilt = 0;
if(adc.Ohms_slowfilt < 10000)
if(sys.adc.Ohms_slowfilt < 10000)
{
sprintf(tempString,"%.0fΩ",adc.Ohms_slowfilt);
sprintf(tempString,"%.0fΩ",sys.adc.Ohms_slowfilt);
FL_DrawString( tempString, X_POS_MA+90, 72, font16Bold, LCD_DRAW_SET, FL_ALIGN_LEFT);
}
else
{
if(adc.Ohms_slowfilt < 100000)
if(sys.adc.Ohms_slowfilt < 100000)
{
sprintf(tempString,"%.0f kΩ",adc.Ohms_slowfilt/1000);
sprintf(tempString,"%.0f kΩ",sys.adc.Ohms_slowfilt/1000);
FL_DrawString( tempString, X_POS_MA+90, 72, font16Bold, LCD_DRAW_SET, FL_ALIGN_LEFT);
}
else
@@ -323,15 +308,15 @@ void Display_Battery_NC() // No Cap
if (Bat_Type == LITHIUM)
{
if(adc.V_BAT >= NCL_BATTERY_NINETY)
if(sys.adc.V_BAT >= NCL_BATTERY_NINETY)
Draw_Battery(STACKS_4);
else if(adc.V_BAT > NCL_BATTERY_3QUARTERS)
else if(sys.adc.V_BAT > NCL_BATTERY_3QUARTERS)
Draw_Battery(STACKS_3);
else if(adc.V_BAT > NCL_BATTERY_FIFTY)
else if(sys.adc.V_BAT > NCL_BATTERY_FIFTY)
Draw_Battery(STACKS_2);
else if(adc.V_BAT > NCL_BATTERY_1QUARTER)
else if(sys.adc.V_BAT > NCL_BATTERY_1QUARTER)
Draw_Battery(STACKS_1);
else if (adc.V_BAT > NCL_BATTERY_1EIGTH)
else if (sys.adc.V_BAT > NCL_BATTERY_1EIGTH)
Draw_Battery(STACKS_EMPTY);
else
Display_Bat_Frame_Flash();
@@ -340,15 +325,15 @@ void Display_Battery_NC() // No Cap
else
{
if(adc.V_BAT >= NCA_BATTERY_NINETY)
if(sys.adc.V_BAT >= NCA_BATTERY_NINETY)
Draw_Battery(STACKS_4);
else if(adc.V_BAT > NCA_BATTERY_3QUARTERS)
else if(sys.adc.V_BAT > NCA_BATTERY_3QUARTERS)
Draw_Battery(STACKS_3);
else if(adc.V_BAT > NCA_BATTERY_FIFTY)
else if(sys.adc.V_BAT > NCA_BATTERY_FIFTY)
Draw_Battery(STACKS_2);
else if(adc.V_BAT > NCA_BATTERY_1QUARTER)
else if(sys.adc.V_BAT > NCA_BATTERY_1QUARTER)
Draw_Battery(STACKS_1);
else if (adc.V_BAT > NCA_BATTERY_1EIGTH)
else if (sys.adc.V_BAT > NCA_BATTERY_1EIGTH)
Draw_Battery(STACKS_EMPTY);
else
Display_Bat_Frame_Flash();
@@ -365,15 +350,15 @@ void Display_Battery_CF() // cap fitted
if (Bat_Type == LITHIUM)
{
if(adc.V_BAT >= L_BATTERY_NINETY)
if(sys.adc.V_BAT >= L_BATTERY_NINETY)
Draw_Battery(STACKS_4);
else if(adc.V_BAT > L_BATTERY_3QUARTERS)
else if(sys.adc.V_BAT > L_BATTERY_3QUARTERS)
Draw_Battery(STACKS_3);
else if(adc.V_BAT > L_BATTERY_FIFTY)
else if(sys.adc.V_BAT > L_BATTERY_FIFTY)
Draw_Battery(STACKS_2);
else if(adc.V_BAT > L_BATTERY_1QUARTER)
else if(sys.adc.V_BAT > L_BATTERY_1QUARTER)
Draw_Battery(STACKS_1);
else if (adc.V_BAT > L_BATTERY_1EIGTH)
else if (sys.adc.V_BAT > L_BATTERY_1EIGTH)
Draw_Battery(STACKS_EMPTY);
else
Display_Bat_Frame_Flash();
@@ -382,15 +367,15 @@ void Display_Battery_CF() // cap fitted
else
{
if(adc.V_BAT >= A_BATTERY_NINETY)
if(sys.adc.V_BAT >= A_BATTERY_NINETY)
Draw_Battery(STACKS_4);
else if(adc.V_BAT > A_BATTERY_3QUARTERS)
else if(sys.adc.V_BAT > A_BATTERY_3QUARTERS)
Draw_Battery(STACKS_3);
else if(adc.V_BAT > A_BATTERY_FIFTY)
else if(sys.adc.V_BAT > A_BATTERY_FIFTY)
Draw_Battery(STACKS_2);
else if(adc.V_BAT > A_BATTERY_1QUARTER)
else if(sys.adc.V_BAT > A_BATTERY_1QUARTER)
Draw_Battery(STACKS_1);
else if (adc.V_BAT > A_BATTERY_1EIGTH)
else if (sys.adc.V_BAT > A_BATTERY_1EIGTH)
Draw_Battery(STACKS_EMPTY);
else
Display_Bat_Frame_Flash();
@@ -471,25 +456,15 @@ void Display_Mode(uint8_t Con_Mode1)
{
uint8_t What; // What to display
// Con_Mode1 = Cur_Mode; // Currently indexed is the selected.
// mod_Array[Cur_Mode].Select = false;
//What = mode_Array[Cur_Mode].Plugged;
switch(Con_Mode1) // Where to draw
{
case BROADCAST:
//GL_DrawMonoBitmap(border60x60, LCD_X_MAX-60,LCD_Y_MIN + 2, LCD_DRAW_SET); // Always draw
// GL_DrawMonoBitmap(clampIcon2, LCD_X_MAX-60,LCD_Y_MIN + 2, LCD_DRAW_SET); // Always draw
// GL_DrawMonoBitmap(directConnectIcon3, LCD_X_MAX-60,LCD_Y_MIN + 2, LCD_DRAW_SET); // Always draw
// GL_DrawMonoBitmap(directConnectIcon5, LCD_X_MAX-60,LCD_Y_MIN + 2, LCD_DRAW_SET); // Always draw
{
GL_DrawMonoBitmap(inductionIcon, LCD_X_MAX-60,LCD_Y_MIN + 2, LCD_DRAW_SET); // Always draw
// GL_DrawMonoBitmap(lamp, LCD_X_MAX-28,LCD_Y_MIN + 2, LCD_DRAW_SET); // Always draw
break;
}
case PORT1_A: // ACtually PORT 2
What = ACCY_GetConnectedAccessory(1);
@@ -968,7 +943,7 @@ void Display_Over_Voltage_Status(void)
{
static uint32_t county = 0;
if(Over_Voltage_Flag)
if(sys.status[OVERVOLTAGE])
{
if(county<3)
{
@@ -1008,13 +983,13 @@ void Display_OnScreen_Diagnostics(void)
sprintf(tempString,"Taps %d", Display_Taps());
FL_DrawString(tempString, 0, 20, font10Bold, LCD_DRAW_SET, FL_ALIGN_LEFT);
sprintf(tempString,"B %.2fV",adc.V_BAT);
sprintf(tempString,"B %.2fV",sys.adc.V_BAT);
FL_DrawString(tempString, 0, 60, font10Bold, LCD_DRAW_SET, FL_ALIGN_LEFT);
// sprintf(tempString,"VPSU %.2fV", adc.V_PSU);
// sprintf(tempString,"VPSU %.2fV", sys.adc.V_PSU);
// FL_DrawString(tempString, 0, 80, font10Bold, LCD_DRAW_SET, FL_ALIGN_LEFT);
sprintf(tempString,"C %.2fV",adc.V_CHK);
sprintf(tempString,"C %.2fV",sys.adc.V_CHK);
FL_DrawString(tempString, 0, 70, font10Bold, LCD_DRAW_SET, FL_ALIGN_LEFT);
@@ -1030,7 +1005,7 @@ void Display_OnScreen_Diagnostics(void)
FL_DrawString(tempString, 0, 80, font10Bold, LCD_DRAW_SET, FL_ALIGN_LEFT);
}
// sprintf(tempString,"R %.2f",adc.IRawFilt);
// sprintf(tempString,"R %.2f",sys.adc.IRawFilt);
// FL_DrawString(tempString, 0, 80, font10Bold, LCD_DRAW_SET, FL_ALIGN_LEFT);
}
@@ -1089,9 +1064,9 @@ void Display_OnScreen_Diagnostics(void)
// sprintf(tempString, "1: %.2f", adc.V_ID1);
// sprintf(tempString, "1: %.2f", sys.adc.V_ID1);
// FL_DrawString( tempString, 0, 0, font12Bold, LCD_DRAW_SET, FL_ALIGN_LEFT);
// sprintf(tempString, "2: %.2f", adc.V_ID2);
// sprintf(tempString, "2: %.2f", sys.adc.V_ID2);
// FL_DrawString( tempString, 0, 15, font12Bold, LCD_DRAW_SET, FL_ALIGN_LEFT);
// sprintf(tempString, "%d", Power_Level); // Display number
// FL_DrawString(tempString, 120, 00, font18Bold, LCD_DRAW_SET, FL_ALIGN_LEFT);

21
source/frq.c
View File

@@ -22,6 +22,7 @@
#include "stdbool.h"
#include "eeprom.h"
#include "pwr_level.h"
#include "System/system.h"
extern uint8_t Test_Mode, catch_up_flag;
extern uint8_t Taps_Flag;
@@ -263,29 +264,14 @@ void FREQ_Init(void)
freq.numFrequencies = 0;
if(Test_Mode) //
{
FREQ_LoadFactoryDefaults();
// frq_update_flag = false;
}
else
{
if(!EE_LoadFrequencies())
{
FREQ_LoadFactoryDefaults();
}
}
Send_Ctrl_Word(SLP_CTRL_WRD,SDSIGNAL); // Put unused DDS to sleep
// tmp = Calc_Freq(32768);
// Load_Frq_Gen(SINGLE,tmp,0); // testing only 8KHz
// Load_Ramp(7829367); // 350KHz ramp waveform
Load_Ramp(6710886); // 300KHz ramp waveform
// Load_Ramp(20132659); // 900KHz ramp waveform
// Load_Ramp(72370199); // 3.2352MHz ramp waveform
}
@@ -684,6 +670,11 @@ FREQUENCY_t FREQ_GetFreqByIndex(uint32_t index)
return freqArray[index];
}
FREQUENCY_t* FREQ_GetFreqPointerByIndex(uint32_t index)
{
return &freqArray[index];
}
uint32_t FREQ_GetNumFrequencies(void)
{
return freq.numFrequencies;

1
source/frq.h
View File

@@ -117,6 +117,7 @@ void Load_Frq_Gen(FRQ_OUT_SELECT_t, int32_t, int32_t); // NONE,either or both pl
uint8_t Next_Frequency(uint8_t frequency);
void FREQ_ToggleEnable(uint32_t selected);
FREQUENCY_t FREQ_GetFreqByIndex(uint32_t index);
FREQUENCY_t* FREQ_GetFreqPointerByIndex(uint32_t index);
uint32_t FREQ_GetNumFrequencies(void);
void FREQ_GetFrequencyName(uint32_t index, uint8_t *string);
void Send_Ctrl_Word(uint16_t Control_Reg, SPI_MODE_t mode);

40
source/init.c
View File

@@ -8,10 +8,10 @@
#include "arm_math.h"
#include <stdbool.h>
#include <stdint.h>
#include <ctype.h>
#include "init.h"
#include "taps.h"
#include "measure.h"
#include "ports.h"
#include "utils.h"
#include "frq.h"
@@ -38,7 +38,6 @@
#include "System/system.h"
extern uint8_t OverVolts_Flag,catch_up_flag; // global OverVoltsFlag
extern ADC_t adc;
extern MODE_REC_t mode_Array[MODE_MAX_NUM];
extern uint8_t Cur_Mode, Old_Mode;
extern uint8_t Port_State[];
@@ -60,12 +59,13 @@ extern uint8_t Safety_Select,Suspend_Step_Chk;
uint8_t Safe_Mode, Init_Done;
extern uint16_t Estop_timer,Sys_Chk_tmr,Pot_Value[],Vchktmr,Key_Lock_Out_tmr;
extern uint8_t Dds_Pot_Val[]; // 2 byte Data for SPI
float32_t Max_Power_Limit;
extern uint32_t TX_TIME[];
extern uint32_t Sys_Timer,Tx_timer;
extern float32_t last_Ohms;
extern uint16_t PSU_Check_tmr,Power_tmr;
extern SYSTEM_DATA_t sys;
void Init_vars()
{
Taps_adjust_timer = DELAY_ONE_SECOND;
@@ -81,9 +81,9 @@ void Init_vars()
// Tx_timer = TX_TIME[0]; // reload the timer
Safety_Select = false;
Over_Voltage_Flag = false;
sys.status[OVERVOLTAGE] = false;
Safe_Mode = false;
Test_Mode = false; //
Test_Mode = false;
char *ver = SW_VERSION;
@@ -102,7 +102,7 @@ void Init_vars()
Key_Lock_Out_tmr = 0;
step_count = 0;
PSU_Check_tmr = PSU_DELAY;
Max_Power_Limit = 5.0; // default until battery type determined.
sys.maxPowerLimit = POWER_LIMIT_ALKALINE; // default until battery type determined.
last_Ohms = 1;
Taps_Flag = false;
catch_up_flag= false;
@@ -141,7 +141,7 @@ void Init_Ports() // Ensure all ports are set to safe when powering up
// [Not BYPASSED,PSU OFF, ALL AMPS SWITCHED OFF, BACKLIGHT ON.]
Select_Estop(ON);
Select_Estop(ISOLATED);
Port_State[TOP_SR] = 0x00; //
Port_State[MID_SR] = 0x00; // U12
@@ -163,7 +163,7 @@ void Clear_Flags()
void Init_Output(void)
{
if(adc.V_CHK < EXCEDED) // Read external voltage disable if present
if(sys.adc.V_CHK < EXCEDED) // Read external voltage disable if present
{
// Read_Tx_Ports(); // check for what's connected is controlled from timer interrupt
@@ -194,18 +194,9 @@ uint8_t i;
for(i = 0; i <= MODE_MAX_NUM; i++ )
{
mode_Array[i].Selected = true;
mode_Array[i].Plugged = true;
}
mode_Array[BROADCAST].Selected = true; //default BCAST always available
mode_Array[BROADCAST].Plugged = BROADCAST;
mode_Array[PORT1_A].Plugged = ID_TX_SINGLE_DIRECT;
mode_Array[PORT1_B].Plugged = EMPTY;
mode_Array[PORT2_A].Plugged = ID_TX_DUAL_DIRECT;
mode_Array[PORT2_B].Plugged = ID_TX_DUAL_DIRECT;
mode_Array[PORT2_A].Selected = false;
mode_Array[PORT2_B].Selected = false;
@@ -288,8 +279,6 @@ void Normal_Init(void)
Init_vars();
// Init_peripherals(); 2/9/24
// Init_sys(); 2/9/24
BL_ReadInfo();
EE_LoadData(); //Read saved data
@@ -299,16 +288,9 @@ void Normal_Init(void)
Delay_Ticks(200); // execute short delay
KEY_Init(); //Init keys after splash delay to prevent POWER short press on startup
// USB_Init();
// Read_Tx_Ports(); // Read output ports and determine what is connected
// Select_Amplifier(); // Select correct amplifier according to frequency
Init_Mode(); //
//init_PWM();
// PWM_Setup(32768, BC_Duty_Cycle);//freqArray[frequency].frequency1
// PWM_Setup(29430, BC_Duty_Cycle);
PWM_Setup(15890, 0); // switches off PWM
@@ -329,18 +311,17 @@ void Normal_Init(void)
for( i=0; i < 15; i++);
{
Delay_Ticks(10);
// ADC_Update();
Read_Tx_Ports(); // check for whats plugged in at the ports every 100mS.
}
if ((adc.V_ID2 > 3.0) && (adc.V_ID1 > 3.0))
if ((sys.adc.V_ID2 > 3.0) && (sys.adc.V_ID1 > 3.0))
{
Cur_Mode = BROADCAST;
Port_changed_flag= 1;
init_flag = 1;
}
Disconnect(2);
Disconnect(ACCY_PORT_2);
Delay_Ticks(30);
Check_For_Clamp_On_Pwr_Up();
@@ -361,6 +342,7 @@ void Normal_Init(void)
Update_Frequency();
// Select_Bypass(OFF);
// HACK
Select_Estop(OFF); // Ensure output is ISOLATED from connections
Init_Amplitude();

3
source/init.h
View File

@@ -11,6 +11,9 @@
#define MID_POINT_PSU 128 // 25V
#define INIT_PWR_LEVEL 0
#define HI_VOLTS 7 //ADC CHannel 7
#define EXCEDED 500 // High voltage value at port
void Clear_Flags(void);
void Init_Output(void);
void Init_Amplitude(void); // set amplitude to minimum

45
source/io.c Normal file
View File

@@ -0,0 +1,45 @@
#include "io.h"
#include "spi.h"
#define EXPANDER_SIZE 3
static uint8_t _expanderState[EXPANDER_SIZE]; // copy of Shift register I/O expander
//Port_State[BOTTOM_SR] |= TAP2_LF_ON;
void io_expanderSet(uint8_t port, uint8_t pins, bool update)
{
_expanderState[port] |= pins;
if (update)
{
io_update();
}
}
void io_expanderClear(uint8_t port, uint8_t pins, bool update)
{
_expanderState[port] &= ~pins;
if (update)
{
io_update();
}
}
// update I/O expander
void io_update(void)
{
SPI0_SendBytes(_expanderState, EXPANDER_SIZE, EXPANDER);
}
void io_expanderSetSafe(void)
{
_expanderState[BOT_SR] = 0;
_expanderState[MID_SR] = 0;
_expanderState[TOP_SR] = 0;
io_update();
}

88
source/io.h
View File

@@ -2,26 +2,36 @@
#define IO_H_
#include "fsl_gpio.h"
#include <stdbool.h>
void io_expanderSet(uint8_t port, uint8_t pins, bool update);
void io_expanderClear(uint8_t port, uint8_t pins, bool update);
void io_expanderSetSafe(void);
void io_update(void);
#define LOW 0
#define HIGH 1
#define PORT0 0
#define PORT1 1
// GPIO
#define IO_PORT0 0
#define IO_PORT1 1
#define PIN_VBUS (PORT1, 6)
#define PIN_POT_CS (PORT1, 7)
#define PIN_SIG_CS (PORT1, 9)
#define PIN_SD_CS (PORT1, 10)
#define PIN_RAMP_CS (PORT1, 11)
#define PIN_SIG_RESET (PORT1, 12)
#define PIN_SD_RESET (PORT1, 13)
#define PIN_RAMP_RST (PORT1, 14)
#define PIN_POWER_CTL (PORT1, 16)
#define PIN_ESTOP (PORT1, 17)
#define PIN_VBUS (IO_PORT1, 6)
#define PIN_SIG_CS (IO_PORT1, 9)
#define PIN_SD_CS (IO_PORT1, 10)
#define PIN_RAMP_CS (IO_PORT1, 11)
#define PIN_SIG_RESET (IO_PORT1, 12)
#define PIN_SD_RESET (IO_PORT1, 13)
#define PIN_RAMP_RST (IO_PORT1, 14)
#define PIN_POWER_CTL (IO_PORT1, 16)
#define PIN_ESTOP (IO_PORT1, 17)
#define PIN_KEY_UP (PORT0, 2)
#define PIN_KEY_DOWN (PORT0, 3)
#define PIN_KEY_UP (IO_PORT0, 2)
#define PIN_KEY_DOWN (IO_PORT0, 3)
#define PIN_POT_CS (IO_PORT0, 7)
#define PIN_EEP_CS (IO_PORT0, 10)
#define PIN_PORT_LE_CS (IO_PORT0, 19)
#define PIN_POT_CS2 (IO_PORT0, 21)
#define _P1(p1, p2) p1
#define _P2(p1, p2) p2
@@ -30,4 +40,54 @@
#define GPIO_READ(port_pin) GPIO_PinRead (GPIO, _P1 port_pin, _P2 port_pin)
// Shift Register Port Expander
#define UPDATE true
#define NO_UPDATE false
#define TOP_SR 0
#define MID_SR 1
#define BOT_SR 2
#define TAPS_OFF_MASK 0b11100111
// Bottom Shift Register (U35)
#define AMP_AB_SW 0b00000001
#define AMP_D_ON 0b00000010
#define AMP_PSU 0b00000100
#define TAP_204_LF 0b00001000
#define TAP_102_LF 0b00010000
#define BKLITE_ON 0b00100000
#define SLCT_AMP 0b01000000
#define V_GAIN 0b10000000
// Mid Shift Register (U33)
#define LF_BYPASS 0b00000001
#define SLCT_XFRMR 0b00000010
#define TAP_102_HF 0b00000100
#define SLCT_GRP 0b00001000
#define SLCT_OUTPUT 0b00010000
#define DAMP_EN 0b00100000
#define I_GAIN 0b01000000
#define ANT_AMP_EN 0b10000000
// Top Shift Register (U34)
#define MUX_AB_AMP 0b00000001
#define ANT_AMP_SW 0b00000010
#define EXTEND_PSU 0b00000100
#define OSC_MUX0 0b00001000
#define OSC_MUX1 0b00010000
#define RST_RF 0b00100000
#define TOP_SR_NC1 0b01000000
#define TOP_SR_NC2 0b10000000
#define _TAP1_LF_ON (BOTTOM_SR, TAP_102_LF | TAP_204_LF)
#define _TAP2_LF_ON (BOTTOM_SR, TAP_102_LF)
#define _TAP3_LF_ON (BOTTOM_SR, TAP_204_LF)
#define _TAP4_LF_ON (BOTTOM_SR, 0)
#define BYPASS_ON (MID_SR, LF_BYPASS)
#define EXPANDER_SET(port_pins, update) io_expanderSet (_P1 port_pins, _P2 port_pins, update)
#define EXPANDER_CLEAR(port_pins, update) io_expanderClear(_P1 port_pins, _P2 port_pins, update)
#endif

2
source/keys.h
View File

@@ -62,6 +62,8 @@
#define KEY_SEL KEY4 //Enter / Select in menu
#define KEY_ENTER KEY4 //Enter / Select in menu
#define KEY_REPEAT_TIME 100 // msec
//Keith Translations
#define ON_OFF_KEY KEY0
#define FRQ_KEY KEY4

1
source/lcd.c
View File

@@ -56,7 +56,6 @@ uint8_t mFrameBuffer[LCD_HEIGHT_PIXELS/8][LCD_WIDTH_PIXELS]; //x,y
extern uint8_t Power_Level, Over_Voltage_Flag, Task,Error;
extern uint8_t tempString[];
extern uint8_t frequency, Cur_Mode, Safe_Mode;
extern ADC_t adc;
extern uint8_t Dds_Pot_Val[];
extern uint8_t Port_State[];
extern uint8_t Diag_Flag;

220
source/main.c
View File

@@ -25,7 +25,6 @@
#include "mode.h"
#include "utils.h"
#include "timer.h"
#include "over_ride.h"
#include "menu.h"
#include "sys_chk.h"
#include "amps.h"
@@ -55,7 +54,7 @@
extern volatile uint8_t BC_Duty_Cycle;
uint8_t Task,Tx_Time_Out_Flag,i,Test_Mode;
extern uint8_t Power_Level,Over_Voltage_Flag,Safe_Mode;
extern uint8_t Power_Level,Safe_Mode;
extern uint8_t Port_State[];
extern uint8_t old_freq, frequency, frq_chg_tmr,Cur_Mode;
extern uint8_t Bat_Type,Bcast_Pwr_Level;
@@ -63,7 +62,6 @@ extern uint16_t Port_timer, Taps_adjust_timer,Sys_Chk_tmr,Shut_down_tmr;
extern uint8_t Port_changed_flag;
extern uint16_t Low_Bat_timer,Estop_timer;
extern uint32_t what_val1, what_val2;
extern ADC_t adc;
extern uint32_t new_freq;
uint8_t init_flag,catch_up_flag;
uint8_t Selected = false;
@@ -72,14 +70,37 @@ extern HARDWARE_FIX_t hwf;
extern uint8_t tempString[40]; // Todo move
extern SYSTEM_DATA_t sys;
#define BYPASS_USB_SAFETY 0 //Use for debugging
#define DDS_PLL_TEST 0
ClampData_t clampData;
void setSafeMode(bool safe)
{
sys.safeMode = safe;
Select_Estop((safe ? ON : OFF));
if (safe)
{
//clear shift registers to known state
Port_State[MID_SR] = USB_STATE_MID; //
Port_State[BOTTOM_SR] = USB_STATE_BOT; //
Port_State[TOP_SR] = USB_STATE_TOP;
SPI0_SendBytes(Port_State, 3, EXPANDER); // Update shift register
Delay_Ticks(1);
Send_Ctrl_Word(SLP_CTRL_WRD2, SIGNAL); // Switch signal off
}
}
bool isUsbConnected(void)
{
return GPIO_READ(PIN_VBUS);
}
int main(void)
{
bool prevUsbConnected = false;
sys.usbConnected = false;
// indicate no slope calulated since slope will always be positive
clampData.slope = -1.0f;
@@ -99,6 +120,8 @@ int main(void)
POWER_DisablePD(kPDRUNCFG_PD_USB0_PHY); /*Turn on USB Phy */
Power_ON_OFF(ON); // Enable_Psu(); Ensure Power supply stays switched on.
Select_Estop(ON); // Ensure output is ISOLATED from connections
@@ -109,42 +132,21 @@ int main(void)
Init_sys();
//###################
Check_For_Usb(); // Set everything safe if so
//Check_For_Usb(); // Set everything safe if so
KEY_Init(); //Init keys after splash delay to prevent POWER short press on startup
// Display_Splash(); //Display splash screen
// Delay_Ticks(100); // execute short delay
BL_ReadInfo();
EE_LoadData(); //Read saved data
#if !BYPASS_USB_SAFETY
if(GPIO_PinRead(GPIO,1,6))
{
USB_Init();
Display_Splash(); //Display splash screen
Delay_Ticks(100); // execute short delay
}
while(GPIO_PinRead(GPIO,1,6))
{
LCD_Clear();
Display_USB(); //Display USB icon
LCD_Update();
Delay_Ticks(1); // execute short delay
safe_key(); // process primary keys as safety menu
USB_Update();
}
#endif
//###################
Display_Splash(); //Display splash screen
Delay_Ticks(100); // execute short delay
ADC_Init2();
ADC_SysInit();
ACCY_Init();
KEY_Init(); //Init keys after splash delay to prevent POWER short press on startup
@@ -170,21 +172,16 @@ int main(void)
Cur_Mode = PORT2_A;
init_flag = 0;
for( i=0; i < 15; i++)
{
Delay_Ticks(10);
// ADC_Update();
// Read_Tx_Ports(); // check for whats plugged in at the ports every 100mS.
}
if ((adc.V_ID2 > 3.0) && (adc.V_ID1 > 3.0))
if ((sys.adc.V_ID2 > 3.0) && (sys.adc.V_ID1 > 3.0))
{
Cur_Mode = BROADCAST;
Port_changed_flag= 1;
init_flag = 1;
}
Disconnect(2);
Disconnect(ACCY_PORT_2);
Delay_Ticks(30);
Check_For_Clamp_On_Pwr_Up();
@@ -201,6 +198,7 @@ int main(void)
Update_Frequency();
// Select_Bypass(OFF); // 3/14/24
// HACK
Select_Estop(OFF); // Restore output.
Init_Amplitude();
@@ -209,47 +207,40 @@ int main(void)
Menu_init();
sys.guiMode = GUI_MODE_NORMAL;
#if DDS_PLL_TEST
//# Insert special test code here.
uint32_t tmp;
All_Amps_Off();
// Set OBPTEN
tmp = Calc_Freq(3500090);
Load_Frq_Gen(SINGLE,tmp,0); // # update the frequency generators
//# End Test code
#endif
while(1)
{
static uint32_t tickCount = 0;
sys.usbConnected = isUsbConnected();
USB_Update(); //Update USB here so we're outside the ISR
#if !BYPASS_USB_SAFETY
//#####################
Check_For_Usb();
if(GPIO_READ(PIN_VBUS))
{
Task = USB_SAFE_TASK; // process primary keys as safety menu
safe_key(); // process primary keys as safety menu
LCD_Clear();
Display_USB(); //Display USB icon
LCD_Update();
if (sys.usbConnected)
{
// USB connected
if (!prevUsbConnected)
{
setSafeMode(true);
}
Display_USB();
}
else
if(!GPIO_READ(PIN_VBUS) && Ports_Cleared_Flag)
{
// USB disconnected
if (prevUsbConnected)
{
//setSafeMode(false);
Normal_Init(); // USB is unplugged so reinitialize
setSafeMode(false);
prevUsbConnected = false;
}
}
//###############################
#endif
Delay_Ticks(1); //10mS delay
@@ -258,13 +249,9 @@ uint32_t tmp;
Tx_TimeOut(); // Check main transmitter timer
#if !BYPASS_USB_SAFETY
if((tickCount++ % 10 == 0) && !GPIO_READ(PIN_VBUS)) //every 10 ticks = 100mS AND !USB
#else
if(tickCount++ % 10 == 0) //every 10 ticks = 100mS
#endif
// TODO: replace with system time
if(tickCount++ % 10 == 0)
{
uint32_t pressed = 0;
if (sys.guiMode == GUI_MODE_MENU)
@@ -275,16 +262,70 @@ uint32_t tmp;
{
pressed = KEY_GetPressed();
if (sys.safeMode)
{
// only allow power off while in safe mode
if (pressed != KEY_POWER)
{
pressed = MENU_ID_NONE;
}
}
switch(pressed)
{
case KEY_POWER:
{
Power_Down();
break;
}
case MENU_KEY:
{
Menu_mainMenu();
break;
}
case FRQ_KEY:
{
freq_key_process();
break;
}
case MODE_KEY:
{
mode_menu();
break;
}
#if 0
case PWR_UP_KEY:
{
if(Key_Lock_Out_tmr == 0)
{
Vchktmr = LOCK_OUT_DELAY;
inc_pwr();//increment the power output
Key_Lock_Out_tmr = KEY_LOCK_TIME;
Suspend_Step_Chk = false;
step_count = 0;
}
}
break;
case PWR_DN_KEY:
{
if(Key_Lock_Out_tmr == 0)
{
Vchktmr = LOCK_OUT_DELAY;
dec_pwr();// decrement the power output
Key_Lock_Out_tmr = KEY_LOCK_TIME;
Suspend_Step_Chk = false;
step_count = 0;
}
break;
}
#endif
}
Display_Update();
}
@@ -292,38 +333,11 @@ uint32_t tmp;
switch (Task)
{
case SAFETY_TASK:
safe_key(); // process primary keys as safety menu
break;
case USB_SAFE_TASK:
safe_key(); // process primary keys as safety menu
break;
case FATAL_ERROR_TASK:
safe_key(); // process primary keys as safety menu
break;
case PRIMARY_TASK:
pro_key(pressed); // process primary keys front 6 first menu
break;
case MENU_TASK: // Allows user to select options
menu_key();
Task = PRIMARY_TASK;
break;
case MODE_TASK: // Selects between DC || BC
mode_menu();
Task = PRIMARY_TASK;
break;
case PWR_OFF_TASK:
Power_Down(); // Stores last settings and powers off
break;
case OVER_RIDE_TASK: // Allows user to Over ride safe settings
Over_Ride(); // schedule Over Ride Menu
KEY_ClearKeyPresses();
break;
case BAT_INSERTION_ERROR:
if(Shut_down_tmr == 0); //Display_Bat_Error();
@@ -379,8 +393,11 @@ uint32_t tmp;
}
else
{
Port_State[MID_SR] |= BYPASS_ON; // Set relay to By Pass protection cap
SPI0_SendBytes(Port_State, 3, EXPANDER); // Send_Update_Port();
EXPANDER_SET(BYPASS_ON, true);
//Port_State[MID_SR] |= BYPASS_ON; // Set relay to By Pass protection cap
//SPI0_SendBytes(Port_State, 3, EXPANDER); // Send_Update_Port();
}
@@ -394,15 +411,16 @@ uint32_t tmp;
if (Taps_adjust_timer == 0)
Check_Taps(); // Check for optimum Taps
#endif
// Display_Update();
}
}
prevUsbConnected = sys.usbConnected;
} // while (1)
}

54
source/measure.c
View File

@@ -1,54 +0,0 @@
/*
* measure.c
*
* Created on: Jun 7, 2022
* Author: Keith.Lloyd
*/
#include "fsl_spi.h"
#include "pin_mux.h"
#include "board.h"
#include "fsl_debug_console.h"
#include <stdio.h>
#include <math.h>
#include <stdbool.h>
#include <string.h>
#include <stdint.h>
#include <arm_math.h>
#include "measure.h"
#include "frq.h"
#include "ports.h"
#include "adc.h"
#include "amps.h"
extern float32_t Volts;
extern float32_t Amps;
extern float32_t Ohms;
extern float32_t Watts,Max_Power_Limit;
extern uint8_t frequency;
extern uint8_t Port_State[];
extern ADC_t adc;
float Calc_Max_current(void)
{
float a;
if(freqArray[frequency].frequency1 <= MAX_DTYPE)
a = sqrtf(Max_Power_Limit / adc.Ohms_slowfilt);
else
a = sqrtf(1/adc.Ohms_slowfilt);
return(a);
}

21
source/measure.h
View File

@@ -1,21 +0,0 @@
/*
* measure.h
*
* Created on: Mar 24, 2023
* Author: Keith.Lloyd
*/
#ifndef MEASURE_H_
#define MEASURE_H_
void Measure_Volts(void);
void Measure_Current(void);
void Calculate_Volts(void);
void Calculate_Current(void);
float Calc_Max_current(void);
#define HI_VOLTS 7 //ADC CHannel 7
#define EXCEDED 500 // High voltage value at port
#endif /* MEASURE_H_ */

206
source/menu.c
View File

@@ -73,7 +73,6 @@ extern SYSTEM_DATA_t sys;
extern uint8_t Cur_Mode;
extern ADC_t adc;
extern uint8_t frequency,psu_failed;
extern uint8_t Dds_Pot_Val[];
extern uint8_t Port_State[];
@@ -81,8 +80,9 @@ extern uint8_t Port_State[];
extern HARDWARE_FIX_t hwf;
extern uint32_t systemTime;
MenuItem_t _menuItems[50];
#define MENU_ITEM_SIZE 50
MenuItem_t _menuItems[MENU_ITEM_SIZE];
int _menuItemsIndex;
/*******************************************************************************
@@ -93,6 +93,7 @@ static Menu_t* getNewMenu(MenuHandler_t handler);
static Menu_t* getCurrentMenu(void);
static int handleSystemInfoMenu(Menu_t *menu);
static int handleAutoShutdown(Menu_t *menu);
static int handleFrequencies(Menu_t *menu);
static void ClearMenuItems(MenuItem_t items[], uint32_t num);
@@ -120,11 +121,13 @@ static void createMenuItem(MenuItemId_t id, MenuItem_t *item)
{
item->id = id;
item->handler = NULL;
switch (id)
{
case MENU_ID_SYSINFO:
{
item->pMonoIcon = menuMore;
item->pMonoIcon = (uint32_t*)menuMore;
strcpy(item->text, "System Information");
item->handler = handleSystemInfoMenu;
break;
@@ -132,8 +135,9 @@ static void createMenuItem(MenuItemId_t id, MenuItem_t *item)
case MENU_ID_FREQUENCIES:
{
item->pMonoIcon = menuMore;
item->pMonoIcon = (uint32_t*)menuMore;
strcpy(item->text, "Frequencies");
item->handler = handleFrequencies;
break;
}
@@ -147,7 +151,14 @@ static void createMenuItem(MenuItemId_t id, MenuItem_t *item)
case MENU_ID_LANGUAGE:
{
item->pMonoIcon = menuMore;
item->pMonoIcon = (uint32_t*)menuMore;
strcpy(item->text, "Language");
break;
}
case MENU_ID_FREQUENCY:
{
item->pMonoIcon = NULL;
strcpy(item->text, "Language");
break;
}
@@ -155,7 +166,7 @@ static void createMenuItem(MenuItemId_t id, MenuItem_t *item)
}
static void handleUpDown(uint32_t pressed, Menu_t *menu)
static void handleMenuKeys(uint32_t pressed, Menu_t *menu)
{
switch (menu->longPress)
{
@@ -166,7 +177,7 @@ static void handleUpDown(uint32_t pressed, Menu_t *menu)
if (systemTime >= menu->nextRepeat)
{
pressed = KEY_UP;
menu->nextRepeat = systemTime + 100;
menu->nextRepeat = systemTime + KEY_REPEAT_TIME;
}
}
else
@@ -217,10 +228,12 @@ static void handleUpDown(uint32_t pressed, Menu_t *menu)
{
menu->selected++;
if(menu->selected >= menu->itemCount)
{
menu->selected = menu->itemCount - 1;
}
menu->draw = true;
break;
@@ -233,6 +246,13 @@ static void handleUpDown(uint32_t pressed, Menu_t *menu)
menu->nextRepeat = 0;
break;
}
case KEY_BACK:
{
menu->exitCode = MENU_EXIT;
break;
}
}
if (menu->draw)
@@ -246,6 +266,14 @@ static void handleUpDown(uint32_t pressed, Menu_t *menu)
menu->displayIndex--;
}
}
if (pressed == KEY_ENTER)
{
if (menu->items[menu->selected].handler != NULL)
{
menu->items[menu->selected].handler(NULL);
}
}
}
static void drawScrollBar(Menu_t *menu)
@@ -293,11 +321,11 @@ static int handleAutoShutdown(Menu_t *menu)
}
static int handleSystemInfoMenu(Menu_t *menu)
static int handleFrequencies(Menu_t *menu)
{
if (menu == NULL)
{
menu = getNewMenu(handleSystemInfoMenu);
menu = getNewMenu(handleFrequencies);
if (menu == NULL)
{
@@ -308,10 +336,20 @@ static int handleSystemInfoMenu(Menu_t *menu)
if (menu->init)
{
int itemCount = 0;
menu->items = &_menuItems[_menuItemsIndex];
MenuItem_t *item;
int numFreq = FREQ_GetNumFrequencies();
createMenuItem(MENU_ID_SYSINFO , &menu->items[itemCount++]);
createMenuItem(MENU_ID_FREQUENCIES , &menu->items[itemCount++]);
for (int i=0; i<numFreq; ++i)
{
item = &menu->items[itemCount++];
item->id = MENU_ID_FREQUENCY;
item->handler = NULL;
FREQ_GetFrequencyName(i, item->text);
item->data = (void*)FREQ_GetFreqPointerByIndex(i);
}
_menuItemsIndex += itemCount;
menu->itemCount = itemCount;
menu->init = false;
menu->draw = true;
@@ -320,19 +358,14 @@ static int handleSystemInfoMenu(Menu_t *menu)
uint32_t pressed = KEY_GetPressed();
handleUpDown(pressed, menu);
handleMenuKeys(pressed, menu);
if (pressed == KEY_BACK)
{
menu->exitCode = MENU_EXIT;
}
else
if (pressed == KEY_ENTER)
{
if (menu->items[menu->selected].handler != NULL)
{
menu->items[menu->selected].handler(NULL);
}
FREQUENCY_t *freq = (FREQUENCY_t*)menu->items[menu->selected].data;
freq->enabled ^= 1;
menu->draw = true;
}
if (menu->draw)
@@ -348,14 +381,17 @@ static int handleSystemInfoMenu(Menu_t *menu)
{
item = &menu->items[i];
//Menu strings
FL_DrawTranslatedString(item->text, MENU_MAIN_TEXT_X, MENU_MAIN_TEXT_Y_START + (i-menu->displayIndex)*MENU_LINE_HEIGHT, MENU_FONT, LCD_DRAW_SET, FL_ALIGN_LEFT);
//Frequency name
FL_DrawString(item->text, MENU_MAIN_TEXT_X, MENU_MAIN_TEXT_Y_START + (i - menu->displayIndex)*MENU_LINE_HEIGHT, MENU_FONT, LCD_DRAW_SET, FL_ALIGN_LEFT);
// Draw item status
if (item->pMonoIcon != NULL)
//checkBoxes
if(FREQ_GetFreqByIndex(i).enabled)
{
GL_DrawMonoBitmap(item->pMonoIcon, MENU_MAIN_STATUS_X, MENU_MAIN_TEXT_Y_START + (i-menu->displayIndex)*MENU_LINE_HEIGHT + MENU_MAIN_STATUS_Y_OFF, LCD_DRAW_SET);
GL_DrawMonoBitmap(box_checked, MENU_MAIN_STATUS_X, MENU_MAIN_TEXT_Y_START +2+ (i - menu->displayIndex)*MENU_LINE_HEIGHT, LCD_DRAW_SET);
}
else
{
GL_DrawMonoBitmap(box_unchecked, MENU_MAIN_STATUS_X, MENU_MAIN_TEXT_Y_START +2+ (i - menu->displayIndex)*MENU_LINE_HEIGHT, LCD_DRAW_SET);
}
@@ -374,7 +410,56 @@ static int handleSystemInfoMenu(Menu_t *menu)
return menu->exitCode;
//SystemInfoMenu();
}
static int handleSystemInfoMenu(Menu_t *menu)
{
if (menu == NULL)
{
menu = getNewMenu(handleSystemInfoMenu);
if (menu == NULL)
{
return MENU_EXIT;
}
}
if (menu->init)
{
menu->items = NULL;
menu->itemCount = 2;
menu->init = false;
menu->draw = true;
}
uint32_t pressed = KEY_GetPressed();
handleMenuKeys(pressed, menu);
if (menu->draw)
{
LCD_Clear();
if (menu->selected == 0)
{
FL_DrawString("Menu 1", MENU_MAIN_TEXT_X, MENU_MAIN_TEXT_Y_START, MENU_FONT, LCD_DRAW_SET, FL_ALIGN_LEFT);
}
else
if (menu->selected == 1)
{
FL_DrawString("Menu 2", MENU_MAIN_TEXT_X, MENU_MAIN_TEXT_Y_START, MENU_FONT, LCD_DRAW_SET, FL_ALIGN_LEFT);
}
LCD_Update();
menu->draw = false;
}
return menu->exitCode;
}
static int handleMainMenu(Menu_t *menu)
@@ -391,17 +476,14 @@ static int handleMainMenu(Menu_t *menu)
{
int itemCount = 0;
menu->items = &_menuItems[_menuItemsIndex];
createMenuItem(MENU_ID_SYSINFO , &menu->items[itemCount++]);
createMenuItem(MENU_ID_FREQUENCIES , &menu->items[itemCount++]);
createMenuItem(MENU_ID_AUTOSHUTDOWN , &menu->items[itemCount++]);
createMenuItem(MENU_ID_LANGUAGE , &menu->items[itemCount++]);
createMenuItem(MENU_ID_SYSINFO , &menu->items[itemCount++]);
createMenuItem(MENU_ID_FREQUENCIES , &menu->items[itemCount++]);
createMenuItem(MENU_ID_AUTOSHUTDOWN , &menu->items[itemCount++]);
createMenuItem(MENU_ID_LANGUAGE , &menu->items[itemCount++]);
_menuItemsIndex += itemCount;
menu->itemCount = itemCount;
menu->init = false;
menu->draw = true;
@@ -410,21 +492,21 @@ static int handleMainMenu(Menu_t *menu)
uint32_t pressed = KEY_GetPressed();
handleUpDown(pressed, menu);
handleMenuKeys(pressed, menu);
if (pressed == KEY_BACK)
{
menu->exitCode = MENU_EXIT;
}
else
if (pressed == KEY_ENTER)
{
if (menu->items[menu->selected].handler != NULL)
{
menu->items[menu->selected].handler(NULL);
//return MENU_OK;
}
}
// if (pressed == KEY_BACK)
// {
// menu->exitCode = MENU_EXIT;
// }
// else
// if (pressed == KEY_ENTER)
// {
// if (menu->items[menu->selected].handler != NULL)
// {
// menu->items[menu->selected].handler(NULL);
// //return MENU_OK;
// }
// }
if (menu->draw)
@@ -482,7 +564,7 @@ static void ClearMenuItems(MenuItem_t items[], uint32_t num)
for(uint32_t i = 0; i < num; i++)
{
items[i].pMonoIcon = NULL; //Init mono icon pointer to null
items[i].text[0] = NULL; //Init first char to null
items[i].text[0] = '\0'; //Init first char to null
}
}
@@ -822,17 +904,17 @@ static void DisplayDiagnostics(void)
yPos += yInc;
// yPos += yInc;
sprintf(tempString, "%d", adc.V_OffsetAdc);
sprintf(tempString, "%d", sys.adc.V_OffsetAdc);
FL_DrawString(tempString, xCol2, yPos, MENU_FONT, LCD_DRAW_SET, FL_ALIGN_LEFT); //voltage offset
if(!adc.vosOK)
if(!sys.adc.vosOK)
{
FL_DrawString("ERR", xCol1 + 30, yPos, MENU_FONT, LCD_DRAW_SET, FL_ALIGN_LEFT);
}
yPos += yInc;
sprintf(tempString, "%d", adc.I_OffsetAdc);
sprintf(tempString, "%d", sys.adc.I_OffsetAdc);
FL_DrawString(tempString, xCol2, yPos, MENU_FONT, LCD_DRAW_SET, FL_ALIGN_LEFT); //current offset
if(!adc.iosOK)
if(!sys.adc.iosOK)
{
FL_DrawString("ERR", xCol1 + 30, yPos, MENU_FONT, LCD_DRAW_SET, FL_ALIGN_LEFT);
}
@@ -1241,6 +1323,8 @@ void MENU_Init(void)
ClearMenuItems(mainMenu, MAIN_MENU_NUM_TX10);
ClearMenuItems(langMenu, LANG_MENU_NUM);
_menuItemsIndex = 0;
for (int i=0; i < MENU_STACK_SIZE; ++i)
{
_menuData.menuStack[i].selected = 0;
@@ -1484,11 +1568,16 @@ void Menu_init(void)
_menuData.menuStack[i].displayIndex = 0;
_menuData.menuStack[i].exitCode = MENU_OK;
}
for (int j=0; j<MENU_ITEM_SIZE; ++j)
{
_menuData.menuStack[i].items[j].id = MENU_ID_NONE;
_menuData.menuStack[i].items[j].handler = NULL;
}
//_menuData.menuStack[i].items[j].id = MENU_ID_NONE;
//_menuData.menuStack[i].items[j].handler = NULL;
_menuItems[j].id = MENU_ID_NONE;
_menuItems[j].handler = NULL;
}
}
@@ -1505,6 +1594,7 @@ void Menu_mainMenu(void)
void Menu_service(void)
{
int exitCode = MENU_OK;
Menu_t *menu;
// run the menu state machine and prevent blocking
if (_menuData.currentMenu != NULL)
@@ -1516,11 +1606,15 @@ void Menu_service(void)
case MENU_HOME:
{
_menuData.stackCount = 0;
_menuItemsIndex = 0;
break;
}
case MENU_EXIT:
{
menu = getCurrentMenu();
_menuItemsIndex -= (menu->items != NULL ? menu->itemCount : 0);
// pop the menu off the stack
_menuData.stackCount--;

6
source/menu.h
View File

@@ -61,7 +61,7 @@
#define MENU_SEL_RECT_RADIUS 5
#define MENU_STACK_SIZE 4
#define MENU_ITEM_SIZE 10
//#define MENU_ITEM_SIZE 10
typedef struct Menu_s Menu_t;
typedef int (*MenuHandler_t)(Menu_t *menu);
@@ -73,6 +73,7 @@ typedef enum
MENU_ID_FREQUENCIES,
MENU_ID_SYSINFO,
MENU_ID_LANGUAGE,
MENU_ID_FREQUENCY,
} MenuItemId_t;
@@ -82,6 +83,7 @@ typedef struct MENU_ITEM_s
char text[MENU_MAX_STRING_LENGTH];
MenuItemId_t id;
int (*handler)(Menu_t *menu);
void *data;
} MenuItem_t;
@@ -98,7 +100,7 @@ struct Menu_s
bool init;
bool draw;
int selected;
MenuItem_t items[MENU_ITEM_SIZE];
MenuItem_t *items;
int itemCount;
int displayIndex;
int exitCode;

8
source/mode.c
View File

@@ -27,13 +27,7 @@ void mode_menu(void)
uint32_t value = 22370; // testing only
uint32_t tmp;
static bool keithistan = false;
// Delay_Ticks(10);
keithistan ^= 1; //toggle
Select_Next_Mode(); //
Select_Next_Mode();
Port_changed_flag = true;

3
source/mode.h
View File

@@ -15,6 +15,8 @@
// BROADCAST = 1
//}CONNECT_MODE_t;
typedef enum {
BROADCAST,
PORT1_A,
@@ -25,7 +27,6 @@ typedef enum {
//Data for individual frequencies
typedef struct {
uint8_t Plugged; //frequency in Hz
uint8_t Selected;
}MODE_REC_t;

16
source/over_ride.c
View File

@@ -1,16 +0,0 @@
/*
* over_ride.c
*
* Created on: Jun 30, 2022
* Author: Keith.Lloyd
*/
void Over_Ride(void)
{
// display Over ride message
// wait for user response
}

14
source/over_ride.h
View File

@@ -1,14 +0,0 @@
/*
* over_ride.h
*
* Created on: Jun 30, 2022
* Author: Keith.Lloyd
*/
#ifndef OVER_RIDE_H_
#define OVER_RIDE_H_
void Over_Ride(void);
#endif /* OVER_RIDE_H_ */

200
source/ports.c
View File

@@ -29,13 +29,13 @@
#include "fsl_sctimer.h"
#include "pwm.h"
#include "pwr_level.h"
#include "System/system.h"
ACCESSORY_t accy1;
ACCESSORY_t accy2;
uint16_t Port_timer;
uint16_t Taps_adjust_timer;
extern uint8_t Port_changed_flag,Init_Done;
extern ADC_t adc;
extern uint8_t Port_State[],Cur_Mode,old_freq,Bcast_Pwr_Level,Bcast_LF_Value[],Bcast_HF_Value[],Power_Level;
extern MODE_REC_t mode_Array[MODE_MAX_NUM];
extern uint8_t frequency,Over_Voltage_Flag;
@@ -45,19 +45,123 @@ extern uint16_t Pot_Value_AB[];
extern uint16_t Pot_Value[];
extern uint8_t Dds_Pot_Val[];
extern SYSTEM_DATA_t sys;
uint8_t whatever;
static int handleBroadcast(ACCESSORY_t *accy)
{
switch (accy->state)
{
case PORT_STATE_INIT:
break;
case PORT_STATE_DEINIT:
break;
default:
return -1;
}
return 0;
}
static int handleClamp(ACCESSORY_t *accy)
{
switch (accy->state)
{
case PORT_STATE_INIT:
break;
case PORT_STATE_DEINIT:
break;
default:
return -1;
}
return 0;
}
static int handleDirect(ACCESSORY_t *accy)
{
switch (accy->state)
{
case PORT_STATE_INIT:
break;
case PORT_STATE_DEINIT:
break;
default:
return -1;
}
return 0;
}
static int initAccessory(ACCESSORY_t *accy)
{
accy->state = PORT_STATE_INIT;
accy->initState = true;
accy->handler(accy);
}
static int deinitAccessory(ACCESSORY_t *accy)
{
accy->state = PORT_STATE_DEINIT;
accy->initState = true;
accy->handler(accy);
}
void ACCY_Connect(ACCESSORY_t *accy, ACCY_ID_t id)
{
accy->connected = id;
accy->isConnected = true;
accy->state = PORT_STATE_INIT;
accy->channels[0] = 0;
accy->channels[1] = 0;
switch (id)
{
case ID_TX_SINGLE_DIRECT:
case ID_TX_DUAL_DIRECT:
{
accy->handler = handleDirect;
break;
}
case ID_CLAMP:
case ID_CLAMP2:
{
accy->handler = handleClamp;
break;
}
case ID_BROADCAST:
{
accy->handler = handleBroadcast;
break;
}
default:
{
accy->handler = NULL;
accy->connected = ID_NONE;
accy->isConnected = false;
}
}
}
static ACCY_ID_t ReadAccessory(uint8_t port)
{
float32_t idVoltage = 0.0;
if(port == 1)
idVoltage = adc.V_ID1; //idVoltage = ANA_GetVAccyDetect(); //TODO: Write this function
else
idVoltage = adc.V_ID2;
//ID 0 through 11. Voltage target is ID * 0.3v
if (port >= NUM_PORTS)
{
return ID_NONE;
}
uint32_t idNumber = (uint32_t)((idVoltage * 3.3333) + 0.25); //multiply by 3.3333 and round down to nearest integer
ACCESSORY_t *accy = &sys.ports[port];
uint32_t idNumber = (uint32_t)((*accy->idVoltage * 3.3333f) + 0.5f); //multiply by 3.3333 and round down to nearest integer
return (ACCY_ID_t)idNumber;
@@ -65,7 +169,7 @@ static ACCY_ID_t ReadAccessory(uint8_t port)
void Disconnect(uint8_t port) // called when you disconnect
{
if (port ==1)
if (port == ACCY_PORT_1)
{
accy1.connected = ID_NONE;
accy1.consecutiveScans = 0;
@@ -135,6 +239,17 @@ void Disconnect(uint8_t port) // called when you disconnect
}
void ACCY_Init(void)
{
for (int i=0; i<NUM_PORTS; ++i)
{
sys.ports[i].connected = ID_NONE;
sys.ports[i].consecutiveScans = 0;
sys.ports[i].isConnected = false;
}
sys.ports[ACCY_PORT_1].idVoltage = &sys.adc.V_ID1;
sys.ports[ACCY_PORT_2].idVoltage = &sys.adc.V_ID2;
accy1.connected = ID_NONE;
accy1.consecutiveScans = 0;
accy1.isConnected = false;
@@ -149,6 +264,40 @@ void ACCY_Init(void)
//Setup accessory for GPIO gain control
// InitAccessoryGainGPIO();
}
void ACCY_Update(void)
{
for (int i=0; i<NUM_PORTS; ++i)
{
ACCESSORY_t *accy = &sys.ports[i];
ACCY_ID_t detected = ReadAccessory(i);
if(accy->connected == ID_NONE) //Nothing connected. Look for accessory to connect
{
if((detected == accy->lastDetected) && (detected != ID_NONE)) //If detected same as last time and not ID_NONE
{
if(++accy->consecutiveScans == AC_NUM_SCANS_TO_CONNECT) //Connect on 3rd consecutive scan of same accessory
{
ACCY_Connect(accy, detected);
}
}
else //If different than last scan
{
accy->lastDetected = detected; //remember what was scanned last time
accy->consecutiveScans = 0;
}
}
else if (detected != accy->connected) //If connected and detected reads different, disconnect
{
Disconnect(i);
}
}
}
//Call @ 10Hz to detect, connect, and disconnect accessories
void ACCY_Update1(void)
{
@@ -180,7 +329,7 @@ void ACCY_Update1(void)
}
else if (detected != accy1.connected) //If connected and detected reads different, disconnect
{
Disconnect(1);
Disconnect(ACCY_PORT_1);
}
}
@@ -217,13 +366,30 @@ void ACCY_Update2(void)
}
else if (detected != accy2.connected) //If connected and detected reads different, disconnect
{
Disconnect(2);
Disconnect(ACCY_PORT_2);
}
}
/*
* Connect accessory
*/
bool ACCY_isKnown(ACCY_ID_t id)
{
bool known = false;
switch(id)
{
case ID_TX_SINGLE_DIRECT:
case ID_TX_DUAL_DIRECT:
case ID_CLAMP:
case ID_CLAMP2:
known = true;
break;
}
return known;
}
void ACCY_Connect1(ACCY_ID_t id)
{
accy1.connected = id;
@@ -324,7 +490,9 @@ uint8_t chip;
Port_timer = DELAY_100MS;
ACCY_Update1();
ACCY_Update();
//ACCY_Update1();
if((mode_Array[PORT1_A].Selected == false) && (mode_Array[PORT1_B].Selected == false) && (accy1.isConnected)) //new bit here
Cur_Mode = PORT1_A; // Something is connected to PORT1
@@ -354,7 +522,7 @@ uint8_t chip;
}
ACCY_Update2();
//ACCY_Update2();
if((mode_Array[PORT2_A].Selected == false) && (mode_Array[PORT2_B].Selected == false) && (accy2.isConnected)) //new bit here
Cur_Mode = PORT2_A;
@@ -396,14 +564,15 @@ void Select_Output_Port(void) // which DC Out port, to switch on
{
Delay_Ticks(DELAY_100MS);
if(Compare_Voltage(adc.V_CHK, MAX_BYPASS_VOLTS))
if(Compare_Voltage(sys.adc.V_CHK, MAX_BYPASS_VOLTS))
{
Over_Voltage_Flag = true;
sys.status[OVERVOLTAGE] = true;
Select_Bypass(OFF); // Force into blocked state.
Delay_Ticks(20);
}
// HACK
Select_Estop(OFF); // Ensure output is not ISOLATED from connections
switch (Cur_Mode)
@@ -615,6 +784,7 @@ void Disable_BC(void)
// Init_PWM_CLKS(DC_CLK); // Return timer clock to internal
}
bool Is_Clamp_Detected(void)
{
if((ACCY_GetConnectedAccessory(1) == ID_CLAMP) || (ACCY_GetConnectedAccessory(2) == ID_CLAMP) || (ACCY_GetConnectedAccessory(1) == ID_CLAMP2) || (ACCY_GetConnectedAccessory(2) == ID_CLAMP2))

41
source/ports.h
View File

@@ -8,7 +8,11 @@
#ifndef PORTS_H_
#define PORTS_H_
typedef struct ACCESSORY_s ACCESSORY_t;
typedef int (*AccessoryHandler_t)(ACCESSORY_t *accy);
typedef enum {
ID_BROADCAST = -1,
ID_ERROR = 0, //0V should never happen. Error condition
ID_TX_SINGLE_DIRECT, //Transmitter accessory
ID_TX_DUAL_DIRECT, //Transmitter accessory
@@ -24,14 +28,46 @@ typedef enum {
ID_NUM
}ACCY_ID_t;
typedef enum
{
PORT_STATE_DEINIT = -1,
PORT_STATE_INIT = 0,
} PortState_t;
typedef struct {
typedef enum
{
ACCY_PORT_INDUCTION = -1,
ACCY_PORT_1 = 0,
ACCY_PORT_2 = 1,
NUM_PORTS
} AccessoryPortId_t;
typedef enum
{
CHANNEL_A = 0,
CHANNEL_B,
NUM_CHANNELS
} AccyChannelId_t;
typedef struct
{
AccyChannelId_t id;
bool connected;
} AccessoryChannel_t;
struct ACCESSORY_s {
bool isConnected; //Accessory is connected
ACCY_ID_t connected; //Currently connected accessory
ACCY_ID_t lastDetected; //accessory detected last scan
uint32_t consecutiveScans; //number of consecutive scans of same accessory
float *idVoltage;
PortState_t state;
bool initState;
AccessoryHandler_t handler;
}ACCESSORY_t;
AccessoryChannel_t channels[NUM_CHANNELS];
};
#define DELAY_100MS 10
#define DELAY_ONE_SECOND 100
@@ -57,6 +93,7 @@ typedef enum {
void ACCY_Init(void);
bool ACCY_isKnown(ACCY_ID_t id);
void ACCY_Update1(void);
void ACCY_Update2(void);
void Read_Tx_Ports(void); // check for whats plugged in at the ports.

5
source/psu_ctrl.c
View File

@@ -14,6 +14,7 @@
#include "adc.h"
#include "timer.h"
#include "utils.h"
#include "System/system.h"
#include <stdbool.h>
#include <stdint.h>
@@ -28,7 +29,7 @@ uint8_t mode,psu_index;
extern uint8_t Power_Level;
uint8_t Psu_Pot_Data[5] = {V_18V,V_24V,V_27V,V_36V,V_55V}; // PSU Pot values.
extern ADC_t adc;
extern SYSTEM_DATA_t sys;
void Set_PSU_Voltage(uint8_t value)
@@ -117,7 +118,7 @@ uint16_t escape_count;
escape_count = 350;
while(adc.V_PSU > volt_limit && escape_count > 0 )
while(sys.adc.V_PSU > volt_limit && escape_count > 0 )
{
Delay_Ticks(1);
escape_count--;

29
source/pwr_level.c
View File

@@ -17,7 +17,6 @@
#include "pwm.h"
#include "amps.h"
#include "frq.h"
#include "measure.h"
#include "adc.h"
#include "init.h"
#include "utils.h"
@@ -25,10 +24,13 @@
#include "timer.h"
#include "sys_chk.h"
#include "battery.h"
#include "System/system.h"
extern float32_t Watts;
extern uint8_t frequency,Test_Mode,catch_up_flag;
extern ADC_t adc;
extern float32_t Milli_amps;
extern SYSTEM_DATA_t sys;
uint16_t Old_Pot_Val;
uint8_t Power_Level,Bcast_Pwr_Level;
float Requested_Current_Lith[5] = {10.0/1000,50.0/1000.0,150.0/1000.0,400.0/1000.0,1000.0/1000.0}; // Requested Current Output Value
@@ -111,8 +113,8 @@ void doClampPower(void)
float power = 0.0f;
bool update = true;
clampData.voltage = adc.V_OUT_FastFilt;
clampData.current = adc.I_OUT_FastFilt;
clampData.voltage = sys.adc.V_OUT_FastFilt;
clampData.current = sys.adc.I_OUT_FastFilt;
power = clampData.voltage * clampData.current;
if (power > clampData.maxPower)
@@ -365,6 +367,17 @@ uint8_t BC_Duty_val;
return(BC_Duty_val);
}
float Calc_Max_current(void)
{
float a;
if(freqArray[frequency].frequency1 <= MAX_DTYPE)
a = sqrtf(sys.maxPowerLimit / sys.adc.Ohms_slowfilt);
else
a = sqrtf(1/sys.adc.Ohms_slowfilt);
return(a);
}
void Request_Current_Change(void)
{
@@ -382,7 +395,7 @@ void Request_Current_Change(void)
Current_Request = Max_Current_Allowed; //make it comply}
Old_Pot_Val = Dds_Pot_Val[1];
new_pot_val = (Current_Request /adc.I_OUT_SlowFilt) * Dds_Pot_Val[1]; // Request divided by Pot current contents
new_pot_val = (Current_Request /sys.adc.I_OUT_SlowFilt) * Dds_Pot_Val[1]; // Request divided by Pot current contents
if(new_pot_val < 3)
new_pot_val = 3;
@@ -561,12 +574,12 @@ void Check_New_Pot_Volts()
{
float32_t V_Calc; // Currently set value is Old_Pot requested value is Pot_Val[]
if(adc.V_OUT_SlowFilt > 0.0)
if(sys.adc.V_OUT_SlowFilt > 0.0)
{
V_Calc = (adc.V_OUT_FastFilt / Old_Pot_Val);
V_Calc = (sys.adc.V_OUT_FastFilt / Old_Pot_Val);
if(V_Calc * Dds_Pot_Val[1] > 90.0)
Dds_Pot_Val[1] = MAX_DC_VOLTAGE / adc.V_OUT_FastFilt * Old_Pot_Val;
Dds_Pot_Val[1] = MAX_DC_VOLTAGE / sys.adc.V_OUT_FastFilt * Old_Pot_Val;
if(Dds_Pot_Val[1] > freqArray[frequency].max_pot)
Dds_Pot_Val[1] = freqArray[frequency].max_pot;

12
source/radio.c
View File

@@ -1,12 +0,0 @@
/*
* radio.c
*
* Created on: Feb 27, 2023
* Author: Keith.Lloyd
*/
void Send_Wireless_Data(void) // Send system update to Receiver.
{
}

14
source/radio.h
View File

@@ -1,14 +0,0 @@
/*
* radio.h
*
* Created on: Feb 27, 2023
* Author: Keith.Lloyd
*/
#ifndef RADIO_H_
#define RADIO_H_
void Send_Wireless_Data(void); // Send system update to Receiver.
#endif /* RADIO_H_ */

27
source/spi.c
View File

@@ -15,6 +15,7 @@
#include <stdbool.h>
#include <stdint.h>
#include "spi.h"
#include "io.h"
/*******************************************************************************
* Definitions
@@ -274,29 +275,37 @@ void SPI0_Chip_Select(uint8_t state, SPI_MODE_t destination)
switch(destination)
{
case SIGNAL:
GPIO_PinWrite(GPIO, SIGNAL_PORT, SIG_CS_GPIO_PIN, state);
GPIO_WRITE(PIN_SIG_CS, state);
break;
case SDSIGNAL:
GPIO_PinWrite(GPIO, SIGNAL_PORT, SD_CS_GPIO_PIN, state);
GPIO_WRITE(PIN_SD_CS, state);
break;
case BOTH_SIGNAL:
GPIO_PinWrite(GPIO, SIGNAL_PORT, SIG_CS_GPIO_PIN, state);
GPIO_PinWrite(GPIO, SIGNAL_PORT, SD_CS_GPIO_PIN, state);
GPIO_WRITE(PIN_SIG_CS, state);
GPIO_WRITE(PIN_SD_CS, state);
break;
case RAMP:
GPIO_PinWrite(GPIO, SIGNAL_PORT, RAMP_CS_GPIO_PIN, state);
GPIO_WRITE(PIN_RAMP_CS, state);
break;
case AMPLITUDE:
GPIO_PinWrite(GPIO, PORT0, POT_CS_GPIO_PIN, state);
GPIO_WRITE(PIN_POT_CS, state);
break;
case EXPANDER:
GPIO_PinWrite(GPIO, PORT0, PORT_LE_CS_GPIO_PIN, state);
GPIO_WRITE(PIN_PORT_LE_CS, state);
break;
case E2PROM:
GPIO_PinWrite(GPIO, PORT0, EEP_CS_GPIO_PIN, state);
GPIO_WRITE(PIN_EEP_CS, state);
break;
case PSU_VCTRL:
GPIO_PinWrite(GPIO, PORT0, POT_CS2_GPIO_PIN, state);
GPIO_WRITE(PIN_POT_CS2, state);
break;
}

54
source/sys_chk.c
View File

@@ -1,4 +1,3 @@
#include "arm_math.h"
#include "fsl_gpio.h"
#include "spi.h"
@@ -12,7 +11,6 @@
#include "mode.h"
#include "ports.h"
#include "utils.h"
#include "adc.h"
#include "safety_key.h"
#include "sys_chk.h"
#include "pwr_level.h"
@@ -22,22 +20,22 @@
#include "taps.h"
#include "amps.h"
#include "stdbool.h"
#include "System/system.h"
extern uint8_t Task,Cur_Mode,Power_Level,catch_up_flag;
extern uint8_t Over_Voltage_Flag,Bat_Type,Suspend_Step_Chk;
extern uint16_t Pot_Value_CLAMP_AB[];
extern uint16_t Pot_Value_AB[],Over_Voltage_tmr,ByPass_tmr;
extern uint8_t Dds_Pot_Val[]; // 2 byte Data for SPI
extern ADC_t adc;
extern uint16_t Vchktmr, Pot_Value[];
//extern float Requested_Current[];
extern uint8_t Port_State[];
uint8_t Ports_Cleared_Flag,step_count;
extern uint8_t frequency,Over_Current_Flag, Taps_Flag;
extern FREQUENCY_t freqArray[FREQ_MAX_NUM];
extern ADC_t adc;
extern float32_t Max_Power_Limit;
extern float32_t Watts_Filt;
extern SYSTEM_DATA_t sys;
uint16_t Power_tmr, Display_warning_tmr;
void System_Check()
@@ -112,7 +110,7 @@ void Safety_Check(void)
void Normal_Bypass_Chk(void)
{
if(!Over_Voltage_Flag)
if(!sys.status[OVERVOLTAGE])
Select_Bypass(ON);
}
@@ -125,10 +123,10 @@ void Check_For_Open_Circuit(void)
Select_Bypass(OFF);
ByPass_tmr = DELAY_5S;
}
else if (adc.V_CHK < MAX_BYPASS_VOLTS2) // else if NOT HVP
else if (sys.adc.V_CHK < MAX_BYPASS_VOLTS2) // else if NOT HVP
{ // Switch Blocking cap off
Delay_Ticks(10); // Check again after delay
if (adc.V_CHK < MAX_BYPASS_VOLTS2 && ByPass_tmr == 0)
if (sys.adc.V_CHK < MAX_BYPASS_VOLTS2 && ByPass_tmr == 0)
{
Select_Bypass(ON);
step_count = 0;
@@ -137,12 +135,12 @@ void Check_For_Open_Circuit(void)
}
if (adc.V_CHK > MAX_BYPASS_VOLTS2)
Over_Voltage_Flag = true;
if (sys.adc.V_CHK > MAX_BYPASS_VOLTS2)
sys.status[OVERVOLTAGE] = true;
else
Over_Voltage_Flag = false; // added 1/6/25
sys.status[OVERVOLTAGE] = false; // added 1/6/25
if (Compare_Voltage(adc.V_CHK, MAX_OP_VOLTS)) //Potentially fatal voltage
if (Compare_Voltage(sys.adc.V_CHK, MAX_OP_VOLTS)) //Potentially fatal voltage
{
Select_Estop(ON); // Fault condition disable output
Select_Bypass(OFF); // Force into blocked state.
@@ -154,7 +152,7 @@ void Check_For_Open_Circuit(void)
bool Open_Circuit_Chk(void)
{
if(adc.I_OUT_FastFilt <= OPEN_CIRCUIT_CURRENT)
if(sys.adc.I_OUT_FastFilt <= OPEN_CIRCUIT_CURRENT)
return(true);
else
return(false);
@@ -169,7 +167,7 @@ void Check_For_Connected_Volts(void)
Vchktmr = 0;
// Check_Live_Voltage(); // Check Live voltage external source
Safety_Check();
if(Over_Voltage_Flag)
if(sys.status[OVERVOLTAGE])
Select_Bypass(OFF);
else
{
@@ -194,7 +192,7 @@ void Check_For_Connected_Volts(void)
#if 0
for(uint32_t i = 0; i < 10; i++)
{
Current1[i] = adc.I_OUT_FastFilt;
Current1[i] = sys.adc.I_OUT_FastFilt;
Delay_Ticks(10); //100mS to stabilize measurement after cap bypassed
}
@@ -218,10 +216,10 @@ void Check_Trickle_Current(void)
float32_t x;
uint8_t y,z;
if(Power_Level == 0 && adc.I_OUT_SlowFilt > 0.050)
if(Power_Level == 0 && sys.adc.I_OUT_SlowFilt > 0.050)
{
z = Dds_Pot_Val[1];
x = 0.050 /adc.I_OUT_SlowFilt;
x = 0.050 /sys.adc.I_OUT_SlowFilt;
y = (Dds_Pot_Val[1]*x);
if (y < 3)
@@ -243,7 +241,7 @@ void Check_Selected_Current(void)
{
if(!Check_For_Clamp())
{
if((!Suspend_Step_Chk) && (!Over_Voltage_Flag))
if((!Suspend_Step_Chk) && (!sys.status[OVERVOLTAGE]))
{
if(Demand_Check() && Power_Level > 0) //
{
@@ -270,7 +268,7 @@ uint8_t xval;
// num = Requested_Current[Power_Level] * 1.2; 3/8/24
num = Requested_Current(Bat_Type);
current = adc.I_OUT_SlowFilt; //
current = sys.adc.I_OUT_SlowFilt; //
// if(current > (Requested_Current[Power_Level] * 1.2) && Power_Level > 0) 3/8/24
if(current > (num * 1.1) && Power_Level > 0)
return(true);
@@ -287,9 +285,9 @@ uint8_t xval;
void Chk_Selected_Current2(void)
{
if(!Check_For_Clamp() && (!Suspend_Step_Chk) && (!Over_Voltage_Flag))
if(!Check_For_Clamp() && (!Suspend_Step_Chk) && (!sys.status[OVERVOLTAGE]))
{
if(adc.I_OUT_SlowFilt > (Requested_Current(Bat_Type) * 1.05) || (Watts_Filt > Get_Power_Limit()))
if(sys.adc.I_OUT_SlowFilt > (Requested_Current(Bat_Type) * 1.05) || (Watts_Filt > Get_Power_Limit()))
{
Request_Current_Change(); // reduce current
catch_up_flag = false;
@@ -298,7 +296,7 @@ void Chk_Selected_Current2(void)
}
else
{
if (adc.I_OUT_SlowFilt < (Requested_Current(Bat_Type) * 0.95))
if (sys.adc.I_OUT_SlowFilt < (Requested_Current(Bat_Type) * 0.95))
{
if(!Check_Maxed_Out())
{
@@ -342,7 +340,7 @@ float32_t x;
if((Port_State[MID_SR] & I_GAIN) > 0)
{ // High Gain
if(adc.I_OUT_FastFilt > 0.05 && adc.V_OUT_FastFilt < 1 && Power_Level > 1)
if(sys.adc.I_OUT_FastFilt > 0.05 && sys.adc.V_OUT_FastFilt < 1 && Power_Level > 1)
return(true);
else
return(false);
@@ -351,7 +349,7 @@ float32_t x;
{ // Low GAIN
x = Get_Max_Current();
if(adc.I_OUT_FastFilt * 1000 > x)
if(sys.adc.I_OUT_FastFilt * 1000 > x)
return(true);
else
return(false);
@@ -365,20 +363,20 @@ bool Check_Maxed_Out(void)
float32_t x,Power_Limit,Current_Request;
if (freqArray[frequency].frequency1 < MAX_DTYPE)
Power_Limit = Max_Power_Limit;
Power_Limit = sys.maxPowerLimit;
else
Power_Limit = 1.0;
x = Get_Max_Current(); // HF 250mA LF 950mA
Current_Request = Requested_Current(Bat_Type);
if(adc.I_OUT_FastFilt * 1000 > x)
if(sys.adc.I_OUT_FastFilt * 1000 > x)
return(true);
else if (adc.V_OUT > (MAX_DC_VOLTAGE * 0.95))
else if (sys.adc.V_OUT > (MAX_DC_VOLTAGE * 0.95))
return(true);
else if (Watts_Filt > (Power_Limit * 0.95))
return(true);
else if ((Current_Request * adc.V_OUT_SlowFilt) > Power_Limit)
else if ((Current_Request * sys.adc.V_OUT_SlowFilt) > Power_Limit)
return (true);
else
return(false);

47
source/taps.c
View File

@@ -16,8 +16,10 @@
#include "amps.h"
#include "adc.h"
#include "utils.h"
#include "io.h"
#include "System/system.h"
extern ADC_t adc;
extern SYSTEM_DATA_t sys;
extern uint8_t Port_State[];
extern uint8_t Cur_Mode,Test_Mode;
extern uint32_t new_freq;
@@ -42,7 +44,35 @@ void Check_Taps(void)
}
}
void taps_setTapLF(uint8_t tap)
{
//EXPANDER_CLEAR(~TAPS_OFF_MASK, NO_UPDATE);
switch (tap)
{
case 2:
{
EXPANDER_SET(_TAP2_LF_ON, UPDATE);
break;
}
case 3:
{
EXPANDER_SET(_TAP3_LF_ON, UPDATE);
break;
}
case 4:
{
EXPANDER_SET(_TAP4_LF_ON, UPDATE);
break;
}
default:
{
EXPANDER_SET(_TAP1_LF_ON, UPDATE);
break;
}
}
}
void Set_taps_LF(void) // D' Type Amplifier
{
@@ -55,7 +85,7 @@ void Set_taps_LF(void) // D' Type Amplifier
if(!Taps_Flag)
{
Port_State[BOTTOM_SR] &= TAPS_OFF_MASK;
New_Ohms = (adc.Ohms_slowfilt);
New_Ohms = (sys.adc.Ohms_slowfilt);
switch (New_Ohms)
{
@@ -105,7 +135,7 @@ void Set_taps_LF(void) // D' Type Amplifier
SPI0_SendBytes(Port_State, 3, EXPANDER);
last_Ohms = adc.Ohms_slowfilt;
last_Ohms = sys.adc.Ohms_slowfilt;
Taps_Flag = true;
}
@@ -117,9 +147,6 @@ void Set_taps_LF(void) // D' Type Amplifier
SPI0_SendBytes(Port_State, 3, EXPANDER);
}
// Port_State[BOTTOM_SR] &= TAPS_OFF_MASK;
// Port_State[BOTTOM_SR] |= TAP2_LF_ON; // force TAP 2 for new transformer test (remove later)
// SPI0_SendBytes(Port_State, 3, EXPANDER);
}
@@ -128,9 +155,9 @@ void Set_taps_HF(void) // AB Amplifier
{
if(Hys_Taps)
{
last_Ohms = adc.Ohms_slowfilt;
last_Ohms = sys.adc.Ohms_slowfilt;
if(adc.Ohms_slowfilt < 200)
if(sys.adc.Ohms_slowfilt < 200)
Port_State[MID_SR] &= TAP102_HF_OFF; // 1:1
else
@@ -146,12 +173,12 @@ float32_t test;
test = last_Ohms + last_Ohms/10;
if(adc.Ohms_slowfilt > test )
if(sys.adc.Ohms_slowfilt > test )
return(true);
test = last_Ohms - last_Ohms/10;
if(adc.Ohms_slowfilt < test)
if(sys.adc.Ohms_slowfilt < test)
return(true);
else
return(false);

5
source/timer.c
View File

@@ -21,6 +21,7 @@
#include "adc.h"
#include "utils.h"
#include "usbComms.h"
#include "System/system.h"
/*******************************************************************************
* Definitions
@@ -62,7 +63,7 @@ uint16_t Low_Bat_timer,Estop_timer,Shut_down_tmr,Vchktmr, Over_Voltage_tmr,PSU_C
uint16_t Key_Lock_Out_tmr,ByPass_tmr;
uint32_t TX_TIME[4] = {TIME_1HR,TIME_2HR,TIME_0HR,TIME_0HR};
extern ADC_t adc;
extern SYSTEM_DATA_t sys;
uint32_t systemTime = 0; // 10mS ticks
/*******************************************************************************
@@ -131,7 +132,7 @@ void ctimer_match0_callback(uint32_t flags) // ISR every 10mS
Display_warning_tmr--;
if(adc.measure)
if(sys.adc.measure)
{
ADC_Update();
}

77
source/utils.c
View File

@@ -41,11 +41,10 @@ extern uint8_t Over_Current_Flag;
extern uint8_t Hardware_Error_Flag;
extern uint8_t frequency, Task, Cur_Mode;
extern spi_master_config_t SPI0_config;
extern ADC_t adc;
extern AMP_XFRMR_SLCT_t Amp2xfrmr;
extern uint8_t frequency,old_freq,frq_chg_tmr;
extern float32_t Watts, Max_Power_Limit, Milli_amps,test_val2;
extern float32_t Watts, Milli_amps,test_val2;
extern uint8_t Dds_Pot_Val[], Power_Level;
extern uint16_t Pot_Value_CLAMP1[];
extern uint16_t Pot_Value_CLAMP_AB[]; // DDS Output amplitude. (AB amp)
@@ -69,9 +68,9 @@ uint8_t Check_Output_Status(char Connector)
uint32_t x = 1;
if (Connector == 1)
x = adc.V_ID1; // Todo Don't forget limits.
x = sys.adc.V_ID1; // Todo Don't forget limits.
else
x = adc.V_ID2;
x = sys.adc.V_ID2;
if (x > TGT_NOT_USED)
return (EMPTY);
@@ -114,30 +113,42 @@ GPIO_PinWrite(GPIO, 0, PORT_LE, 1); // De-select CS
#endif
}
void Select_Bypass(RELAY_SELECT_t Bypass) // Bypass allows transmitting w/o full protection
void Select_Bypass(RELAY_SELECT_t bypass) // Bypass allows transmitting w/o full protection
{
if (Bypass)
sys.status[BYPASS] = bypass;
if (bypass)
{
if ((freqArray[frequency].frequency1 < MIN_BLOCK_FREQ) && (!Over_Voltage_Flag))
Port_State[MID_SR] |= BYPASS_ON; // Set relay to By Pass protection cap
if ((freqArray[frequency].frequency1 < MIN_BLOCK_FREQ) && (!sys.status[OVERVOLTAGE]))
{
EXPANDER_SET(BYPASS_ON, true);
}
}
else
Port_State[MID_SR] &= ~BYPASS_ON; // ReSet relay to include Cap in circuit
{
EXPANDER_CLEAR(BYPASS_ON, true);
}
SPI0_SendBytes(Port_State, 3, EXPANDER); // Send_Update_Port();
}
void Select_Estop(RELAY_SELECT_t E_stop)
void Select_Estop(ESTOP_SELECT_t stop)
{
if (E_stop)
sys.status[ESTOP] = (bool)stop;
// HACK
stop = ON;
if (stop)
{
GPIO_WRITE(PIN_ESTOP, LOW);
//GPIO_PinWrite(GPIO, 1, ESTOP, 0); // Isolated
GPIO_WRITE(PIN_ESTOP, LOW); // Isolated
}
else
//GPIO_PinWrite(GPIO, 1, ESTOP, 1); // Not Isolated
GPIO_WRITE(PIN_ESTOP, HIGH);
{
GPIO_WRITE(PIN_ESTOP, HIGH); // Not Isolated
}
}
void Select_Transformer()
@@ -216,7 +227,7 @@ void Check_Clamp_OverVoltage(void)
{
if (ACCY_GetActive() != ID_CLAMP2)
{
if (Compare_Voltage(adc.V_OUT, MAX_CLAMP_VOLTAGE))
if (Compare_Voltage(sys.adc.V_OUT, MAX_CLAMP_VOLTAGE))
Adjust_Clamp_Volts();
}
}
@@ -235,18 +246,20 @@ void Check_Live_Voltage()
{
if (Vchktmr == 0)
{
if (Compare_Voltage(adc.V_CHK, MAX_OP_VOLTS)) //Potentially fatal voltage
if (Compare_Voltage(sys.adc.V_CHK, MAX_OP_VOLTS)) //Potentially fatal voltage
{
Select_Estop(ON); // Fault condition disable output
Select_Bypass(OFF); // Force into blocked state.
// Over_Voltage_Flag = true;
// Estop_timer = DELAY_5S;
Task = SAFETY_TASK;
}
if (Compare_Voltage(adc.V_CHK, MAX_BYPASS_VOLTS)) // damaging voltage but allow operation
if (Compare_Voltage(sys.adc.V_CHK, MAX_BYPASS_VOLTS)) // damaging voltage but allow operation
{ // to continue.
Over_Voltage_Flag = true;
sys.status[OVERVOLTAGE] = true;
Select_Bypass(OFF); // Force into blocked state.
}
}
@@ -267,7 +280,7 @@ void Check_Over_Current()
float x;
x = Get_Max_Current();
if (adc.I_OUT_FastFilt * 1000 > x)
if (sys.adc.I_OUT_FastFilt * 1000 > x)
{
Power_Level = 0;
Cut_Signal_To_Min();
@@ -297,7 +310,7 @@ void Check_Over_Power(void)
if (ACCY_GetActive() != ID_CLAMP2)
{
if (freqArray[frequency].frequency1 < MAX_DTYPE)
Adjust_Output_Power(Max_Power_Limit);
Adjust_Output_Power(sys.maxPowerLimit);
else
Adjust_Output_Power(1.0);
}
@@ -308,7 +321,7 @@ void Check_Over_Power(void)
float32_t Get_Power_Limit(void)
{
if (freqArray[frequency].frequency1 < MAX_DTYPE)
return(Max_Power_Limit);
return(sys.maxPowerLimit);
else
return(1.0);
@@ -340,7 +353,7 @@ void Check_PSU_Short(void) // if output less than 10% of expected PSU voltage
{ // then a fault condition is present.
if (PSU_Check_tmr == 0)
{
if ((adc.V_PSU * 1.2) < Convert_Pot2_Volts(Psu_Pot_Val[1]))
if ((sys.adc.V_PSU * 1.2) < Convert_Pot2_Volts(Psu_Pot_Val[1]))
{
Select_Estop(ON); // Disconnect from external threats
@@ -424,7 +437,7 @@ void Chk_Gain(void)
if ((Port_State[MID_SR] & I_GAIN) > 0) // High gain
{
if (adc.I_OUT_SlowFilt > 0.035)
if (sys.adc.I_OUT_SlowFilt > 0.035)
{
Port_State[MID_SR] &= ~I_GAIN; // U12 switch to low gain
SPI0_SendBytes(Port_State, 3, EXPANDER);
@@ -432,7 +445,7 @@ void Chk_Gain(void)
}
else
{
if (adc.I_OUT_SlowFilt < 0.025)
if (sys.adc.I_OUT_SlowFilt < 0.025)
{
Port_State[MID_SR] |= I_GAIN; // switch to High gain
SPI0_SendBytes(Port_State, 3, EXPANDER);
@@ -483,10 +496,10 @@ void Check_Over_Voltage(void) // Check Direct Connect Over voltage
// test1 = Check_For_Clamp();
if (Cur_Mode != BROADCAST && !Check_For_Clamp())
{
if (Compare_Voltage(adc.V_OUT_FastFilt, MAX_DC_VOLTAGE))
if (Compare_Voltage(sys.adc.V_OUT_FastFilt, MAX_DC_VOLTAGE))
{
Vchktmr = LOCK_OUT_DELAY;
New_Pot_Val = MAX_DC_VOLTAGE / adc.V_OUT_FastFilt
New_Pot_Val = MAX_DC_VOLTAGE / sys.adc.V_OUT_FastFilt
* Dds_Pot_Val[1];
if (New_Pot_Val > freqArray[frequency].max_pot)
Dds_Pot_Val[1] = freqArray[frequency].max_pot;
@@ -557,8 +570,8 @@ void Update_Amp_Pot(void)
void Check_For_Clamp_On_Pwr_Up(void)
{
uint32_t idNumber1 = (uint32_t) ((adc.V_ID2 * 3.3333) + 0.5);//multiply by 3.3333 and round to nearest integer
uint32_t idNumber2 = (uint32_t) ((adc.V_ID1 * 3.3333) + 0.5);//multiply by 3.3333 and round to nearest integer
uint32_t idNumber1 = (uint32_t) ((sys.adc.V_ID2 * 3.3333) + 0.5);//multiply by 3.3333 and round to nearest integer
uint32_t idNumber2 = (uint32_t) ((sys.adc.V_ID1 * 3.3333) + 0.5);//multiply by 3.3333 and round to nearest integer
uint8_t count;
@@ -583,8 +596,8 @@ void Check_For_Clamp_On_Pwr_Up(void)
}
bool Check_For_Clamp_New()
{
uint32_t idNumber1 = (uint32_t) ((adc.V_ID2 * 3.3333) + 0.25);//multiply by 3.3333 and round to nearest integer
uint32_t idNumber2 = (uint32_t) ((adc.V_ID1 * 3.3333) + 0.25);//multiply by 3.3333 and round to nearest integer
uint32_t idNumber1 = (uint32_t) ((sys.adc.V_ID2 * 3.3333) + 0.25);//multiply by 3.3333 and round to nearest integer
uint32_t idNumber2 = (uint32_t) ((sys.adc.V_ID1 * 3.3333) + 0.25);//multiply by 3.3333 and round to nearest integer
uint8_t count;

26
source/utils.h
View File

@@ -34,8 +34,7 @@
#define HF_AMP_ON 0b01000000
#define PORT_LE 5
#define ESTOP 17
#define BYPASS_ON 0b00000001 //
//#define BYPASS_ON 0b00000001 //
#define HFDC_ON 0b00000010
#define LFDC_ON 0b00000000
#define LFANT_ON 0b00000100
@@ -84,30 +83,19 @@ typedef enum{
} AMP_XFRMR_SLCT_t;
typedef enum {
CONNECTED,
ISOLATED
} ESTOP_SELECT_t;
typedef enum {
OFF,
ON
} RELAY_SELECT_t;
typedef struct ClampData_s
{
float slope;
uint8_t pot;
float voltage;
float current;
float impedance;
float power;
float maxPower;
float targetPower;
uint32_t timeout;
bool regulate;
uint8_t prevPowerLevel;
} ClampData_t;
void Select_Estop(RELAY_SELECT_t);
void Select_Estop(ESTOP_SELECT_t);
void Send_Pot_Data(uint16_t Data, SPI_MODE_t destination);
void Send_Update_Port(void);
void Clear_Relays(void);