Crash_Override/ESP32_ChinaDieselHeater_Control
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Fully migrated to JSON comms over Bluetooth. New .aia file for App Inventor included.

Browse source 
All JSON commands now accepted by ESP.
Output JSON from ESP is moderated.
This commit is contained in:
rljonesau 2018-12-15 20:34:58 +11:00
parent a168cea5d2
commit 97b2c849e2
18 changed files with 309 additions and 166 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

BIN
AppInventor/BluetoothHeaterJSON.aia Normal file
View file

Binary file not shown.

3
Arduino/BTCDieselHeater/BTCDateTime.h
View file

@ -3,8 +3,9 @@
#include "RTClib.h"
const char daysOfTheWeek[7][4] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
class BTCDateTime : public DateTime {
const char daysOfTheWeek[7][4] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
const char months[12][4] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
const char monthDays[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
public:

113
Arduino/BTCDieselHeater/BTCDieselHeater.ino
View file

@ -133,6 +133,7 @@ void initBlueWireSerial();
bool validateFrame(const CProtocol& frame, const char* name);
void checkDisplayUpdate();
void checkDebugCommands();
void updateJsonBT();
// DS18B20 temperature sensor support
OneWire ds(DS18B20_Pin); // on pin 5 (a 4.7K resistor is necessary)
@ -153,7 +154,7 @@ CSmartError SmartError;
CKeyPad KeyPad;
CScreenManager ScreenManager;
TelnetSpy DebugPort;
CModerator BTModerator;
sRxLine PCline;
long lastRxTime; // used to observe inter character delays
@ -164,6 +165,7 @@ CProtocolPackage HeaterData;
unsigned long moderator;
bool bUpdateDisplay = false;
bool bHaveWebClient = false;
bool bBTconnected = false;
////////////////////////////////////////////////////////////////////////////////////////////////////////
// Bluetooth instantiation
@ -290,6 +292,7 @@ void setup() {
DefaultBTCParams.setFan_Min(1680);
DefaultBTCParams.setFan_Max(4500);
bBTconnected = false;
Bluetooth.begin();
}
@ -326,6 +329,16 @@ void loop()
Bluetooth.check(); // check for Bluetooth activity
if(Bluetooth.isConnected()) {
if(!bBTconnected) {
bBTconnected = true;
BTModerator.reset();
}
}
else {
bBTconnected = false;
}
//////////////////////////////////////////////////////////////////////////////////////
// Blue wire data reception
@ -541,7 +554,7 @@ void loop()
if(!hasOEMController) {
// only convey this frames to Bluetooth when NOT using an OEM controller!
// Bluetooth.sendFrame("[BTC]", TxManage.getFrame(), TERMINATE_BTC_LINE); // BTC => Bluetooth Controller :-)
Bluetooth.send( createJSON("RunState", int(0) ) );
// Bluetooth.send( createJSON("RunState", 1.50 ) );
}
CommState.set(CommStates::HeaterRx2); // then await heater repsonse
}
@ -619,6 +632,7 @@ void loop()
ScreenManager.reqUpdate();
}
CommState.set(CommStates::Idle);
updateJsonBT();
break;
} // switch(CommState)
@ -638,82 +652,6 @@ void DebugReportFrame(const char* hdr, const CProtocol& Frame, const char* ftr)
}
void interpretCommand(const char* pLine)
{
unsigned char cVal;
unsigned short sVal;
float fVal;
if(strlen(pLine) == 0)
return;
#ifdef DEBUG_BTRX
DebugPort.println(pLine);
#endif
if(strncmp(pLine, "[CMD]", 5) == 0) {
// incoming command from BT app!
DebugPort.write(" Command decode: ");
pLine += 5; // skip past "[CMD]" header
if(strncmp(pLine, "ON", 2) == 0) {
TxManage.queueOnRequest();
DebugPort.println("Heater ON");
SmartError.reset();
Bluetooth.setRefTime();
}
else if(strncmp(pLine, "OFF", 3) == 0) {
TxManage.queueOffRequest();
DebugPort.println("Heater OFF");
SmartError.inhibit();
Bluetooth.setRefTime();
}
else if(strncmp(pLine, "Pmin", 4) == 0) {
pLine += 4;
fVal = atof(pLine);
NVstore.setPmin(fVal);
DebugPort.print("Pump min = "); DebugPort.println(fVal);
}
else if(strncmp(pLine, "Pmax", 4) == 0) {
pLine += 4;
fVal = atof(pLine);
NVstore.setPmax(fVal);
DebugPort.print("Pump max = "); DebugPort.println(fVal);
}
else if(strncmp(pLine, "Fmin", 4) == 0) {
pLine += 4;
sVal = atoi(pLine);
NVstore.setFmin(sVal);
DebugPort.print("Fan min = "); DebugPort.println(sVal);
}
else if(strncmp(pLine, "Fmax", 4) == 0) {
pLine += 4;
sVal = atoi(pLine);
NVstore.setFmax(sVal);
DebugPort.print("Fan max = "); DebugPort.println(int(sVal));
}
else if(strncmp(pLine, "save", 4) == 0) {
NVstore.save();
DebugPort.println("NV save");
}
else if(strncmp(pLine, "degC", 4) == 0) {
pLine += 4;
cVal = atoi(pLine);
NVstore.setTemperature(cVal);
DebugPort.print("degC = "); DebugPort.println(cVal);
}
else if(strncmp(pLine, "Mode", 4) == 0) {
pLine += 4;
cVal = !NVstore.getThermostatMode();
NVstore.setThermostatMode(cVal);
DebugPort.print("Mode now "); DebugPort.println(cVal ? "Thermostat" : "Fixed Hz");
}
else {
DebugPort.print(pLine); DebugPort.println(" ????");
}
}
}
void initBlueWireSerial()
{
@ -785,7 +723,7 @@ void reqTemp(unsigned char newTemp)
if(newTemp <= min)
newTemp = min;
NVstore.setTemperature(newTemp);
NVstore.setDesiredTemperature(newTemp);
ScreenManager.reqUpdate();
}
@ -799,7 +737,7 @@ void reqTempDelta(int delta)
int getSetTemp()
{
return NVstore.getTemperature();
return NVstore.getDesiredTemperature();
}
void reqThermoToggle()
@ -946,3 +884,18 @@ void checkDebugCommands()
}
}
}
void updateJsonBT()
{
char jsonStr[512];
if(makeJsonString(BTModerator, jsonStr, 512)) {
Bluetooth.send( jsonStr );
}
}
void resetBTModerator()
{
BTModerator.reset();
}

