[FWT-20] Out of the CR(H)IB and into the fire

CMakeLists.txt

@@ -11,9 +11,9 @@ if(EVT_CORE_LOG_ENABLE)
 endif()
 
 # Handle selection of the target device
-option(TARGET_DEV "Target device" "STM32F334x8")
+option(TARGET_DEV "Target device" "STM32F446xx")
 if(NOT TARGET_DEV)
-    set(TARGET_DEV "STM32F334x8")
+    set(TARGET_DEV "STM32F446xx")
 endif()
 
 if(TARGET_DEV STREQUAL "STM32F302x8")
@@ -22,6 +22,9 @@ if(TARGET_DEV STREQUAL "STM32F302x8")
 elseif(TARGET_DEV STREQUAL "STM32F334x8")
     add_compile_definitions(STM32F334x8)
     add_compile_definitions(STM32F3xx)
+elseif(TARGET_DEV STREQUAL "STM32F446xx")
+    add_compile_definitions(STM32F446xx)
+    add_compile_definitions(STM32F4xx)
 else()
     message(FATAL_ERROR "The target device is not supported")
 endif()
@@ -57,12 +60,17 @@ project(${BOARD_LIB_NAME}
         LANGUAGES CXX C
         )
 
-add_library(${PROJECT_NAME} STATIC)
+add_library(${PROJECT_NAME} STATIC
+        include/dev/ADS8689IPWR.hpp
+        include/dev/RedundantADC.hpp
+        include/HIB.hpp
+)
 
 # Add sources
 target_sources(${PROJECT_NAME} PRIVATE
         src/HIB.cpp
         src/dev/RedundantADC.cpp
+        src/dev/ADS8689IPWR.cpp
         )
 
 ###############################################################################

Changelog.md

@@ -11,3 +11,9 @@ Contains notable changes there were added, fixed, or removed in each release.
 * Build Board source as a library
 * Template to build arbitrary number of targets
 * Auto-generating documentation template
+
+## 0.2.0
+
+### Changes
+
+* ADS8689IPWR driver

include/HIB.hpp

@@ -1,13 +1,66 @@
 #pragma once
+#include <core/io/UART.hpp>
+#include <dev/ADS8689IPWR.hpp>
+#include <dev/RedundantADC.hpp>
+#include <sys/types.h>
 
 namespace HIB {
 
+/**
+ * Counts that when exceeded throw an error to the VC
+ */
+#define COMPARISON_ERROR_COUNT 1
+#define PRECISION_MARGIN_ERROR_COUNT 3
+#define ACCEPTABLE_MARGIN_ERROR_COUNT 5
+
+constexpr size_t payloadLength = 5;
+
 /**
  * HIB header file
  */
 class HIB {
 public:
+    HIB(DEV::RedundantADC& throttle, DEV::RedundantADC& brake);
+
+    void process();
+
+    uint8_t payload[payloadLength];
+    uint32_t throttleVoltage = 0;
+    uint32_t brakeVoltage = 0;
+
+    // Counters for throttle errors
+    uint64_t acceptableThrottleMarginErrors = 0;
+    uint64_t precisionThrottleMarginErrors = 0;
+    uint64_t comparisonThrottleErrors = 0;
+
+    // Counters for brake errors
+    uint64_t acceptableBrakeMarginErrors = 0;
+    uint64_t precisionBrakeMarginErrors = 0;
+    uint64_t comparisonBrakeErrors = 0;
+
 private:
+    void readThrottleVoltage();
+
+    void readBrakeVoltage();
+
+    DEV::RedundantADC& throttle;
+    DEV::RedundantADC& brake;
+
+    /**
+     * Payload for CAN transmission.
+     * Byte 0: MSB for Throttle Voltage
+     * Byte 1: LSB for Throttle Voltage
+     * Byte 2: MSB for Brake Voltage
+     * Byte 3: LSB for Brake Voltage
+     * Byte 4: Error Byte for triggering a shutdown
+     * Byte 4 layout: X X X X X X X X
+     *                7 6 5 4 3 2 1 0
+     *                            ^ ^
+     *                            | \
+     *           ________________/   \__________________
+     *           Brake Error Bit      Throttle Error Bit
+     */
+    uint8_t data[payloadLength];
 };
 
 }// namespace HIB

