Added individual channel enable for EGT channels, and added 0305 AEMNet protocol back in

Author: xtitoris

firmware/boards/port.h

@@ -59,15 +59,26 @@ enum class AuxOutputMode : uint8_t {
     Egt1 = 5,
 };
 
-enum class CanProtocol : uint8_t {
+enum class CanAfrProtocol : uint8_t {
     None = 0,
     AemNet = 1,
     LinkEcu = 2,
     Haltech = 3,
+    EcuMaster = 4,
+    Motec = 6,
+    Emtron = 7,
+};
+
+enum class CanEgtProtocol : uint8_t {
+    None = 0,
+    AemNet0305 = 1,
+    LinkEcu = 2,
+    Haltech = 3,
     EcuMasterClassic = 4,
     EcuMasterBlack = 5,
     Motec = 6,
     Emtron = 7,
+    AemNet2224 = 8,
 };
 
 class Configuration {
@@ -110,7 +121,7 @@ class Configuration {
             afr[i].RusEfiIdx = i;
 
             // No extra protocol by default
-            afr[i].ExtraCanProtocol = CanProtocol::None;
+            afr[i].ExtraCanProtocol = CanAfrProtocol::None;
             afr[i].ExtraCanIdOffset = i;
         }
 
@@ -121,7 +132,8 @@ class Configuration {
             egt[i].RusEfiIdx = i;
 
             // AemNet protocol by default
-            egt[i].ExtraCanProtocol = CanProtocol::AemNet;
+            egt[i].ExtraCanProtocol = CanEgtProtocol::AemNet0305;
+            egt[i].ExtraCanChannelEnabled = true;
             egt[i].ExtraCanIdOffset = i;
         }
 
@@ -149,8 +161,7 @@ class Configuration {
             struct {
                 bool RusEfiTx:1;
                 bool RusEfiTxDiag:1;
-                CanProtocol ExtraCanProtocol:4;
-
+                CanAfrProtocol ExtraCanProtocol:4;
 
                 uint8_t RusEfiIdx;
                 uint8_t ExtraCanIdOffset;
@@ -161,8 +172,9 @@ class Configuration {
             struct {
                 bool RusEfiTx:1;
                 bool RusEfiTxDiag:1;
-                CanProtocol ExtraCanProtocol:4;
-
+                CanEgtProtocol ExtraCanProtocol:4;
+                uint8_t Reserved0:3; // Keep some room for future protocol expansion without breaking the config format
+                bool ExtraCanChannelEnabled:1; // Is the channel actually enabled in the selected protocol
 
                 uint8_t RusEfiIdx;
                 uint8_t ExtraCanIdOffset;

firmware/can.cpp

@@ -39,9 +39,7 @@ void CanTxThread(void*)
 
         // EGT - 20 Hz
         if ((cycle % 5) == 0) {
-            for (int ch = 0; ch < EGT_CHANNELS; ch++) {
-                SendCanEgtForChannel(ch);
-            }
+            SendCanEgt();
         }
 
         cycle++;
@@ -102,56 +100,59 @@ __attribute__((weak)) void SendCanForChannel(uint8_t ch)
 
     switch (configuration->afr[ch].ExtraCanProtocol)
     {
-        case CanProtocol::AemNet:
+        case CanAfrProtocol::AemNet:
             SendAemNetUEGOFormat(configuration, ch);
             break;
-        case CanProtocol::EcuMasterClassic:
-        case CanProtocol::EcuMasterBlack:
+        case CanAfrProtocol::EcuMaster:
             SendEcuMasterAfrFormat(configuration, ch);
             break;
-        case CanProtocol::Haltech:
+        case CanAfrProtocol::Haltech:
             SendHaltechAfrFormat(configuration, ch);
             break;
-        case CanProtocol::LinkEcu:
+        case CanAfrProtocol::LinkEcu:
             SendLinkAfrFormat(configuration, ch);
             break;
-        case CanProtocol::Emtron:
+        case CanAfrProtocol::Emtron:
             SendEmtronAfrFormat(configuration, ch);
             break;
-        case CanProtocol::Motec:
+        case CanAfrProtocol::Motec:
             SendMotecAfrFormat(configuration, ch);
             break;
         default:
             break;
     }
 }
 
-__attribute__((weak)) void SendCanEgtForChannel(uint8_t ch)
+__attribute__((weak)) void SendCanEgt()
 {
 #if (EGT_CHANNELS > 0)
 
-    SendRusefiEgtFormat(configuration, ch);
+    SendRusefiEgtFormat(configuration);
 
-    switch (configuration->egt[ch].ExtraCanProtocol)
+    // Look at channel 0 EGT protocol
+    switch (configuration->egt[0].ExtraCanProtocol)
     {
-        case CanProtocol::AemNet:
-            SendAemNetEGTFormat(configuration, ch);
+        case CanEgtProtocol::AemNet0305:
+            SendAemNetEGT0305Format(configuration);
             break;
-        case CanProtocol::EcuMasterClassic:
-        case CanProtocol::EcuMasterBlack:
-            SendEcuMasterEgtFormat(configuration, ch);
+        case CanEgtProtocol::AemNet2224:
+            SendAemNetEGT2224Format(configuration);
             break;
-        case CanProtocol::Haltech:
-            SendHaltechEgtFormat(configuration, ch);
+        case CanEgtProtocol::EcuMasterClassic:
+        case CanEgtProtocol::EcuMasterBlack:
+            SendEcuMasterEgtFormat(configuration);
             break;
-        case CanProtocol::LinkEcu:
-            SendLinkEgtFormat(configuration, ch);
+        case CanEgtProtocol::Haltech:
+            SendHaltechEgtFormat(configuration);
             break;
-        case CanProtocol::Emtron:
-            SendEmtronEgtFormat(configuration, ch);
+        case CanEgtProtocol::LinkEcu:
+            SendLinkEgtFormat(configuration);
             break;
-        case CanProtocol::Motec:
-            SendMotec888Format(configuration, ch);
+        case CanEgtProtocol::Emtron:
+            SendEmtronEgtFormat(configuration);
+            break;
+        case CanEgtProtocol::Motec:
+            SendMotec888Format(configuration);
             break;
         default:
             break;

firmware/can.h

@@ -21,7 +21,7 @@ float GetRemoteBatteryVoltage();
 // implement this for your board if you want some non-standard behavior
 // default implementation simply calls SendRusefiFormat
 void SendCanForChannel(uint8_t ch);
-void SendCanEgtForChannel(uint8_t ch);
+void SendCanEgt();
 
 // Helpers to support both bxCAN and CANFD peripherals
 #ifdef STM32G4XX

firmware/can/can_aemnet.cpp

@@ -70,62 +70,84 @@ namespace aemnet
 
 #define AEMNET_EGT_TX_PERIOD        50
 
-// That's for AEM EGT Gauge 1800F (30-0305)
-// It does not support multiple EGT channels, as 0x000A0306 is a ID of AEM Boost Gauge 50psia (30-0306)
-//#define AEMNET_EGT_BASE_ID          0x000A0305 
+// AEM EGT Gauge 1800F (30-0305)
+#define AEMNET_EGT_0305_BASE_ID          0x000A0305 
 
-// This one is for 8-Channel K-Type CAN Module (30-2224), which supports up to 8 EGT channels
+struct Egt0305Data
+{
+    // 1 degC/bit, 0 to 65535 degC
+    beuint16_t TemperatureC;
+    uint8_t Reserved[6];
+} __attribute__((packed));
+
+static_assert(sizeof(Egt0305Data) == 8);
+
+// 8-Channel K-Type CAN Module (30-2224), which supports up to 8 EGT channels
 // https://documents.aemelectronics.com/techlibrary_30-2224-_8-channel-k-type-can-module-instructions.pdf
 // 0xBA00 and 0xBB00 if using 29 bit IDs 
 // 0x5A0 and 0x5B0 if using 11 bit IDs
-#define AEMNET_EGT1_BASE_ID          0x0000BA00
-#define AEMNET_EGT2_BASE_ID          0x0000BB00
+#define AEMNET_EGT_2224_1_BASE_ID          0x0000BA00
+#define AEMNET_EGT_2224_2_BASE_ID          0x0000BB00
 
 // 29 bit ID, 500kbs, rate 20 hz, endian big, DLC 8
 // UNIT1 ID: 0x0000BA00 .. 0x0000BA01
 // UNIT2 ID: 0x0000BB00 .. 0x0000BB01
-struct EgtData
+struct Egt2224Data
 {
     beint16_t Egt[4]; // 0.1 C/bit, -3276.8 to 3276.7 C
 } __attribute__((packed));
 
-static_assert(sizeof(EgtData) == 8);
+static_assert(sizeof(Egt2224Data) == 8);
 
 // UNIT1 ID: 0x0000BA02
 // UNIT2 ID: 0x0000BB02
-struct EgtStatus
+struct Egt2224Status
 {
     beuint16_t ColdJunctionTemp; // 0.1 C/bit, -3276.8 to 3276.7 C
     uint8_t BatteryVoltage;      // 0 - 25.5 V
     uint8_t Reserved[5];
 } __attribute__((packed));
 
-static_assert(sizeof(EgtStatus) == 8);
+static_assert(sizeof(Egt2224Status) == 8);
 
 } //namespace aemnet
 
-void SendAemNetEGTFormat(Configuration* cfg, uint8_t ch)
+
+void SendAemNetEGT0305Format(Configuration* cfg)
 {
-    if (ch != 0)
-        return; // Use a first channel for config, as AEMNet sends up to 4 EGT channels in one message
+    for (uint8_t ch = 0; ch < EGT_CHANNELS; ch++)
+    {
+        if (!cfg->egt[ch].ExtraCanChannelEnabled)
+            return;
 
+        auto id = AEMNET_EGT_0305_BASE_ID + cfg->egt[ch].ExtraCanIdOffset;
+        CanTxTyped<aemnet::Egt0305Data> frame(id, true);
+        frame.get().TemperatureC = getEgtDrivers()[ch].temperature;
+    }
+}
+
+void SendAemNetEGT2224Format(Configuration* cfg)
+{
     uint32_t id;
-    switch (cfg->egt[ch].ExtraCanIdOffset)
+    switch (cfg->egt[0].ExtraCanIdOffset)
     {
         case 0:
-            id = AEMNET_EGT1_BASE_ID;
+            id = AEMNET_EGT_2224_1_BASE_ID;
             break;
         case 1:
-            id = AEMNET_EGT2_BASE_ID;
+            id = AEMNET_EGT_2224_2_BASE_ID;
             break;
 
         default:
             return; // Invalid channel for AEMNet EGT
     }
 
-    CanTxTyped<aemnet::EgtData> frame(id, true);
+    CanTxTyped<aemnet::Egt2224Data> frame(id, true);
     for (uint8_t i = 0; i < EGT_CHANNELS; i++)
     {
+        if (!cfg->egt[i].ExtraCanChannelEnabled)
+            continue;
+
         frame.get().Egt[i] = getEgtDrivers()[i].temperature * 10;
     }
 }

firmware/can/can_aemnet.h

@@ -6,4 +6,6 @@
 #include "port.h"
 
 void SendAemNetUEGOFormat(Configuration* cfg, uint8_t ch);
-void SendAemNetEGTFormat(Configuration* cfg, uint8_t ch);
+
+void SendAemNetEGT0305Format(Configuration* cfg);
+void SendAemNetEGT2224Format(Configuration* cfg);

firmware/can/can_ecumaster.cpp

@@ -127,21 +127,21 @@ static_assert(sizeof(EgtData) == 8);
 } //namespace ecumaster
 
 
-void SendEcuMasterEgtFormat(Configuration* configuration, uint8_t ch)
+void SendEcuMasterEgtFormat(Configuration* configuration)
 {
-    if (ch != 0)
-        return; // EcuMaster protocol sends 1-4 channels in one message
-
     auto base = ECUMASTER_CLASSIC_EGT_BASE_ID;
-    if (configuration->egt[ch].ExtraCanProtocol == CanProtocol::EcuMasterBlack)
+    if (configuration->egt[0].ExtraCanProtocol == CanEgtProtocol::EcuMasterBlack)
         base = ECUMASTER_BLACK_EGT_BASE_ID;
 
-    auto id = base + configuration->egt[ch].ExtraCanIdOffset;
+    auto id = base + configuration->egt[0].ExtraCanIdOffset;
 
     CanTxTyped<ecumaster::EgtData> frame(id, true);
 
     for (uint8_t i = 0; i < EGT_CHANNELS; i++)
     {
+        if (!configuration->egt[i].ExtraCanChannelEnabled)
+            continue;
+
         frame.get().Egt[i] = getEgtDrivers()[i].temperature;
     }
 }

firmware/can/can_ecumaster.h

@@ -7,4 +7,4 @@
 
 void SendEcuMasterAfrFormat(Configuration* configuration, uint8_t ch);
 
-void SendEcuMasterEgtFormat(Configuration* configuration, uint8_t ch);
+void SendEcuMasterEgtFormat(Configuration* configuration);

firmware/can/can_emtron.cpp

@@ -175,36 +175,47 @@ uint16_t get_temperature(float raw_temp)
 
 } //namespace emtron
 
-void SendEmtronEgtFormat(Configuration* configuration, uint8_t ch)
+void SendEmtronEgtFormat(Configuration* configuration)
 {
-    if (ch != 0)
-        return;
-
-    auto id = EMTRON_ETC4_BASE_ID + configuration->egt[ch].ExtraCanIdOffset;
+    auto id = EMTRON_ETC4_BASE_ID + configuration->egt[0].ExtraCanIdOffset;
     CanTxTyped<emtron::ETC4Data> frame(id, true);
 
     const auto egtDrivers = getEgtDrivers();
-    uint16_t temp = emtron::get_temperature(egtDrivers[0].temperature);
+    
+    uint16_t temp;
 
-    frame->EgtData[0] = (temp >> 4) & 0xFF; // High 8 bits
-    frame->EgtData[1] = (temp & 0xF) << 4; // Low 4 bits in high nibble
+    if (configuration->egt[0].ExtraCanChannelEnabled)
+    {
+        uint16_t temp = emtron::get_temperature(egtDrivers[0].temperature);
+        frame->EgtData[0] = (temp >> 4) & 0xFF; // High 8 bits
+        frame->EgtData[1] = (temp & 0xF) << 4; // Low 4 bits in high nibble
+    }
 
     #if (EGT_CHANNELS > 1)
+    if (configuration->egt[1].ExtraCanChannelEnabled)
+    {
         temp = emtron::get_temperature(egtDrivers[1].temperature);
         frame->EgtData[1] |= (temp >> 8) & 0xF; // High 4 bits in low nibble
         frame->EgtData[2] = temp & 0xFF; // Low 8 bits
+    }
     #endif
 
     #if (EGT_CHANNELS > 2)
+    if (configuration->egt[2].ExtraCanChannelEnabled)
+    {
         temp = emtron::get_temperature(egtDrivers[2].temperature);
         frame->EgtData[3] |= (temp >> 8) & 0xF; // High 4 bits in low nibble
         frame->EgtData[4] = temp & 0xFF; // Low 8 bits
+    }
     #endif
 
     #if (EGT_CHANNELS > 3)
+    if (configuration->egt[3].ExtraCanChannelEnabled)
+    {
         temp = emtron::get_temperature(egtDrivers[3].temperature);
         frame->EgtData[4] |= (temp >> 8) & 0xF; // High 4 bits in low nibble
         frame->EgtData[5] = temp & 0xFF; // Low 8 bits
+    }
     #endif
 
     frame->ColdJunctionTemp = egtDrivers[0].coldJunctionTemperature;

firmware/can/can_emtron.h

@@ -6,4 +6,4 @@
 #include "port.h"
 
 void SendEmtronAfrFormat(Configuration* configuration, uint8_t ch);
-void SendEmtronEgtFormat(Configuration* configuration, uint8_t ch);
+void SendEmtronEgtFormat(Configuration* configuration);