18
Arduino/BTCDieselHeater/BTCWebServer.cpp
View file

@ -36,7 +36,7 @@ WebSocketsServer webSocket = WebSocketsServer(81);
bool bRxWebData = false; // flags for OLED animation
bool bTxWebData = false;
CModerator Moderator; // check for settings that are not actually changing, avoid sending these
CModerator WebModerator; // check for settings that are not actually changing, avoid sending these
const int led = 13;
@ -89,7 +89,7 @@ bool doWebServer(void) {
int numClients = webSocket.connectedClients();
if(numClients != prevNumClients) {
prevNumClients = numClients;
Moderator.reset(); // force full update of params if number of clients change
WebModerator.reset(); // force full update of params if number of clients change
DebugPort.println("Changed number of web clients, resetting history");
}
@ -103,10 +103,10 @@ bool doWebServer(void) {
bool bSend = false; // reset should send flag
float tidyTemp = int(getActualTemperature() * 10) * 0.1f; // round to 0.1 resolution
bSend |= Moderator.send("CurrentTemp", tidyTemp, root);
bSend |= Moderator.send("DesiredTemp", getHeaterInfo().getTemperature_Desired(), root);
bSend |= Moderator.send("RunState", getHeaterInfo().getRunState(), root);
bSend |= Moderator.send("ErrorState", getHeaterInfo().getErrState(), root );
bSend |= WebModerator.addJson("CurrentTemp", tidyTemp, root);
bSend |= WebModerator.addJson("DesiredTemp", getHeaterInfo().getTemperature_Desired(), root);
bSend |= WebModerator.addJson("RunState", getHeaterInfo().getRunState(), root);
bSend |= WebModerator.addJson("ErrorState", getHeaterInfo().getErrState(), root );
if(bSend) {
@ -129,7 +129,6 @@ void webSocketEvent(uint8_t num, WStype_t type, uint8_t * payload, size_t length
for (int i = 0; i < length && i < 256; i++) {
cmd[i] = payload[i];
}
// DebugPort.println(cmd);
interpretJsonCommand(cmd); // send to the main heater controller decode routine
}
}
@ -150,4 +149,7 @@ bool hasWebServerSpoken(bool reset)
return retval;
}
void resetWebModerator()
{
WebModerator.reset();
}

149
Arduino/BTCDieselHeater/BTC_JSON.cpp
View file

@ -19,14 +19,20 @@
*
*/
#include <ArduinoJson.h>
#include "BTC_JSON.h"
#include "DebugPort.h"
#include "helpers.h"
#include "NVstorage.h"
#include "BTCDateTime.h"
char defaultJSONstr[64];
void decodeTimerDays(int timerID, const char* str);
void decodeTimerTime(int ID, int stop, const char*);
void decodeTimerRepeat(int ID, int state);
void interpretJsonCommand(char* pLine)
{
if(strlen(pLine) == 0)
@ -71,41 +77,132 @@ void interpretJsonCommand(char* pLine)
else if(strcmp("Thermostat", it->key) == 0) {
setThermostatMode(it->value.as<unsigned char>());
}
else if(strcmp("NVsave", it->key) == 0) {
if(it->value.as<int>() == 8861)
saveNV();
}
else if(strcmp("DateTime", it->key) == 0) {
setDateTime(it->value.as<const char*>());
}
else if(strcmp("Date", it->key) == 0) {
setDate(it->value.as<const char*>());
}
else if(strcmp("Time", it->key) == 0) {
setTime(it->value.as<const char*>());
}
else if(strcmp("PumpPrime", it->key) == 0) {
reqPumpPrime(it->value.as<unsigned char>());
}
else if(strcmp("Refresh", it->key) == 0) {
resetWebModerator();
resetBTModerator();
}
else if(strcmp("Timer1Days", it->key) == 0) {
decodeTimerDays(0, it->value.as<const char*>());
}
else if(strcmp("Timer1Start", it->key) == 0) {
decodeTimerTime(0, 0, it->value.as<const char*>());
}
else if(strcmp("Timer1Stop", it->key) == 0) {
decodeTimerTime(0, 1, it->value.as<const char*>());
}
else if(strcmp("Timer1Repeat", it->key) == 0) {
decodeTimerRepeat(0, it->value.as<unsigned char>());
}
else if(strcmp("Timer2Days", it->key) == 0) {
decodeTimerDays(1, it->value.as<const char*>());
}
else if(strcmp("Timer2Start", it->key) == 0) {
decodeTimerTime(1, 0, it->value.as<const char*>());
}
else if(strcmp("Timer2Stop", it->key) == 0) {
decodeTimerTime(1, 1, it->value.as<const char*>());
}
else if(strcmp("Timer2Repeat", it->key) == 0) {
decodeTimerRepeat(1, it->value.as<unsigned char>());
}
}
}
const char* createJSON(const char* name, float value, char* jsonToSend)
bool makeJsonString(CModerator& moderator, char* opStr, int len)
{
StaticJsonBuffer<64> jsonBuffer;
JsonObject& root = jsonBuffer.createObject(); // create object to add JSON commands to
StaticJsonBuffer<512> jsonBuffer; // create a JSON buffer on the stack
JsonObject& root = jsonBuffer.createObject(); // create object to add JSON commands to
root.set(name, value);
root.printTo(defaultJSONstr);
strcat(defaultJSONstr, "\n");
bool bSend = false; // reset should send flag
return defaultJSONstr;
float tidyTemp = int(getActualTemperature() * 10) * 0.1f; // round to 0.1 resolution
bSend |= moderator.addJson("TempCurrent", tidyTemp, root);
bSend |= moderator.addJson("TempDesired", getHeaterInfo().getTemperature_Desired(), root);
bSend |= moderator.addJson("TempMin", getHeaterInfo().getTemperature_Min(), root);
bSend |= moderator.addJson("TempMax", getHeaterInfo().getTemperature_Max(), root);
bSend |= moderator.addJson("TempBody", getHeaterInfo().getTemperature_HeatExchg(), root);
bSend |= moderator.addJson("RunState", getHeaterInfo().getRunState(), root);
bSend |= moderator.addJson("ErrorState", getHeaterInfo().getErrState(), root );
bSend |= moderator.addJson("Thermostat", getHeaterInfo().isThermostat(), root );
bSend |= moderator.addJson("PumpFixed", getHeaterInfo().getPump_Fixed(), root );
bSend |= moderator.addJson("PumpMin", getHeaterInfo().getPump_Min(), root );
bSend |= moderator.addJson("PumpMax", getHeaterInfo().getPump_Max(), root );
bSend |= moderator.addJson("PumpActual", getHeaterInfo().getPump_Actual(), root );
bSend |= moderator.addJson("FanMin", getHeaterInfo().getFan_Min(), root );
bSend |= moderator.addJson("FanMax", getHeaterInfo().getFan_Max(), root );
bSend |= moderator.addJson("FanRPM", getHeaterInfo().getFan_Actual(), root );
bSend |= moderator.addJson("FanVoltage", getHeaterInfo().getFan_Voltage(), root );
bSend |= moderator.addJson("SystemVoltage", getHeaterInfo().getBattVoltage(), root );
bSend |= moderator.addJson("GlowVoltage", getHeaterInfo().getGlow_Voltage(), root );
bSend |= moderator.addJson("GlowCurrent", getHeaterInfo().getGlow_Current(), root );
if(bSend) {
root.printTo(opStr, len);
}
return bSend;
}
const char* createJSON(const char* name, unsigned char value, char*jsonToSend)
void decodeTimerDays(int ID, const char* str)
{
StaticJsonBuffer<64> jsonBuffer;
JsonObject& root = jsonBuffer.createObject(); // create object to add JSON commands to
root.set(name, value);
root.printTo(defaultJSONstr);
strcat(defaultJSONstr, "\n");
return defaultJSONstr;
sTimer timer;
NVstore.getTimerInfo(ID, timer);
unsigned char days = 0;
if(strstr(str, "Next")) {
days = 0x80;
}
else {
for(int i=0; i< 7; i++) {
int mask = 0x01 << i;
if(strstr(str, daysOfTheWeek[i]))
days |= mask;
}
}
timer.enabled = days;
NVstore.setTimerInfo(ID, timer);
}
const char* createJSON(const char* name, int value, char* jsonToSend)
void decodeTimerTime(int ID, int stop, const char* str)
{
StaticJsonBuffer<64> jsonBuffer;
JsonObject& root = jsonBuffer.createObject(); // create object to add JSON commands to
root.set(name, value);
root.printTo(defaultJSONstr);
strcat(defaultJSONstr, "\n");
return defaultJSONstr;
sTimer timer;
NVstore.getTimerInfo(ID, timer);
int hour, minute;
if(2 == sscanf(str, "%d:%d", &hour, &minute)) {
if(stop) {
timer.stop.hour = hour;
timer.stop.min = minute;
}
else {
timer.start.hour = hour;
timer.start.min = minute;
}
NVstore.setTimerInfo(ID, timer);
}
}
void decodeTimerRepeat(int ID, int state)
{
sTimer timer;
NVstore.getTimerInfo(ID, timer);
timer.repeat = state;
NVstore.setTimerInfo(ID, timer);
}