include/dev/ADS8689IPWR.hpp

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <core/io/GPIO.hpp>
+#include <core/io/SPI.hpp>
+
+#define RANGE_SEL_REG 0x14 // R/W Range selection register  ----
+#define TWELVE_VOLT_SCALER 0b1000
+#define HALF_WORD_WRITE 0b11010000
+#define EMPTY_BYTE 0b00000000
+#define NOP {EMPTY_BYTE, EMPTY_BYTE, EMPTY_BYTE, EMPTY_BYTE}
+#define VOLTAGE_MAX 12288
+
+namespace io   = core::io;
+
+namespace HIB::DEV {
+
+class ADS8689IPWR {
+public:
+    /**
+     * Creates a ADS8689IPWR object while configuring the range selector.
+     *
+     * @param spi SPI reference to interface with the ADC
+     * @param deviceNumber The number of the cs pin that the device is
+     */
+    ADS8689IPWR(io::SPI& spi, uint8_t deviceNumber);
+
+    /**
+     * Reads out the voltage from the ADC with a blank command through SPI
+     *
+     * @param voltage reference to variable that is storing voltage
+     * @return the status of whether the transaction was successful
+     */
+    uint16_t read() const;
+private:
+    io::SPI& spi;
+    const uint8_t deviceNumber;
+};
+
+}// namespace HIB::DEV

include/dev/RedundantADC.hpp

@@ -1,8 +1,8 @@
 #pragma once
 
-#include <EVT/io/ADC.hpp>
+#include <dev/ADS8689IPWR.hpp>
 
-namespace IO = EVT::core::IO;
+namespace io = core::io;
 
 namespace HIB::DEV {
 
@@ -33,27 +33,25 @@ class RedundantADC {
      * @param[in] adc1 The second ADC instance.
      * @param[in] adc2 The third ADC instance.
      */
-    RedundantADC(IO::ADC& adc0, IO::ADC& adc1, IO::ADC& adc2);
+    RedundantADC(ADS8689IPWR& adc0, ADS8689IPWR& adc1, ADS8689IPWR& adc2);
 
     /**
      * Read voltage readings from the ADCs and check for redundancy.
      *
      * This function reads values from three ADCs and checks for redundancy.
      *
      * @param[out] return_val Reference to the variable to store the value read from the ADCs
-     * @param[in] val2 Reference to the variable to store the value read from the second ADC.
-     * @param[in] val3 Reference to the variable to store the value read from the third ADC.
      * @return RedundantADC::Status The status of the processing.
      */
-    RedundantADC::Status readVoltage(uint32_t& return_val);
+    RedundantADC::Status read(uint32_t& return_val);
 
 private:
     /** Reference to the first ADC. */
-    IO::ADC& adc0;
+    ADS8689IPWR& adc0;
     /** Reference to the second ADC. */
-    IO::ADC& adc1;
+    ADS8689IPWR& adc1;
     /** Reference to the third ADC. */
-    IO::ADC& adc2;
+    ADS8689IPWR& adc2;
 };
 
 }// namespace HIB::DEV

src/HIB.cpp

@@ -1,5 +1,98 @@
 #include <HIB.hpp>
