Merge pull request #93 from hytech-racing/CASE_testbranch

Case testbranch

ETHERNET.md

@@ -0,0 +1,17 @@
+```mermaid
+flowchart TD
+    ethernet[ethernet port] --> qnethernet[encoded ethernet data packets]
+    qnethernet --> port[protobuf union msgs port]
+    port --> ht_eth[HT ethernet interface]
+    ht_eth --> union_dec[union msgs splitter]
+    union_dec --> int1[interface 1 message buffer]
+    union_dec --> int2[interface 2 message buffer]
+    union_dec --> intN[interface N message buffer]
+```
+
+## explanation
+
+### receiving
+Packets stream over ethernet and hit the ethernet port itself. The ethernet library has an internal queue for the UDP packets received. We know that a specific port id (say 4521) all messages will be a protobuf union msg that can contain only one of the types of messages that we will be sending (config control, TCU status, CASE msgs, etc.) and the union decoder method in the ethernet interface itself will handle this. The ethernet shall be able to receive multiple messages in one loop (of a limited number) and in between iterations of the loop the ethernet driver will hold the un-parsed messages in it's queue. 
+
+The union message decoder will handle parsing of all of the messages in the queue and will be able to determine what message the union pb packet holds. If all messages of a specific type are needed, The message decoder will then add the decoded particular protobuf message struct to the message queue in the respective interface that way if multiple messages of the same type appear in one loop iteration they can all be processed by the underlying system / interface. If the interface just needs the latest version of a message each loop, the decoder will just update the message instance in its respective interface.

README.md

@@ -296,3 +296,63 @@ new MCU code:
     - interface level:
         - hytech_can interface
         - spi interfaces: SPI adcs for load cells, steering input, glv, etc.
+
+
+```mermaid
+flowchart LR
+    subgraph user_inputs[user defined inputs]
+        simulink
+        o_params
+        CAN_data
+        other_protos
+    end
+    subgraph user_interact[user interfaces]
+        fxglv_live
+        mcap
+        database
+        param_server
+        
+    end
+    subgraph user_code_interact[user embedded code interfaces]
+        MCU
+    end
+    subgraph CASE_lib_repo[CASE lib repo gen]
+        CASE_lib
+        params
+        outputs
+    end
+    subgraph HT_params[HT_params repo gen]
+        param_defaults
+        nanopb
+    end
+    simulink[CASE simulink model] --> CASE_lib
+    simulink --> params[CASE defined params.json]
+    simulink --> outputs[CASE_outputs.proto]
+    params --> param_protos[params.proto]
+    params --> param_defaults[config defaults header]
+    param_defaults --> MCU
+    o_params[other params.json] --> param_protos
+    outputs --> h_proto
+    param_protos --> param_server[parameter server]
+    
+    h_proto --> data_acq
+    data_acq --> fxglv_live[live foxglove]
+    data_acq --> mcap[output mcap files]
+    CAN_data[CAN message definitions] --> can_protos[CAN messages in hytech.proto]
+    can_protos --> h_proto
+    mcap --> database[mcap metadata defined database]
+    CASE_lib --> MCU
+    CAN_data --> dbc_h[dbc to C code gen hytech.h for CAN]
+    param_protos --> h_proto[hytech.proto]
+    dbc_h --> MCU
+    h_proto --> nanopb[protobuf msg defs ht_eth.pb.h]
+    nanopb --> MCU
+    other_protos[other msgs.proto]
+    other_protos --> h_proto
+
+    
+
+
+    
+  
+```

include/InterfaceParams.h

@@ -0,0 +1,21 @@
+#ifndef INTERFACEPARAMS
+#define INTERFACEPARAMS
+#include "NativeEthernet.h"
+
+namespace EthParams
+{
+    uint8_t default_MCU_MAC_address[6] = 
+    {0x04, 0xe9, 0xe5, 0x10, 0x1f, 0x22};
+
+    const IPAddress default_MCU_ip(192, 168, 1, 30);
+    const IPAddress default_TCU_ip(192, 168, 1, 68);
+
+    const uint16_t default_protobuf_send_port = 2001;
+    const uint16_t default_protobuf_recv_port = 2000;
+
+    const IPAddress default_netmask(255, 255, 255, 0);
+    const IPAddress default_gateway(192, 168, 0, 1);
+
+    const uint16_t default_buffer_size = 512;
+}
+#endif

include/MCU_rev15_defs.h

@@ -2,6 +2,10 @@
 #define __MCU15_H__
 
 #include "PedalsSystem.h"
+#ifndef TESTING_SYSTEMS
+#include "InterfaceParams.h"
+#endif
+
 
 // pindefs
 const int ADC1_CS = 34;
@@ -26,6 +30,14 @@ const int MCU15_FR_POTS_CHANNEL         = 1;
 const int MCU15_FL_LOADCELL_CHANNEL     = 2;
 const int MCU15_FR_LOADCELL_CHANNEL     = 2;
 
