diff --git a/CHANGELOG.md b/CHANGELOG.md index 284ccb6e..f3eb6942 100644 --- 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] diff --git a/hal/src/fsfw_hal/linux/uart/UartComIF.cpp b/hal/src/fsfw_hal/linux/uart/UartComIF.cpp index 3cfa0417..5aa72138 100644 --- 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; diff --git a/hal/src/fsfw_hal/linux/uart/UartCookie.cpp b/hal/src/fsfw_hal/linux/uart/UartCookie.cpp index 63d90766..aa2dd214 100644 --- a/hal/src/fsfw_hal/linux/uart/UartCookie.cpp +++ b/hal/src/fsfw_hal/linux/uart/UartCookie.cpp @@ -3,7 +3,7 @@ #include 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; } diff --git a/hal/src/fsfw_hal/linux/uart/UartCookie.h b/hal/src/fsfw_hal/linux/uart/UartCookie.h index 884665e5..6840b352 100644 --- 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;