Gracefully handle ambient and heaters missing

GuLinux · GuLinux · commit 0b7f2a323189 · 2024-09-01T09:00:56.000+01:00
diff --git a/src/ambient/ambient-none.cpp b/src/ambient/ambient-none.cpp
@@ -0,0 +1,15 @@
+#include "ambient-p.h"
+#ifdef APB_AMBIENT_TEMPERATURE_SENSOR_NONE
+
+
+
+bool APB::Ambient::initialiseSensor() {
+  Log.infoln(LOG_SCOPE "No Ambient sensor installed");
+  return false;
+}
+
+void APB::Ambient::readSensor() {
+}
+
+#endif
+
diff --git a/src/configuration.h b/src/configuration.h
@@ -20,8 +20,10 @@
 #define APB_HEATER_TEMPERATURE_SENSOR_THERMISTOR_NOMINAL 10'000
 #define APB_HEATER_TEMPERATURE_SENSOR_THERMISTOR_NOMINAL_TEMP 25
 #define APB_HEATER_TEMPERATURE_SENSOR_THERMISTOR_B_VALUE 3950
-#define APB_POWER_MAX_CURRENT_AMPS 15
+#define APB_POWER_MAX_CURRENT_AMPS 8
 #define APB_POWER_SHUNT_OHMS 0.040
+#define APB_POWER_INA219_GAIN 8
+#define APB_POWER_INA219_VOLTAGE_RANGE 16
 #define APB_HISTORY_TASK_SECONDS 10'000
 
 #define APB_AMBIENT_TEMPERATURE_SENSOR_SHT4x
diff --git a/src/history.cpp b/src/history.cpp
@@ -10,16 +10,20 @@ APB::History::History() {
 }
 
 
+#if APB_HEATERS_SIZE > 0
 void APB::History::Entry::Heater::set(const APB::Heater &heater) {
     temperatureHundredth = static_cast<int16_t>(heater.temperature().value_or(-100.0) * 100.0);
     duty = heater.active() ? heater.duty() : 0;
 }
+#endif
 
+#ifndef APB_AMBIENT_TEMPERATURE_SENSOR_NONE
 void APB::History::Entry::setAmbient(const std::optional<Ambient::Reading> &reading) {
     const auto readingValue = reading.value_or(Ambient::Reading{-100.0, -100.0});
     ambientTemperatureHundredth = static_cast<uint16_t>(readingValue.temperature * 100.0);
     ambientHumidityHundredth = static_cast<uint16_t>(readingValue.humidity * 100.0);
 }