22
Arduino/BTCDieselHeater/BTC_JSON.h
View file

@ -22,10 +22,24 @@
#ifndef __BTC_JSON_H__
#define __BTC_JSON_H__
extern char defaultJSONstr[];
#include <ArduinoJson.h>
#include "Moderator.h"
extern char defaultJSONstr[64];
bool makeJsonString(CModerator& moderator, char* opStr, int len);
template<class T>
const char* createJSON(const char* name, T value)
{
StaticJsonBuffer<64> jsonBuffer;
JsonObject& root = jsonBuffer.createObject(); // create object to add JSON commands to
root.set(name, value);
root.printTo(defaultJSONstr);
return defaultJSONstr;
}
const char* createJSON(const char* name, float value, char* jsonToSend = defaultJSONstr);
const char* createJSON(const char* name, unsigned char value, char* jsonToSend = defaultJSONstr);
const char* createJSON(const char* name, int value, char* jsonToSend = defaultJSONstr);
#endif

9
Arduino/BTCDieselHeater/BluetoothAbstract.h
View file

@ -33,6 +33,7 @@ class CBluetoothAbstract {
protected:
sRxLine _rxLine;
CContextTimeStamp _timeStamp;
virtual void foldbackDesiredTemp() {};
public:
virtual void begin() {};
virtual void setRefTime() {
@ -46,13 +47,11 @@ public:
virtual void check() {};
virtual void collectRxData(char rxVal) {
// provide common behviour for bytes received from a bluetooth client
if(isControl(rxVal)) { // "End of Line"
interpretCommand(_rxLine.Line);
_rxLine.append(rxVal); // append new char to our Rx buffer
if(rxVal == '}') { // "End of JSON Line"
interpretJsonCommand(_rxLine.Line);
_rxLine.clear();
}
else {
_rxLine.append(rxVal); // append new char to our Rx buffer
foldbackDesiredTemp(); // rapid foldback if desired temp changes
}
};
virtual bool isConnected() { return false; };

15
Arduino/BTCDieselHeater/BluetoothHC05.cpp
View file

@ -24,6 +24,7 @@
#include "debugport.h"
#include "BluetoothHC05.h"
#include "BTCConfig.h"
#include "helpers.h"
// Bluetooth access via HC-05 Module, using a UART
@ -150,6 +151,7 @@ CBluetoothHC05::isConnected()
void
CBluetoothHC05::send(const char* Str)
{
DebugPort.print("BT send: "); DebugPort.println(Str);
HC05_SerialPort.print(Str);
}
@ -207,3 +209,16 @@ CBluetoothHC05::ATCommand(const char* cmd)
return false;
}
void
CBluetoothHC05::foldbackDesiredTemp()
{
StaticJsonBuffer<32> jsonBuffer; // create a JSON buffer on the stack
JsonObject& root = jsonBuffer.createObject(); // create object to add JSON commands to
if(foldbackModerator.addJson("TempDesired", getSetTemp(), root)) {
char opStr[32];
root.printTo(opStr);
send(opStr);
}
}

3
Arduino/BTCDieselHeater/BluetoothHC05.h
View file

@ -21,6 +21,7 @@
#include "BluetoothAbstract.h"
#include "Moderator.h"
// Define the serial port for access to a HC-05 module.
// This is generally Serial2, but different platforms use
@ -38,6 +39,7 @@ static HardwareSerial& HC05_SerialPort(Serial2);
class CBluetoothHC05 : public CBluetoothAbstract {
bool ATCommand(const char* str);
int _sensePin, _keyPin;
CModerator foldbackModerator;
public:
CBluetoothHC05(int keyPin, int sensePin);
void begin();
@ -47,4 +49,5 @@ public:
virtual bool isConnected();
protected:
virtual void openSerial(int baudrate);
virtual void foldbackDesiredTemp();
};

32
Arduino/BTCDieselHeater/Clock.cpp
View file

@ -121,3 +121,35 @@ CClock::_checkTimer(int timer, const DateTime& now)
}
}
}
void setDateTime(const char* newTime)
{
DebugPort.print("setting time to: "); DebugPort.println(newTime);
int month,day,year,hour,minute,second;
if(6 == sscanf(newTime, "%d/%d/%d %d:%d:%d", &day, &month, &year, &hour, &minute, &second)) {
DateTime newDateTime(year, month, day, hour, minute, second);
Clock.set(newDateTime);
}
}
void setDate(const char* newDate)
{
DebugPort.print("setting date to: "); DebugPort.println(newDate);
int month,day,year;
if(3 == sscanf(newDate, "%d/%d/%d", &day, &month, &year)) {
DateTime currentDateTime = Clock.get();
DateTime newDateTime(year, month, day, currentDateTime.hour(), currentDateTime.minute(), currentDateTime.second());
Clock.set(newDateTime);
}
}
void setTime(const char* newTime)
{
DebugPort.print("setting time to: "); DebugPort.println(newTime);
int hour,minute,second;
if(3 == sscanf(newTime, "%d:%d:%d", &hour, &minute, &second)) {
DateTime currentDateTime = Clock.get();
DateTime newDateTime(currentDateTime.year(), currentDateTime.month(), currentDateTime.day(), hour, minute, second);
Clock.set(newDateTime);
}
}

