wip cover UI

Author: ClemensElflein

CMakeLists.txt

@@ -89,6 +89,8 @@ target_sources(${CMAKE_PROJECT_NAME} PRIVATE
         src/drivers/input/gpio_input_driver.cpp
         src/drivers/input/worx_input_driver.cpp
         $<$<CONFIG:Debug>:src/drivers/input/simulated_input_driver.cpp>
+        # YardForce Cover UI Driver
+        src/drivers/ui/YardForceCoverUI/yard_force_cover_ui_driver.cpp
         # Raw driver debug interface
         src/debug/debug_tcp_interface.cpp
         src/debug/debug_udp_interface.cpp

robots/include/yardforce_robot.hpp

@@ -2,6 +2,7 @@
 #define YARDFORCE_ROBOT_HPP
 
 #include <drivers/charger/bq_2576/bq_2576.hpp>
+#include <drivers/ui/YardForceCoverUI/yard_force_cover_ui_driver.hpp>
 
 #include "robot.hpp"
 
@@ -36,6 +37,7 @@ class YardForceRobot : public MowerRobot {
 
  private:
   BQ2576 charger_{};
+  YardForceCoverUIDriver cover_ui_driver_{};
 };
 
 #endif  // YARDFORCE_ROBOT_HPP

robots/src/yardforce_robot.cpp

@@ -6,6 +6,7 @@ void YardForceRobot::InitPlatform() {
   InitMotors();
   charger_.setI2C(&I2CD1);
   power_service.SetDriver(&charger_);
+  cover_ui_driver_.Start(&UARTD7);
 }
 
 bool YardForceRobot::IsHardwareSupported() {

src/drivers/ui/YardForceCoverUI/COBS.h

@@ -0,0 +1,107 @@
+//
+// Copyright (c) 2011 Christopher Baker <https://christopherbaker.net>
+// Copyright (c) 2011 Jacques Fortier <https://github.com/jacquesf/COBS-Consistent-Overhead-Byte-Stuffing>
+//
+// SPDX-License-Identifier: MIT
+//
+
+#ifndef SRC_COBS_H
+#define SRC_COBS_H
+
+/// \brief A Consistent Overhead Byte Stuffing (COBS) Encoder.
+///
+/// Consistent Overhead Byte Stuffing (COBS) is an encoding that removes all 0
+/// bytes from arbitrary binary data. The encoded data consists only of bytes
+/// with values from 0x01 to 0xFF. This is useful for preparing data for
+/// transmission over a serial link (RS-232 or RS-485 for example), as the 0
+/// byte can be used to unambiguously indicate packet boundaries. COBS also has
+/// the advantage of adding very little overhead (at least 1 byte, plus up to an
+/// additional byte per 254 bytes of data). For messages smaller than 254 bytes,
+/// the overhead is constant.
+///
+/// \sa http://conferences.sigcomm.org/sigcomm/1997/papers/p062.pdf
+/// \sa http://en.wikipedia.org/wiki/Consistent_Overhead_Byte_Stuffing
+/// \sa https://github.com/jacquesf/COBS-Consistent-Overhead-Byte-Stuffing
+/// \sa http://www.jacquesf.com/2011/03/consistent-overhead-byte-stuffing
+class COBS {
+ public:
+  /// \brief Encode a byte buffer with the COBS encoder.
+  /// \param buffer A pointer to the unencoded buffer to encode.
+  /// \param size  The number of bytes in the \p buffer.
+  /// \param encodedBuffer The buffer for the encoded bytes.
+  /// \returns The number of bytes written to the \p encodedBuffer.
+  /// \warning The encodedBuffer must have at least getEncodedBufferSize()
+  ///          allocated.
+  static size_t encode(const uint8_t* buffer, size_t size, uint8_t* encodedBuffer) {
+    size_t read_index = 0;
+    size_t write_index = 1;
+    size_t code_index = 0;
+    uint8_t code = 1;
+
+    while (read_index < size) {
+      if (buffer[read_index] == 0) {
+        encodedBuffer[code_index] = code;
+        code = 1;
+        code_index = write_index++;
+        read_index++;
+      } else {
+        encodedBuffer[write_index++] = buffer[read_index++];
+        code++;
+
+        if (code == 0xFF) {
+          encodedBuffer[code_index] = code;
+          code = 1;
+          code_index = write_index++;
+        }
+      }
+    }
+
+    encodedBuffer[code_index] = code;
+
+    return write_index;
+  }
+
+  /// \brief Decode a COBS-encoded buffer.
+  /// \param encodedBuffer A pointer to the \p encodedBuffer to decode.
+  /// \param size The number of bytes in the \p encodedBuffer.
+  /// \param decodedBuffer The target buffer for the decoded bytes.
+  /// \returns The number of bytes written to the \p decodedBuffer.
+  /// \warning decodedBuffer must have a minimum capacity of size.
+  static size_t decode(const uint8_t* encodedBuffer, size_t size, uint8_t* decodedBuffer) {
+    if (size == 0) return 0;
+
+    size_t read_index = 0;
+    size_t write_index = 0;
+    uint8_t code = 0;
+    uint8_t i = 0;
+
+    while (read_index < size) {
+      code = encodedBuffer[read_index];
+
+      if (read_index + code > size && code != 1) {
+        return 0;
+      }
+
+      read_index++;
+
+      for (i = 1; i < code; i++) {
+        decodedBuffer[write_index++] = encodedBuffer[read_index++];
+      }
+
+      if (code != 0xFF && read_index != size) {
+        decodedBuffer[write_index++] = '\0';
+      }
+    }
+
+    return write_index;
+  }
+
+  /// \brief Get the maximum encoded buffer size for an unencoded buffer size.
+  /// \param unencodedBufferSize The size of the buffer to be encoded.
+  /// \returns the maximum size of the required encoded buffer.
+  static size_t getEncodedBufferSize(size_t unencodedBufferSize) {
+    return unencodedBufferSize + unencodedBufferSize / 254 + 1;
+  }
+};
+
+#endif

src/drivers/ui/YardForceCoverUI/ui_board.h

@@ -0,0 +1,165 @@
+#ifndef _UI_DATATYPES_H_
+#define _UI_DATATYPES_H_
+
+#include <stdint.h>
+
+#include <cmath>
+// Protocol Header Info
+enum TYPE {
+  Get_Version = 0xB0,
+  Set_Buzzer = 0xB1,
+  Set_LEDs = 0xB2,
+  Get_Button = 0xB3,
+  Get_Emergency = 0xB4,  // Stock-CoverUI
+  Get_Rain = 0xB5,       // Stock-CoverUI
+  Get_Subscribe = 0xB6
+};
+
+// Function definitions for the 18 LEDS
+enum LED_id {
+  LED_CHARGING = 0,
+  LED_BATTERY_LOW = 1,
+  LED_POOR_GPS = 2,
+  LED_MOWER_LIFTED = 3,
+  LED5 = 4,
+  LED6 = 5,
+  LED7 = 6,
+  LED8 = 7,
+  LED9 = 8,
+  LED10 = 9,
+  LED11 = 10,
+  LED_LOCK = 11,
+  LED_S2 = 12,
+  LED_S1 = 13,
+  LED15 = 14,
+  LED16 = 15,
+  LED17 = 16,
+  LED18 = 17
+};
+
+enum LED_state { LED_off = 0b000, LED_blink_slow = 0b101, LED_blink_fast = 0b110, LED_on = 0b111 };
+
+// Stock-CoverUI (same bitmask as in ll_status.emergency_bitmask of datatypes.h)
+enum Emergency_state {
+  Emergency_latch = 0b00001,
+  Emergency_stop1 = 0b00010,
+  Emergency_stop2 = 0b00100,
+  Emergency_lift1 = 0b01000,
+  Emergency_lift2 = 0b10000
+};
+
+enum Topic_state {
+  Topic_set_leds = 1 << 0,
+  Topic_set_ll_status = 1 << 1,
+  Topic_set_hl_state = 1 << 2,
+};
+
+#pragma pack(push, 1)
+struct msg_get_version {
+  uint8_t type;      // command type
+  uint8_t reserved;  // padding
+  uint16_t version;
+  uint16_t crc;  // CRC 16
+} __attribute__((packed));
+#pragma pack(pop)
+
+#pragma pack(push, 1)
+struct msg_set_buzzer {
+  uint8_t type;      // command type
+  uint8_t repeat;    // Repeat X times
+  uint8_t on_time;   // Signal on time
+  uint8_t off_time;  // Signal off time
+  uint16_t crc;      // CRC 16
+} __attribute__((packed));
+#pragma pack(pop)
+
+/**
+ * @brief Use this to update the LED matrix
+ * Each LED gets three bits with the following meaning:
+ * 0b000 = Off
+ * 0b001 = reserved for future use
+ * 0b010 = reserved for future use
+ * 0b011 = reserved for future use
+ * 0b100 = reserved for future use
+ * 0b101 = On slow blink
+ * 0b110 = On fast blink
+ * 0b111 = On
+ */
+#pragma pack(push, 1)
+struct msg_set_leds {
+  uint8_t type;      // command type
+  uint8_t reserved;  // padding
+  uint64_t leds;
+  uint16_t crc;  // CRC 16
+} __attribute__((packed));
+#pragma pack(pop)
+
+#pragma pack(push, 1)
+struct msg_event_button {
+  uint8_t type;  // command type
+  uint16_t button_id;
+  uint8_t press_duration;
+  uint16_t crc;  // CRC 16
+} __attribute__((packed));
+#pragma pack(pop)
+
+// Stock-CoverUI
+#pragma pack(push, 1)
+struct msg_event_rain {
+  uint8_t type;      // Command type
+  uint8_t reserved;  // Padding
+  uint32_t value;
+  uint32_t threshold;  // If value < threshold then it rains. Why a threshold? Cause there might be a future option to
+                       // make it configurable on Stock-CoverUI
+  uint16_t crc;        // CRC 16
+} __attribute__((packed));
+#pragma pack(pop)
+
+// Stock-CoverUI
+#pragma pack(push, 1)
+struct msg_event_emergency {
+  uint8_t type;   // Command type
+  uint8_t state;  // Same as in ll_status.emergency_bitmask of datatypes.h
+  uint16_t crc;   // CRC 16
+} __attribute__((packed));
+#pragma pack(pop)
+
+// Cover UI might subscribe in what data it's interested to receive
+
+#pragma pack(push, 1)
+struct msg_event_subscribe {
+  uint8_t type;           // Command type
+  uint8_t topic_bitmask;  // Bitmask of data subscription(s), see Topic_state
+  uint16_t interval;      // Interval (ms) how often to send topic(s)
+  uint16_t crc;           // CRC 16
+} __attribute__((packed));
+#pragma pack(pop)
+
+inline void setLed(struct msg_set_leds &msg, int led, uint8_t state) {
+  // mask the current led state
+  uint64_t mask = ~(((uint64_t)0b111) << (led * 3));
+  msg.leds &= mask;
+  msg.leds |= ((uint64_t)(state & 0b111)) << (led * 3);
+}
+
+inline void setBars7(struct msg_set_leds &msg, double value) {
+  int on_leds = round(value * 7.0);
+  for (int i = 0; i < 7; i++) {
+    setLed(msg, LED11 - i, i < on_leds ? LED_on : LED_off);
+  }
+}
+
+inline void setBars4(struct msg_set_leds &msg, double value) {
+  if (value < 0) {
+    for (int i = 0; i < 4; i++) {
+      setLed(msg, i + LED15, LED_blink_fast);
+    }
+  } else {
+    int on_leds = round(value * 4.0);
+    for (int i = 0; i < 4; i++) {
+      setLed(msg, LED18 - i, i < on_leds ? LED_on : LED_off);
+    }
+  }
+}
+
+#endif  // _UI_DATATYPES_H_