+//MCU teensy analog channels
+const int MCU15_TEENSY_ADC_CHANNELS = 2;
+const int MCU15_THERM_FL = 38;
+const int MCU15_THERM_FR = 41;
+const int MCU15_THERM_FL_CHANNEL = 0;
+const int MCU15_THERM_FR_CHANNEL = 1;
+
+const int DEFAULT_ANALOG_PINS[MCU15_TEENSY_ADC_CHANNELS] = {MCU15_THERM_FL, MCU15_THERM_FR};
 // Time intervals
 const unsigned long SETUP_PRESENT_ACTION_INTERVAL       = 1000;
 const unsigned long BUZZER_ON_INTERVAL                  = 2000;
@@ -87,9 +99,10 @@ const float LOADCELL_RR_OFFSET = 23.761 / LOADCELL_RR_SCALE;
 
 // Steering parameters
 const float PRIMARY_STEERING_SENSE_OFFSET = 0.0; // units are degrees
-const int SECONDARY_STEERING_SENSE_LEFTMOST_BOUND = 812;
-const int SECONDARY_STEERING_SENSE_RIGHTMOST_BOUND = 3179;
-const int SECONDARY_STEERING_SENSE_CENTER = 1970;
-const float STEERING_RANGE_DEGREES = 256.05f;
+const int SECONDARY_STEERING_SENSE_LEFTMOST_BOUND = 785;    // 794    // 812    // 130 deg
+const int SECONDARY_STEERING_SENSE_RIGHTMOST_BOUND = 3087;    // 3075    // 3179    // 134 deg
+const int SECONDARY_STEERING_SENSE_CENTER = 1945;    // 1960    // 1970
+const float STEERING_RANGE_DEGREES = 257.0f;    // 253.0f    // 256.05f   // 134+130-7(slop)
+const float STEERING_IIR_ALPHA = 0.7f;  // shaves off around 1 deg of max discrepancy
 
 #endif /* __MCU15_H__ */

lib/interfaces/include/ParameterInterface.h

@@ -0,0 +1,46 @@
+#ifndef PARAMETERINTERFACE
+#define PARAMETERINTERFACE
+#include "MCUStateMachine.h"
+#include "ht_eth.pb.h"
+#include "default_config.h"
+
+// yes, i know this is a singleton. im prototyping rn.
+// TODO review if I can just give this a pointer to an ethernet port
+class ParameterInterface
+{
+public:
+    ParameterInterface(): current_car_state_(CAR_STATE::STARTUP), params_need_sending_(false), config_(DEFAULT_CONFIG) {}
+
+    void update_car_state(const CAR_STATE& state)
+    {
+        current_car_state_ = state;
+    }
+    void update_config(const config &config)
+    {
+        if(static_cast<int>(current_car_state_) < 5 ){
+            config_ = config;
+        }
+
+    }
+    config get_config()
+    {
+        return config_;
+    }
+    void set_params_need_sending()
+    {
+        params_need_sending_ = true;
+    }
+    void reset_params_need_sending()
+    {
+        params_need_sending_ = false;
+    }
+    bool params_need_sending() { return params_need_sending_; }
+
+private:
+    CAR_STATE current_car_state_;
+    bool params_need_sending_ = false;
+    config config_;
+
+};
+
+#endif

lib/interfaces/include/ProtobufMsgInterface.h