27
Arduino/BTCDieselHeater/Moderator.h
View file

@ -30,7 +30,7 @@ class TModerator {
std::map<const char*, T> Memory;
public:
bool shouldSend(const char* name, T value);
bool send(const char* name, T value, JsonObject& root);
bool addJson(const char* name, T value, JsonObject& root);
void reset();
};
@ -50,7 +50,7 @@ bool TModerator<T>::shouldSend(const char* name, T value)
}
template<class T>
bool TModerator<T>::send(const char* name, T value, JsonObject& root)
bool TModerator<T>::addJson(const char* name, T value, JsonObject& root)
{
bool retval;
if( retval = shouldSend(name, value ) )
@ -58,6 +58,7 @@ bool TModerator<T>::send(const char* name, T value, JsonObject& root)
return retval;
}
template<class T>
void TModerator<T>::reset()
{
@ -66,20 +67,28 @@ void TModerator<T>::reset()
}
}
class CModerator {
TModerator<int> iModerator;
TModerator<float> fModerator;
TModerator<unsigned char> ucModerator;
public:
bool send(const char* name, int value, JsonObject& root) {
return iModerator.send(name, value, root);
bool shouldSend(const char* name, int value) {
return iModerator.shouldSend(name, value);
};
bool send(const char* name, float value, JsonObject& root) {
return fModerator.send(name, value, root);
bool shouldSend(const char* name, float value) {
return fModerator.shouldSend(name, value);
};
bool send(const char* name, unsigned char value, JsonObject& root) {
return ucModerator.send(name, value, root);
bool shouldSend(const char* name, unsigned char value) {
return ucModerator.shouldSend(name, value);
};
bool addJson(const char* name, int value, JsonObject& root) {
return iModerator.addJson(name, value, root);
};
bool addJson(const char* name, float value, JsonObject& root) {
return fModerator.addJson(name, value, root);
};
bool addJson(const char* name, unsigned char value, JsonObject& root) {
return ucModerator.addJson(name, value, root);
};
void reset() {
iModerator.reset();

4
Arduino/BTCDieselHeater/NVStorage.cpp
View file

@ -97,7 +97,7 @@ CHeaterStorage::getFmax()
}
unsigned char
CHeaterStorage::getTemperature()
CHeaterStorage::getDesiredTemperature()
{
return _calValues.Heater.setTemperature;
}
@ -135,7 +135,7 @@ CHeaterStorage::setFmax(unsigned short val)
}
void
CHeaterStorage::setTemperature(unsigned char val)
CHeaterStorage::setDesiredTemperature(unsigned char val)
{
_calValues.Heater.setTemperature = val;
}

4
Arduino/BTCDieselHeater/NVStorage.h
View file

@ -98,14 +98,14 @@ public:
float getPmax();
unsigned short getFmin();
unsigned short getFmax();
unsigned char getTemperature();
unsigned char getDesiredTemperature();
unsigned char getThermostatMode();
void setPmin(float);
void setPmax(float);
void setFmin(unsigned short val);
void setFmax(unsigned short val);
void setTemperature(unsigned char val);
void setDesiredTemperature(unsigned char val);
void setThermostatMode(unsigned char val);
void getTimerInfo(int idx, sTimer& timerInfo);

31
Arduino/BTCDieselHeater/Protocol.cpp
View file

@ -200,28 +200,33 @@ CProtocol::setTemperature_HeatExchg(short degC) // temperature of heat exchanger
Heater.HeatExchgTemp_LSB = (degC >> 0) & 0xff;
}
short
CProtocol::getFan_Voltage() const // temperature near inlet
float
CProtocol::getFan_Voltage() const // fan voltage
{
short retval;
retval = Heater.FanVoltage_MSB;
retval <<= 8;
retval |= Heater.FanVoltage_LSB;
return retval;
if(getRunState()) { // fan volatge sensing goes stupid when main heater relay turns off!
short val;
val = Heater.FanVoltage_MSB;
val <<= 8;
val |= Heater.FanVoltage_LSB;
return float(val) * 0.1;
}
return 0;
}
void
CProtocol::setFan_Voltage(short voltsx10) // temperature near inlet
CProtocol::setFan_Voltage(float volts) // fan voltage
{
Heater.FanVoltage_MSB = (voltsx10 >> 8) & 0xff;
Heater.FanVoltage_LSB = (voltsx10 >> 0) & 0xff;
short val = short(volts * 10);
Heater.FanVoltage_MSB = (val >> 8) & 0xff;
Heater.FanVoltage_LSB = (val >> 0) & 0xff;
}
void
CProtocol::setVoltage_Supply(short voltsx10)
CProtocol::setVoltage_Supply(float volts)
{
Heater.SupplyV_MSB = (voltsx10 >> 8) & 0xff;
Heater.SupplyV_LSB = (voltsx10 >> 0) & 0xff;
short val = short(volts * 10);
Heater.SupplyV_MSB = (val >> 8) & 0xff;
Heater.SupplyV_LSB = (val >> 0) & 0xff;
}
float

11
Arduino/BTCDieselHeater/Protocol.h
View file

@ -149,7 +149,7 @@ public:
//
float getVoltage_Supply() const;
float getVoltage_SupplyRaw() const;
void setVoltage_Supply(short voltsx10);
void setVoltage_Supply(float volts);
// fan set/get
short getFan_Actual() const; // Heater side, actual
@ -158,8 +158,8 @@ public:
void setFan_Actual(short speed); // Heater side, actual
void setFan_Min(short speed); // Controller side, define min fan speed
void setFan_Max(short speed); // Controller side, define max fan speed
short getFan_Voltage() const; // fan voltage
void setFan_Voltage(short voltsx10); // fan voltage
float getFan_Voltage() const; // fan voltage
void setFan_Voltage(float volts); // fan voltage
// pump set/get
void setPump_Min(float Freq) { Controller.MinPumpFreq = (uint8_t)(Freq * 10.f + 0.5f); };
@ -217,6 +217,8 @@ public:
bool isThermostat() const { return Controller.isThermostat(); };
float getTemperature_Desired() const { return float(Controller.getTemperature_Desired()); };
float getTemperature_HeatExchg() const { return float(Heater.getTemperature_HeatExchg()); };
float getTemperature_Min() const { return float(Controller.getTemperature_Min()); };
float getTemperature_Max() const { return float(Controller.getTemperature_Max()); };
float getPump_Fixed() const { return Heater.getPump_Fixed(); };
float getPump_Actual() const { return Heater.getPump_Actual(); };
float getPump_Min() const { return Controller.getPump_Min(); };
@ -224,7 +226,10 @@ public:
float getFan_Actual() const { return Heater.getFan_Actual(); };
short getFan_Min() const { return Controller.getFan_Min(); };
short getFan_Max() const { return Controller.getFan_Max(); };
float getFan_Voltage() const { return Heater.getFan_Voltage(); };
float getGlowPlug_Power() const { return Heater.getGlowPlug_Current() * Heater.getGlowPlug_Voltage(); };
float getGlow_Voltage() const { return Heater.getGlowPlug_Voltage(); };
float getGlow_Current() const { return Heater.getGlowPlug_Current(); };
};

7
Arduino/BTCDieselHeater/Screen7.cpp
View file

@ -22,9 +22,9 @@
///////////////////////////////////////////////////////////////////////////
//
// CScreen5
// CScreen7
//
// This screen allows the fuel mixture endpoints to be adjusted
// This screen allows the timers to be adjusted
//
///////////////////////////////////////////////////////////////////////////
@ -58,6 +58,9 @@ CScreen7::show()
char str[16];
int xPos, yPos;
if(_rowSel == 0) {
NVstore.getTimerInfo(_instance, _timer);
}
sprintf(str, " Timer %d ", _instance + 1);
_printInverted(0, 16, str, true);

2
Arduino/BTCDieselHeater/TxManage.cpp
View file

@ -118,7 +118,7 @@ CTxManage::PrepareFrame(const CProtocol& basisFrame, bool isBTCmaster)
m_TxFrame.setPump_Min(NVstore.getPmin());
m_TxFrame.setPump_Max(NVstore.getPmax());
m_TxFrame.setThermostatMode(NVstore.getThermostatMode());
m_TxFrame.setTemperature_Desired(NVstore.getTemperature());
m_TxFrame.setTemperature_Desired(NVstore.getDesiredTemperature());
}
else {
m_TxFrame.setPassiveMode(); // this prevents the tuning parameters being saved by heater

25
Arduino/BTCDieselHeater/helpers.h
View file

@ -20,26 +20,31 @@
*
*/
class CProtocolPackage;
#include "Protocol.h"
extern void ToggleOnOff();
extern void requestOn();
extern void requestOff();
extern void reqTempDelta(int delta);
extern void reqTemp(unsigned char newTemp);
extern void reqThermoToggle();
extern void setThermostatMode(unsigned char);
extern void reqPumpPrime(bool on);
extern void ToggleOnOff();
extern void requestOn();
extern void requestOff();
extern void reqTempDelta(int delta);
extern void reqTemp(unsigned char newTemp);
extern void reqThermoToggle();
extern void setThermostatMode(unsigned char);
extern void reqPumpPrime(bool on);
extern float getActualTemperature();
extern int getSetTemp();
extern void setPumpMin(float);
extern void setPumpMax(float);
extern void setFanMin(short);
extern void setFanMax(short);
extern void setDateTime(const char* newTime);
extern void setDate(const char* newTime);
extern void setTime(const char* newTime);
extern void saveNV();
extern const CProtocolPackage& getHeaterInfo();
extern void interpretCommand(const char* pLine);
extern void interpretJsonCommand(char* pLine);
extern void resetWebModerator();
extern void resetBTModerator();
#define LOWERLIMIT(A, B) if(A < B) A = B
#define UPPERLIMIT(A, B) if(A > B) A = B