+#include <dev/RedundantADC.hpp>
 
 namespace HIB {
 
-}// namespace HIB
+HIB::HIB(DEV::RedundantADC& throttle, DEV::RedundantADC& brake)
+    : throttle(throttle), brake(brake) {
+    // Initialize payload to 0's
+    for (uint8_t i = 0; i < payloadLength; i++) {
+        payload[i] = 0;
+    }
+}
+
+// Reads the 2 sets of 3 ADCs and processes their errors while packaging them for CAN
+void HIB::process() {
+    // Read in the voltages from the throttle
+    readThrottleVoltage();
+    readBrakeVoltage();
+
+    if (throttleVoltage < 300) {
+        throttleVoltage = 0;
+    }
+
+    if (brakeVoltage < 300) {
+        brakeVoltage = 0;
+    }
+
+    payload[0] = static_cast<uint8_t>(throttleVoltage >> 8 & 0xFF);
+    payload[1] = static_cast<uint8_t>(throttleVoltage & 0xFF);
+    payload[2] = static_cast<uint8_t>(brakeVoltage >> 8 & 0xFF);
+    payload[3] = static_cast<uint8_t>(brakeVoltage & 0xFF);
+
+    if (acceptableThrottleMarginErrors > ACCEPTABLE_MARGIN_ERROR_COUNT) {
+        acceptableThrottleMarginErrors = ACCEPTABLE_MARGIN_ERROR_COUNT + 1;
+        payload[4] |= 0b01;
+    }
+
+    if (acceptableBrakeMarginErrors > ACCEPTABLE_MARGIN_ERROR_COUNT) {
+        acceptableBrakeMarginErrors = ACCEPTABLE_MARGIN_ERROR_COUNT + 1;
+        payload[4] |= 0b10;
+    }
+
+    if (precisionThrottleMarginErrors > PRECISION_MARGIN_ERROR_COUNT) {
+        precisionThrottleMarginErrors = PRECISION_MARGIN_ERROR_COUNT + 1;
+        payload[4] |= 0b01;
+    }
+
+    if (precisionBrakeMarginErrors > PRECISION_MARGIN_ERROR_COUNT) {
+        precisionBrakeMarginErrors = PRECISION_MARGIN_ERROR_COUNT + 1;
+        payload[4] |= 0b10;
+    }
+
+    if (comparisonThrottleErrors > COMPARISON_ERROR_COUNT) {
+        comparisonThrottleErrors = COMPARISON_ERROR_COUNT + 1;
+        payload[4] |= 0b01;
+    }
+
+    if (comparisonBrakeErrors > COMPARISON_ERROR_COUNT) {
+        comparisonBrakeErrors = COMPARISON_ERROR_COUNT + 1;
+        payload[4] |= 0b10;
+    }
+}
+
+void HIB::readThrottleVoltage() {
+    const DEV::RedundantADC::Status status = throttle.read(throttleVoltage); // gets the errors and voltage from the ADC cluster
+
+    // Increment the status of each error if it is received
+    if (status == DEV::RedundantADC::Status::ACCEPTABLE_MARGIN_EXCEEDED) {
+        acceptableThrottleMarginErrors++;
+    }
+
+    if (status == DEV::RedundantADC::Status::PRECISION_MARGIN_EXCEEDED) {
+        precisionThrottleMarginErrors++;
+    }
+
+    if (status == DEV::RedundantADC::Status::COMPARISON_ERROR) {
+        comparisonThrottleErrors++;
+    }
+}
+
+void HIB::readBrakeVoltage() {
+    const DEV::RedundantADC::Status status = brake.read(brakeVoltage); // gets the errors and voltage from the ADC cluster
+
+    // Increment the status of each error if it is received
+    if (status == DEV::RedundantADC::Status::ACCEPTABLE_MARGIN_EXCEEDED) {
+        acceptableBrakeMarginErrors++;
+    }
+
+    if (status == DEV::RedundantADC::Status::PRECISION_MARGIN_EXCEEDED) {
+        precisionBrakeMarginErrors++;
+    }
+
+    if (status == DEV::RedundantADC::Status::COMPARISON_ERROR) {
+        comparisonBrakeErrors++;
+    }
+}
+
+}

src/dev/ADS8689IPWR.cpp

@@ -0,0 +1,33 @@
+#include <core/utils/log.hpp>
+#include <dev/ADS8689IPWR.hpp>
+
+namespace HIB::DEV {
+
+ADS8689IPWR::ADS8689IPWR(io::SPI& spi, const uint8_t deviceNumber) : spi(spi), deviceNumber(deviceNumber) {
+    uint8_t message[4] = {HALF_WORD_WRITE, RANGE_SEL_REG, EMPTY_BYTE, TWELVE_VOLT_SCALER};
+    spi.startTransmission(deviceNumber);
+    spi.write(message, 4);
+    spi.endTransmission(deviceNumber);
+
+    // Begin the conversion with a NOP command
+    uint8_t nop[4] = NOP;
+    spi.startTransmission(deviceNumber);
+    spi.write(nop, 4);
+    spi.endTransmission(deviceNumber);
+}
+
+uint16_t ADS8689IPWR::read() const {
+    uint8_t bytes[4];
+    spi.startTransmission(deviceNumber);
+    spi.read(bytes, 4);
+    spi.endTransmission(deviceNumber);
+
+    // First byte is MSB
+    uint32_t voltage = (bytes[0] << 8) + bytes[1];
+
+    // Normalize the received info (divide by uint16_t(MAX)) and scale accordingly
+    voltage = voltage * VOLTAGE_MAX / UINT16_MAX;
+    return voltage;
+}
+
+}