@@ -0,0 +1,78 @@
+#ifndef PROTOBUFMSGINTERFACE
+#define PROTOBUFMSGINTERFACE
+
+#include "ht_eth.pb.h"
+#include "pb_encode.h"
+#include "pb_decode.h"
+#include "pb_common.h"
+#include "ParameterInterface.h"
+#include "circular_buffer.h"
+#include "NativeEthernet.h"
+#include "MCU_rev15_defs.h"
+
+
+struct ETHInterfaces
+{
+    ParameterInterface* param_interface;
+};
+
+using recv_function_t = void (*)(const uint8_t* buffer, size_t packet_size, ETHInterfaces& interfaces);
+
+// this should be usable with arbitrary functions idk something
+void handle_ethernet_socket_receive(EthernetUDP* socket, recv_function_t recv_function, ETHInterfaces& interfaces)
+{
+    int packet_size = socket->parsePacket();
+    if(packet_size > 0)
+    {
+        Serial.println("packet size");
+        Serial.println(packet_size);
+        uint8_t buffer[EthParams::default_buffer_size];
+        size_t read_bytes = socket->read(buffer, sizeof(buffer));
+        socket->read(buffer, UDP_TX_PACKET_MAX_SIZE);
+        recv_function(buffer, read_bytes, interfaces);
+    }
+}
+
+template <typename pb_struct>
+bool handle_ethernet_socket_send_pb(EthernetUDP* socket, const pb_struct& msg, const pb_msgdesc_t* msg_desc)
+{
+    socket->beginPacket(EthParams::default_TCU_ip, EthParams::default_protobuf_send_port);
+
+    uint8_t buffer[EthParams::default_buffer_size];
+    pb_ostream_t stream = pb_ostream_from_buffer(buffer, sizeof(buffer));
+    if (!pb_encode(&stream, msg_desc, &msg)) {
+        // You can handle error more explicitly by looking at stream.errmsg
+        return false;
+    }
+    auto message_length = stream.bytes_written;
+    socket->write(buffer, message_length);
+    socket->endPacket();
+    return true;
+}
+
+// 
+void recv_pb_stream_union_msg(const uint8_t *buffer, size_t packet_size, ETHInterfaces& interfaces)
+{
+    pb_istream_t stream = pb_istream_from_buffer(buffer, packet_size);
+    HT_ETH_Union msg = HT_ETH_Union_init_zero;
+    if (pb_decode(&stream, HT_ETH_Union_fields, &msg))
+    {
+        Serial.println("decoded!");
+
+        switch (msg.which_type_union)
+        {
+        case HT_ETH_Union_config__tag:
+            interfaces.param_interface->update_config(msg.type_union.config_);
+            break;
+        case HT_ETH_Union_get_config__tag:
+            interfaces.param_interface->set_params_need_sending();
+            break;
+        default:
+            break;
+        }
+    }
+}
+
+
+
+#endif

lib/interfaces/include/TelemetryInterface.h

@@ -29,6 +29,8 @@ struct TelemetryInterfaceReadChannels
     int current_channel;
     int current_ref_channel;
     int glv_sense_channel;
+    int therm_fl_channel;
+    int therm_fr_channel;
 };
 
 class TelemetryInterface
@@ -54,6 +56,10 @@ class TelemetryInterface
 
     /* Update CAN messages (main loop) */
     // Interfaces
+    void update_front_thermistors_CAN_msg(
+        const AnalogConversion_s &therm_fl,
+        const AnalogConversion_s &therm_fr
+    );
     void update_pedal_readings_CAN_msg(
         float accel_percent,
         float brake_percent,
@@ -125,6 +131,7 @@ class TelemetryInterface
         const AnalogConversionPacket_s<8> &adc1,
         const AnalogConversionPacket_s<4> &adc2,
         const AnalogConversionPacket_s<4> &adc3,
+        const AnalogConversionPacket_s<2> &mcu_adc,
         const SteeringEncoderConversion_s &encoder,
         InvInt_t *fl,
         InvInt_t *fr,

lib/interfaces/src/TelemetryInterface.cpp

@@ -1,5 +1,4 @@
 #include "TelemetryInterface.h"
-
 /* Update CAN messages */
 // Main loop
 // MCP3208 returns structure
@@ -58,6 +57,16 @@ void TelemetryInterface::update_analog_readings_CAN_msg(const SteeringEncoderCon
 
     enqueue_CAN<MCU_analog_readings>(mcu_analog_readings_, ID_MCU_ANALOG_READINGS);
 }
+void TelemetryInterface::update_front_thermistors_CAN_msg(const AnalogConversion_s &therm_fl,
+                                                          const AnalogConversion_s &therm_fr) {
+
+    FRONT_THERMISTORS_t front_thermistors_;
+    front_thermistors_.thermistor_motor_fl = therm_fl.raw;
+    front_thermistors_.thermistor_motor_fr = therm_fr.raw;
+
+    enqueue_new_CAN<FRONT_THERMISTORS_t>(&front_thermistors_, &Pack_FRONT_THERMISTORS_hytech);
+}
+
 
 void TelemetryInterface::update_drivetrain_rpms_CAN_msg(InvInt_t* fl, InvInt_t* fr, InvInt_t* rl, InvInt_t* rr)
 {
@@ -233,6 +242,7 @@ void TelemetryInterface::enqeue_controller_CAN_msg(const PIDTVTorqueControllerDa
 void TelemetryInterface::tick(const AnalogConversionPacket_s<8> &adc1,
                               const AnalogConversionPacket_s<4> &adc2,
                               const AnalogConversionPacket_s<4> &adc3,
+                              const AnalogConversionPacket_s<2> &mcu_adc,
                               const SteeringEncoderConversion_s &encoder,
                               InvInt_t* fl,
                               InvInt_t* fr,
@@ -279,5 +289,7 @@ void TelemetryInterface::tick(const AnalogConversionPacket_s<8> &adc1,
                                    adc1.conversions[channels_.current_ref_channel]);
 
     enqeue_controller_CAN_msg(data);
+    update_front_thermistors_CAN_msg(mcu_adc.conversions[channels_.therm_fl_channel],
+                                    mcu_adc.conversions[channels_.therm_fr_channel]);
 
 }