changed hal linux uart baudrate and bits per word to enums

2022-03-24 15:44:32 +01:00 · 2022-03-24 15:44:32 +01:00 · c60aa68d00
commit c60aa68d00
parent f441505476
4 changed files with 83 additions and 62 deletions
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -22,6 +22,8 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/572
 - HAL Devicehandlers: Periodic printout is run-time configurable now
 - `oneShotAction` flag in the `TestTask` class is not static anymore
+- HAL Linux Uart: Baudrate and bits per word are enums now, avoiding misconfigurations
+  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/585

 ## Removed

@ -35,8 +37,6 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 - Dedicated Version class and constant `fsfw::FSFW_VERSION` containing version information
  inside `fsfw/version.h`
  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/559
- Additional baudrates for Linux UART HAL
-  PR: https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/581

 # [v4.0.0]

--- a/hal/src/fsfw_hal/linux/uart/UartComIF.cpp
+++ b/hal/src/fsfw_hal/linux/uart/UartComIF.cpp
@ -148,16 +148,16 @@ void UartComIF::setDatasizeOptions(struct termios* options, UartCookie* uartCook
  /* Clear size bits */
  options->c_cflag &= ~CSIZE;
  switch (uartCookie->getBitsPerWord()) {
-    case 5:
+    case BitsPerWord::BITS_5:
      options->c_cflag |= CS5;
      break;
-    case 6:
+    case BitsPerWord::BITS_6:
      options->c_cflag |= CS6;
      break;
-    case 7:
+    case BitsPerWord::BITS_7:
      options->c_cflag |= CS7;
      break;
-    case 8:
+    case BitsPerWord::BITS_8:
      options->c_cflag |= CS8;
      break;
    default:
@ -193,123 +193,123 @@ void UartComIF::setFixedOptions(struct termios* options) {

 void UartComIF::configureBaudrate(struct termios* options, UartCookie* uartCookie) {
  switch (uartCookie->getBaudrate()) {
-    case 50:
+    case UartBaudRate::RATE_50:
      cfsetispeed(options, B50);
      cfsetospeed(options, B50);
      break;
-    case 75:
+    case UartBaudRate::RATE_75:
      cfsetispeed(options, B75);
      cfsetospeed(options, B75);
      break;
-    case 110:
+    case UartBaudRate::RATE_110:
      cfsetispeed(options, B110);
      cfsetospeed(options, B110);
      break;
-    case 134:
+    case UartBaudRate::RATE_134:
      cfsetispeed(options, B134);
      cfsetospeed(options, B134);
      break;
-    case 150:
+    case UartBaudRate::RATE_150:
      cfsetispeed(options, B150);
      cfsetospeed(options, B150);
      break;
-    case 200:
+    case UartBaudRate::RATE_200:
      cfsetispeed(options, B200);
      cfsetospeed(options, B200);
      break;
-    case 300:
+    case UartBaudRate::RATE_300:
      cfsetispeed(options, B300);
      cfsetospeed(options, B300);
      break;
-    case 600:
+    case UartBaudRate::RATE_600:
      cfsetispeed(options, B600);
      cfsetospeed(options, B600);
      break;
-    case 1200:
+    case UartBaudRate::RATE_1200:
      cfsetispeed(options, B1200);
      cfsetospeed(options, B1200);
      break;
-    case 1800:
+    case UartBaudRate::RATE_1800:
      cfsetispeed(options, B1800);
      cfsetospeed(options, B1800);
      break;
-    case 2400:
+    case UartBaudRate::RATE_2400:
      cfsetispeed(options, B2400);
      cfsetospeed(options, B2400);
      break;
-    case 4800:
+    case UartBaudRate::RATE_4800:
      cfsetispeed(options, B4800);
      cfsetospeed(options, B4800);
      break;
-    case 9600:
+    case UartBaudRate::RATE_9600:
      cfsetispeed(options, B9600);
      cfsetospeed(options, B9600);
      break;
-    case 19200:
+    case UartBaudRate::RATE_19200:
      cfsetispeed(options, B19200);
      cfsetospeed(options, B19200);
      break;
-    case 38400:
+    case UartBaudRate::RATE_38400:
      cfsetispeed(options, B38400);
      cfsetospeed(options, B38400);
      break;
-    case 57600:
+    case UartBaudRate::RATE_57600:
      cfsetispeed(options, B57600);
      cfsetospeed(options, B57600);
      break;
-    case 115200:
+    case UartBaudRate::RATE_115200:
      cfsetispeed(options, B115200);
      cfsetospeed(options, B115200);
      break;
-    case 230400:
+    case UartBaudRate::RATE_230400:
      cfsetispeed(options, B230400);
      cfsetospeed(options, B230400);
      break;
-    case 460800:
+    case UartBaudRate::RATE_460800:
      cfsetispeed(options, B460800);
      cfsetospeed(options, B460800);
      break;
-    case 500000:
+    case UartBaudRate::RATE_500000:
      cfsetispeed(options, B500000);
      cfsetospeed(options, B500000);
      break;
-    case 576000:
+    case UartBaudRate::RATE_576000:
      cfsetispeed(options, B576000);
      cfsetospeed(options, B576000);
      break;
-    case 921600:
+    case UartBaudRate::RATE_921600:
      cfsetispeed(options, B921600);
      cfsetospeed(options, B921600);
      break;
-    case 1000000:
+    case UartBaudRate::RATE_1000000:
      cfsetispeed(options, B1000000);
      cfsetospeed(options, B1000000);
      break;
-    case 1152000:
+    case UartBaudRate::RATE_1152000:
      cfsetispeed(options, B1152000);
      cfsetospeed(options, B1152000);
      break;
-    case 1500000:
+    case UartBaudRate::RATE_1500000:
      cfsetispeed(options, B1500000);
      cfsetospeed(options, B1500000);
      break;
-    case 2000000:
+    case UartBaudRate::RATE_2000000:
      cfsetispeed(options, B2000000);
      cfsetospeed(options, B2000000);
      break;
-    case 2500000:
+    case UartBaudRate::RATE_2500000:
      cfsetispeed(options, B2500000);
      cfsetospeed(options, B2500000);
      break;
-    case 3000000:
+    case UartBaudRate::RATE_3000000:
      cfsetispeed(options, B3000000);
      cfsetospeed(options, B3000000);
      break;
-    case 3500000:
+    case UartBaudRate::RATE_3500000:
      cfsetispeed(options, B3500000);
      cfsetospeed(options, B3500000);
      break;
-    case 4000000:
+    case UartBaudRate::RATE_4000000:
      cfsetispeed(options, B4000000);
      cfsetospeed(options, B4000000);
      break;
--- a/hal/src/fsfw_hal/linux/uart/UartCookie.cpp
+++ b/hal/src/fsfw_hal/linux/uart/UartCookie.cpp
@ -3,7 +3,7 @@
 #include <fsfw/serviceinterface.h>

 UartCookie::UartCookie(object_id_t handlerId, std::string deviceFile, UartModes uartMode,
-                       uint32_t baudrate, size_t maxReplyLen)
+                       UartBaudRate baudrate, size_t maxReplyLen)
    : handlerId(handlerId),
      deviceFile(deviceFile),
      uartMode(uartMode),
@ -12,7 +12,7 @@ UartCookie::UartCookie(object_id_t handlerId, std::string deviceFile, UartModes

 UartCookie::~UartCookie() {}

-uint32_t UartCookie::getBaudrate() const { return baudrate; }
+UartBaudRate UartCookie::getBaudrate() const { return baudrate; }

 size_t UartCookie::getMaxReplyLen() const { return maxReplyLen; }

@ -24,23 +24,11 @@ void UartCookie::setParityEven() { parity = Parity::EVEN; }

 Parity UartCookie::getParity() const { return parity; }

-void UartCookie::setBitsPerWord(uint8_t bitsPerWord_) {
-  switch (bitsPerWord_) {
-    case 5:
-    case 6:
-    case 7:
-    case 8:
-      break;
-    default:
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-      sif::debug << "UartCookie::setBitsPerWord: Invalid bits per word specified" << std::endl;
-#endif
-      return;
-  }
+void UartCookie::setBitsPerWord(BitsPerWord bitsPerWord_) {
  bitsPerWord = bitsPerWord_;
 }

-uint8_t UartCookie::getBitsPerWord() const { return bitsPerWord; }
+BitsPerWord UartCookie::getBitsPerWord() const { return bitsPerWord; }

 StopBits UartCookie::getStopBits() const { return stopBits; }

--- a/hal/src/fsfw_hal/linux/uart/UartCookie.h
+++ b/hal/src/fsfw_hal/linux/uart/UartCookie.h
@ -12,6 +12,41 @@ enum class StopBits { ONE_STOP_BIT, TWO_STOP_BITS };

 enum class UartModes { CANONICAL, NON_CANONICAL };

+enum class BitsPerWord { BITS_5, BITS_6, BITS_7, BITS_8 };
+
+enum class UartBaudRate {
+  RATE_50,
+  RATE_75,
+  RATE_110,
+  RATE_134,
+  RATE_150,
+  RATE_200,
+  RATE_300,
+  RATE_600,
+  RATE_1200,
+  RATE_1800,
+  RATE_2400,
+  RATE_4800,
+  RATE_9600,
+  RATE_19200,
+  RATE_38400,
+  RATE_57600,
+  RATE_115200,
+  RATE_230400,
+  RATE_460800,
+  RATE_500000,
+  RATE_576000,
+  RATE_921600,
+  RATE_1000000,
+  RATE_1152000,
+  RATE_1500000,
+  RATE_2000000,
+  RATE_2500000,
+  RATE_3000000,
+  RATE_3500000,
+  RATE_4000000
+};
+
 /**
 * @brief   Cookie for the UartComIF. There are many options available to configure the UART driver.
 *          The constructor only requests for common options like the baudrate. Other options can
@ -27,25 +62,23 @@ class UartCookie : public CookieIF {
   * @param uartMode      Specify the UART mode. The canonical mode should be used if the
   *                      messages are separated by a delimited character like '\n'. See the
   *                      termios documentation for more information
-   * @param baudrate      The baudrate to use for input and output. Possible Baudrates are: 50,
-   *                      75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800, 9600, B19200,
-   *                      38400, 57600, 115200, 230400, 460800
+   * @param baudrate      The baudrate to use for input and output.
   * @param maxReplyLen   The maximum size an object using this cookie expects
   * @details
   * Default configuration: No parity
   *                        8 databits (number of bits transfered with one uart frame)
   *                        One stop bit
   */
-  UartCookie(object_id_t handlerId, std::string deviceFile, UartModes uartMode, uint32_t baudrate,
-             size_t maxReplyLen);
+  UartCookie(object_id_t handlerId, std::string deviceFile, UartModes uartMode,
+             UartBaudRate baudrate, size_t maxReplyLen);

  virtual ~UartCookie();

-  uint32_t getBaudrate() const;
+  UartBaudRate getBaudrate() const;
  size_t getMaxReplyLen() const;
  std::string getDeviceFile() const;
  Parity getParity() const;
-  uint8_t getBitsPerWord() const;
+  BitsPerWord getBitsPerWord() const;
  StopBits getStopBits() const;
  UartModes getUartMode() const;
  object_id_t getHandlerId() const;
@ -76,7 +109,7 @@ class UartCookie : public CookieIF {
  /**
   * Function two set number of bits per UART frame.
   */
-  void setBitsPerWord(uint8_t bitsPerWord_);
+  void setBitsPerWord(BitsPerWord bitsPerWord_);

  /**
   * Function to specify the number of stopbits.
@ -97,10 +130,10 @@ class UartCookie : public CookieIF {
  std::string deviceFile;
  const UartModes uartMode;
  bool flushInput = false;
-  uint32_t baudrate;
+  UartBaudRate baudrate;
  size_t maxReplyLen = 0;
  Parity parity = Parity::NONE;
-  uint8_t bitsPerWord = 8;
+  BitsPerWord bitsPerWord = BitsPerWord::BITS_8;
  uint8_t readCycles = 1;
  StopBits stopBits = StopBits::ONE_STOP_BIT;
  bool replySizeFixed = true;