+#endif
 
 void APB::History::Entry::setPower(const PowerMonitor::Status & powerStatus) {
     busVoltageHundreth = static_cast<uint16_t>(powerStatus.busVoltage * 100.0);
@@ -28,14 +32,26 @@ void APB::History::Entry::setPower(const PowerMonitor::Status & powerStatus) {
 
 void APB::History::Entry::populate(JsonObject object) {
     object["uptime"] = secondsFromBoot;
+
+#ifndef APB_AMBIENT_TEMPERATURE_SENSOR_NONE
     setNullableFloat(object, "ambientTemperature", getAmbientTemperature());
     setNullableFloat(object, "ambientHumidity", getAmbientHumidity());
     object["ambientDewpoint"] = getDewpoint();
+#else
+    object["ambientTemperature"] = static_cast<char*>(0);
+    object["ambientHumidity"] = static_cast<char*>(0);
+    object["ambientDewpoint"] = static_cast<char*>(0);
+#endif
+
+#if APB_HEATERS_SIZE > 0
     for(uint8_t i=0; i<heaters.size(); i++) {
         JsonObject heaterObject = object["heaters"][i].to<JsonObject>();;
         heaterObject["duty"] = heaters[i].getDuty();
         setNullableFloat(heaterObject, "temperature", heaters[i].getTemperature());
     }
+#else
+    object["heaters"].to<JsonArray>();
+#endif
     object["busVoltage"] = getBusVoltage();
     object["power"] = getPower();
     object["current"] = getCurrent();
diff --git a/src/history.h b/src/history.h
@@ -20,30 +20,35 @@ class History {
 public:
     History();
     struct Entry {
+        #if APB_HEATERS_SIZE > 0
         struct Heater {
             int16_t temperatureHundredth;
             uint8_t duty;
             void set(const APB::Heater &heater);
             float getTemperature() const { return static_cast<float>(temperatureHundredth) / 100.0; }
             float getDuty() const { return static_cast<float>(duty); }
         };
+        std::array<Heater, APB_HEATERS_TEMP_SENSORS> heaters;
+        #endif
         uint32_t secondsFromBoot;
+        #ifndef APB_AMBIENT_TEMPERATURE_SENSOR_NONE
         void setAmbient(const std::optional<Ambient::Reading> &reading);
-        void setPower(const PowerMonitor::Status &powerStatus);
-
+        float getAmbientTemperature() const { return static_cast<float>(ambientTemperatureHundredth) / 100.0; }
+        float getAmbientHumidity() const { return static_cast<float>(ambientHumidityHundredth) / 100.0; }
+        float getDewpoint() const { return Ambient::calculateDewpoint(getAmbientTemperature(), getAmbientHumidity()); }
         int16_t ambientTemperatureHundredth;
         int16_t ambientHumidityHundredth;
+        #endif
+        void setPower(const PowerMonitor::Status &powerStatus);
+
         int16_t busVoltageHundreth;
         int16_t currentHundreth;
 
-        float getAmbientTemperature() const { return static_cast<float>(ambientTemperatureHundredth) / 100.0; }
-        float getAmbientHumidity() const { return static_cast<float>(ambientHumidityHundredth) / 100.0; }
-        float getDewpoint() const { return Ambient::calculateDewpoint(getAmbientTemperature(), getAmbientHumidity()); }
-
+        
         float getBusVoltage() const { return static_cast<float>(busVoltageHundreth) / 100.0; }
         float getCurrent() const { return static_cast<float>(currentHundreth) / 100.0; }
         float getPower() const { return getCurrent() * getBusVoltage(); }
-        std::array<Heater, APB_HEATERS_TEMP_SENSORS> heaters;
+        
 
         void populate(JsonObject object);
         
diff --git a/src/main.cpp b/src/main.cpp
@@ -124,10 +124,16 @@ void addHistoryEntry() {
   APB::History::Entry entry {
     esp_timer_get_time() / 1000'000
   };
+
+#ifndef APB_AMBIENT_TEMPERATURE_SENSOR_NONE
   entry.setAmbient(APB::Ambient::Instance.reading());
+#endif
+  
+#if APB_HEATERS_SIZE > 0
   for(uint8_t i=0; i<APB_HEATERS_TEMP_SENSORS; i++) {
     entry.heaters[i].set(APB::Heaters::Instance[i]);
   }
+#endif
   entry.setPower(APB::PowerMonitor::Instance.status());
   APB::History::Instance.add(entry);
 }
diff --git a/src/webserver.cpp b/src/webserver.cpp
@@ -68,7 +68,12 @@ void APB::WebServer::setup() {
 
     new Task(1000, TASK_FOREVER, [this](){
         eventsDocument.clear();
-        populateAmbientStatus(eventsDocument.createNestedObject("ambient"));
+        if(Ambient::Instance.isInitialised()) {
+            populateAmbientStatus(eventsDocument.createNestedObject("ambient"));
+        } else {
+            eventsDocument["ambient"] = static_cast<char*>(0);
+        }
+        
         populatePowerStatus(eventsDocument.createNestedObject("power"));
         populateHeatersStatus(eventsDocument.createNestedArray("heaters"));
         eventsDocument["app"]["uptime"] = esp_timer_get_time() / 1000'000.0;
diff --git a/web/src/App.js b/web/src/App.js
@@ -4,7 +4,7 @@ import { setAmbient } from './features/sensors/ambient/ambientSlice';
 import { useDispatch, useSelector } from 'react-redux';
 import { getHeatersAsync, updateHeaters } from './features/sensors/heaters/heatersSlice';
 import { setPower } from './features/sensors/power/powerSlice';
-import { darkModeSelector, getHistoryAsync, setUptime, tabSelector } from './features/app/appSlice';
+import { darkModeSelector, getAppStatusAsync, getHistoryAsync, setUptime, tabSelector } from './features/app/appSlice';
 import Tab from 'react-bootstrap/Tab';
 import Container from 'react-bootstrap/Container';
 import { Home } from './features/Home';
@@ -15,8 +15,13 @@ const registerEventSource = dispatch => {
   const es = new EventSource('/api/events');
   es.addEventListener('status', m => {
     const data = JSON.parse(m.data);
-    dispatch(setAmbient(data.ambient));
-    dispatch(updateHeaters(data.heaters));
+    if(data.ambient) {
+      dispatch(setAmbient(data.ambient));
+    }
+    if(data.heaters.length > 0) {
+      dispatch(updateHeaters(data.heaters));
+    } 
+    
     dispatch(setPower(data.power));
     dispatch(setUptime(data.app.uptime));
   })
@@ -29,6 +34,7 @@ const LightMode = () => <link rel="stylesheet" type="text/css" href='flatly.min.
 function App() {
   const dispatch = useDispatch();
   const darkMode = useSelector(darkModeSelector)
+  useEffect(() => { dispatch(getAppStatusAsync()) }, [dispatch])
   useEffect(() => { dispatch(getHistoryAsync()) }, [dispatch])
   useEffect(() => { dispatch(getHeatersAsync()) }, [dispatch])
   useEffect(() => registerEventSource(dispatch), [dispatch]);
diff --git a/web/src/features/Home.js b/web/src/features/Home.js
@@ -1,14 +1,24 @@
+import { useSelector } from "react-redux"
 import { Ambient } from "./sensors/ambient/Ambient"
 import { Heaters } from "./sensors/heaters/Heaters"
 import { Power } from "./sensors/power/Power"
+import { selectHeatersCount } from "./sensors/heaters/heatersSlice"
+import { appStatusSelector } from "./app/appSlice"
 
 export const Home = () => {
+    const heatersCount = useSelector(selectHeatersCount);
+    const hasAmbient = useSelector(appStatusSelector).hasAmbientSensor
     return <>
-        <h2>Environment</h2>
-        <Ambient />
-        <h2 className="mt-5">Heaters</h2>
-        <Heaters />
-        <h2 className="mt-5">Power</h2>
+        { hasAmbient && <>
+            <h2 className="mb-5">Environment</h2>
+            <Ambient />
+        </> }
+        { heatersCount > 0 && <>
+            <h2 className="mb-5">Heaters</h2>
+            <Heaters />
+        </>
+        }
+        <h2 className="mb-5">Power</h2>
         <Power />
     </>
 }
diff --git a/web/src/features/app/api.js b/web/src/features/app/api.js
@@ -20,6 +20,7 @@ const payloadJson = async (path, method, payload) => {
 export const fetchHistory = async () => await fetchJson('/api/history')
 export const fetchHeaters = async () => await fetchJson('/api/heaters')
 export const fetchConfig = async () => await fetchJson('/api/config')
+export const fetchStatus = async () => await fetchJson('/api/status')
 export const saveConfig = async () => await fetchJson('/api/config/write', { method: 'POST'})
 export const saveWiFiAccessPointConfig = async payload => await payloadJson('/api/config/accessPoint', 'POST', payload)
 export const saveWiFiStationConfig = async payload => await payloadJson('/api/config/station', 'POST', payload)
diff --git a/web/src/features/app/appSlice.js b/web/src/features/app/appSlice.js
@@ -1,25 +1,32 @@
 import { createAsyncThunk, createSlice } from '@reduxjs/toolkit';
-import { fetchAppInfo, fetchHistory, fetchReconnectWiFi, fetchRestart } from './api';
+import { fetchAppInfo, fetchHistory, fetchReconnectWiFi, fetchRestart, fetchStatus } from './api';
 
 const initialState = {
     tab: 'home',
     darkMode: true,
     info: {
       ready: false,
       uptime: 0,
-    }
+    },
+    status: {}
 };
 
 export const tabSelector = state => state.app.tab
 export const darkModeSelector = state => state.app.darkMode
 export const appInfoSelector = state => state.app.info
 export const appUptimeSelector = state => state.app.info.uptime
+export const appStatusSelector = state => state.app.status
 
 export const getAppInfoAsync = createAsyncThunk(
   'app/getInfo',
   async () => await fetchAppInfo()
 );
 
+export const getAppStatusAsync = createAsyncThunk(
+  'app/getStatus',
+  async () => await fetchStatus()
+);
+
 export const getHistoryAsync = createAsyncThunk(
   'app/getHistory',
   async () => await fetchHistory()
@@ -46,6 +53,17 @@ export const appSlice = createSlice({
   },
   extraReducers: (builder) => {
     builder
+      .addCase(getAppStatusAsync.pending, (state) => {
+        state.status.ready = false
+      })
+      .addCase(getAppStatusAsync.fulfilled, (state, {payload: status}) => {
+        state.status.ready = true;
+        state.status.hasPowerMonitor = status.has_power_monitor;
+        state.status.hasAmbientSensor = status.has_ambient_sensor;
+        state.status.status = status.status;
+      })
+
+
       .addCase(getAppInfoAsync.pending, (state) => {
         state.info.ready = false
       })
diff --git a/web/src/features/sensors/ambient/ambientSlice.js b/web/src/features/sensors/ambient/ambientSlice.js
@@ -32,7 +32,9 @@ export const ambientSlice = createSlice({
         }
         const { now: bootSeconds, entries } = payload;
         entries.forEach( ({uptime, ambientTemperature: temperature, ambientHumidity: humidity, ambientDewpoint: dewpoint }) => {
-          state.history = [...state.history, { timestamp: historyEntryTimestamp(bootSeconds, uptime), temperature, humidity, dewpoint}]
+          if(temperature !== null && humidity !== null ) {
+            state.history = [...state.history, { timestamp: historyEntryTimestamp(bootSeconds, uptime), temperature, humidity, dewpoint}]
+          }
         })
       })
   }
diff --git a/web/src/features/sensors/heaters/Heaters.js b/web/src/features/sensors/heaters/Heaters.js
@@ -175,7 +175,7 @@ const Heater = ({heater, index}) => {
 }
 
 export const Heaters = () => {
-    const { heaters } = useSelector(selectHeaters);
+    const heaters = useSelector(selectHeaters);
     return <>
         <Table>
             <thead>
diff --git a/web/src/features/sensors/heaters/heatersSlice.js b/web/src/features/sensors/heaters/heatersSlice.js
@@ -1,4 +1,4 @@
-import { createAsyncThunk, createSlice } from '@reduxjs/toolkit';
+import { createAsyncThunk, createSelector, createSlice } from '@reduxjs/toolkit';
 import { fetchHeaters, setHeater } from '../../app/api';
 import { historyEntryTimestamp } from '../../../utils';
 import { getHistoryAsync } from '../../app/appSlice';
@@ -29,7 +29,8 @@ const onHeatersReceived = (state, payload) => {
   addHeatersToHistory(state)
 }
 
-export const selectHeaters = state => state.heaters;
+export const selectHeaters = state => state.heaters.heaters;
+export const selectHeatersCount = createSelector([selectHeaters], heaters => heaters.length)
 export const selectHeatersHistory = state => state.heaters.history.map(entry => {
   const mappedEntry = { name: new Date(entry.timestamp).toLocaleTimeString(), heaters: entry.heaters.length }
   entry.heaters.forEach((heater, index) => {
@@ -56,12 +57,15 @@ export const heatersSlice = createSlice({
       .addCase(getHeatersAsync.fulfilled, (state, action) => onHeatersReceived(state, action.payload))
       .addCase(setHeaterAsync.fulfilled, (state, action) => onHeatersReceived(state, action.payload))
       .addCase(getHistoryAsync.fulfilled, (state, { payload }) => {
+        console.log(payload)
         if(!payload) {
           return;
         }
         const { now: bootSeconds, entries } = payload;
         entries.forEach( ({uptime,  heaters}) => {
-          state.history = [...state.history, { timestamp: historyEntryTimestamp(bootSeconds, uptime), heaters }]
+          if(heaters.length > 0) {
+            state.history = [...state.history, { timestamp: historyEntryTimestamp(bootSeconds, uptime), heaters }]
+          }
         })
       })
   },
diff --git a/web/src/setupProxy.js b/web/src/setupProxy.js
@@ -1,7 +1,7 @@
 const { createProxyMiddleware } = require('http-proxy-middleware');
 
 module.exports = function(app) {
-  const target = 'http://astropowerbox-c11.lan'
+  const target = 'http://astropowerbox-prototype.lan'
   console.log(`****** proxy setup: "/api" => ${target}`)
   app.use(
     '/api',
