Feature STM8 Soft UART support (#58)

vshcryabets · web-flow · commit dbf3f3986a18 · 2026-03-19T23:43:33.000+02:00
* Add Software UART support for STM8 and refactor UART configuration

* Refactor soft UART implementation for STM8: update pin handling and add delay function

* Fix comments
diff --git a/c/l4/README.md b/c/l4/README.md
@@ -16,13 +16,6 @@ Initial value for CRC16 calculation.
 Default: `0xFFFF`.  
 Used as the starting point for CRC16 calculation.
 
-## `V2STYXLIB_STREAMING_MODE`
-Flag bit indicating streaming mode is enabled.  
-Default: `0x01`.  
-When set, UART operates in streaming mode:
-- SOF (Start of Frame) markers are sent before each data frame.
-- The sender does not wait for responses between transmissions.
-
 ## `V2STYXLIB_SOF_MARKER_1`
 First byte of the Start of Frame (SOF) marker sequence.  
 Default: `0x55`.  
@@ -33,10 +26,10 @@ Second byte of the Start of Frame (SOF) marker sequence.
 Default: `0xAA`.  
 Used with `V2STYXLIB_SOF_MARKER_1` to form the two-byte SOF marker sequence: `0x55 0xAA`.
 
-## `V2STYXLIB_SEND_CRC16`
-Flag bit indicating CRC16 is appended to each transmitted frame.  
-Default: `0x02`.  
-When set, a 2-byte CRC16 checksum (using `V2STYXLIB_CRC16_POLY` and 
-`V2STYXLIB_CRC16_INITIAL_VALUE`) is added at the beggining of every frame, 
-before the payload. 
-This extends the frame layout by two bytes and enables end-to-end error detection.
+## `V2STYXLIB_SOFTUART_TX`
+
+Enables the use of Software UART for TX on STM8. This is particularly useful when 
+you need additional ADC channels and want to free up the **UART1_TX / AIN5 / (HS) PD5** pin for analog input.
+
+**Note:** This implementation covers TX only, as software-based RX is generally 
+unstable on this architecture due to timing constraints.
diff --git a/c/l4/include/ChannelUartStm8.h b/c/l4/include/ChannelUartStm8.h
@@ -5,6 +5,14 @@
 
 #include "Channel_c.h"
 
+typedef struct {
+    V2styxlibUartConfig baseConfig;
+#ifdef V2STYXLIB_SOFTUART    
+    GPIO_TypeDef * softUartPort;
+    uint8_t softUartTxPinMask;
+#endif    
+} V2styxlibUartStm8Config;
+
 /**
  * baudRateDivider - is a value that determines the data transmission speed over UART.
  * It is calculated based on the clock frequency (F_CPU) and the desired transmission speed (baud rate).
@@ -14,15 +22,18 @@
  * baudRateDivider = 16000000 / 115200 ≈ 138.89
  * In this case, baudRateDivider will be approximately 139 (rounded to the nearest integer).
  */
-void v2styxlib_uart_setup(uint16_t baudRateDivider);
+void v2styxlib_uart_setup(
+    const V2styxlibUartStm8Config* config,
+    uint16_t baudRateDivider
+    );
 
 /**
  * buffer - is a pointer to the data buffer that contains the data to be sent over UART.
  * length - is the number of bytes to be sent from the buffer.
  * This function is responsible for sending a specified number of bytes from the provided buffer over UART.
  */
 void v2styxlib_uart_send(
-    const V2styxlibUartConfig* config, 
+    const V2styxlibUartStm8Config* config, 
     const uint8_t *buffer, 
     BufferSize_t length
-);
+);
diff --git a/c/l4/include/Channel_c.h b/c/l4/include/Channel_c.h
@@ -14,12 +14,9 @@
     #define V2STYXLIB_CRC16_INITIAL_VALUE 0xFFFF
 #endif
 
-#ifndef V2STYXLIB_STREAMING_MODE
-    #define V2STYXLIB_STREAMING_MODE 0x01
-#endif
-#ifndef V2STYXLIB_SEND_CRC16
-    #define V2STYXLIB_SEND_CRC16 0x02
-#endif
+#define V2STYXLIB_CONFIG_STREAMING_MODE 0x01
+#define V2STYXLIB_CONFIG_SEND_CRC16 0x02
+#define V2STYXLIB_CONFIG_SOFT_UART_TX 0x04
 
 #ifndef V2STYXLIB_SOF_MARKER_1
     #define V2STYXLIB_SOF_MARKER_1 0x55
@@ -31,7 +28,7 @@ extern "C" {
 #endif
 
 typedef struct {
-    uint8_t config;    
+    uint8_t config;
 } V2styxlibUartConfig;
 
 /**
@@ -43,11 +40,15 @@ typedef struct {
  *
  * sendCrc16 - is a boolean flag that indicates whether to calculate and send
  * CRC16 checksum with each message.
+ *
+ * useSoftUartTx - is a boolean flag that indicates whether to use software 
+ * UART for transmission.
  */
 void v2styxlib_uart_configure_proto(
     V2styxlibUartConfig *config,
     bool useStreamingMode,
-    bool sendCrc16
+    bool sendCrc16,
+    bool useSoftUartTx
 );
 
 /**
diff --git a/c/l4/library.json b/c/l4/library.json
@@ -3,6 +3,7 @@
   "version": "1.0.0",
   "build": {
     "srcFilter": [
+      "+<Channel_c.c>",
       "+<ChannelUartStm8.c>"
     ]
   }
diff --git a/c/l4/src/ChannelUartStm8.c b/c/l4/src/ChannelUartStm8.c
@@ -1,46 +1,107 @@
 #include "ChannelUartStm8.h"
 
-#define WAIT_FOR_TXE() while (!(UART1->SR & UART1_SR_TXE))
+#ifdef V2STYXLIB_SOFTUART
+static void v2styxlib_delay_bit() {
+    __asm
+        pushw x         
+        ldw x, #535 ; hardcode for 9600 baud at 16 MHz, adjust if needed
+    00001$:
+        decw x  
+        jrne 00001$  
+        popw x  
+    __endasm;
+}
+#endif
+
+static void v2styxlib_send_byte(
+    const V2styxlibUartStm8Config* config,
+    uint8_t byte) {
+#ifdef V2STYXLIB_SOFTUART
+    if (config->baseConfig.config & V2STYXLIB_CONFIG_SOFT_UART_TX) {
+        // Send byte using software UART
+        // Start bit
+        __asm
+            sim ; disable interrupts (software UART timing)
+        __endasm;
+        config->softUartPort->ODR &= ~config->softUartTxPinMask;
+        v2styxlib_delay_bit();
+
+        // Data bits (LSB first)
+        for (uint8_t i = 0; i < 8; i++) {
+            if (byte & 0x01) {
+                config->softUartPort->ODR |= config->softUartTxPinMask;
+            } else {
+                config->softUartPort->ODR &= ~config->softUartTxPinMask;
+            }
+            byte >>= 1;
+            v2styxlib_delay_bit();
+        }
 
-void v2styxlib_uart_setup(uint16_t baudRateDivider) 
+        // Stop bit
+        config->softUartPort->ODR |= config->softUartTxPinMask;
+        v2styxlib_delay_bit();
+        __asm
+            rim ; enable interrupts (software UART timing)
+        __endasm;
+    } else
+#endif
+    {    
+        while (!(UART1->SR & UART1_SR_TXE)) {
+
+        };
+        UART1->DR = byte;
+    }
+}
+
+void v2styxlib_uart_setup(
+    const V2styxlibUartStm8Config* config,
+    uint16_t baudRateDivider) 
 {
+    UART1->CR1 |= UART1_CR1_UARTD; // Disable UART before configuration
     UART1->BRR2 = ((baudRateDivider >> 8) & 0xF0) | (baudRateDivider & 0x0F);
     UART1->BRR1 = (baudRateDivider >> 4) & 0xFF;
-    UART1->CR2 |= UART1_CR2_TEN;
+#ifdef V2STYXLIB_SOFTUART
+     if (config->baseConfig.config & V2STYXLIB_CONFIG_SOFT_UART_TX) {
+        // Configure the soft UART TX pin as output
+        config->softUartPort->DDR |= config->softUartTxPinMask;
+        config->softUartPort->CR1 |= config->softUartTxPinMask;
+        config->softUartPort->CR2 |= config->softUartTxPinMask;
+        config->softUartPort->ODR |= config->softUartTxPinMask;
+        UART1->CR2 &= ~UART1_CR2_TEN; // Disable hardware UART transmission, we will use software UART for TX
+        UART1->CR2 |= UART1_CR2_REN;
+    } else 
+#endif    
+    {
+        UART1->CR2 |= (UART1_CR2_TEN | UART1_CR2_REN);
+    }
+    UART1->CR1 &= ~UART1_CR1_UARTD; // Enable UART after configuration    
 }
 
 void v2styxlib_uart_send(
-    const V2styxlibUartConfig* config, 
+    const V2styxlibUartStm8Config* config, 
     const uint8_t *buffer, 
     BufferSize_t length)
 {
-    if (config->config & V2STYXLIB_STREAMING_MODE) {
+    if (config->baseConfig.config & V2STYXLIB_CONFIG_STREAMING_MODE) {
         // If streaming mode is enabled, send SOF markers before the data
-        WAIT_FOR_TXE();
-        UART1->DR = V2STYXLIB_SOF_MARKER_1;
-
-        WAIT_FOR_TXE();
-        UART1->DR = V2STYXLIB_SOF_MARKER_2;
+        v2styxlib_send_byte(config, V2STYXLIB_SOF_MARKER_1);
+        v2styxlib_send_byte(config, V2STYXLIB_SOF_MARKER_2);
     }
 
-    WAIT_FOR_TXE();
-    if (config->config & V2STYXLIB_SEND_CRC16) {
+    if (config->baseConfig.config & V2STYXLIB_CONFIG_SEND_CRC16) {
         // send packet size + 2 bytes for CRC16
-        UART1->DR = length + 2;
+        v2styxlib_send_byte(config, length + 2);
         // then CRC16
         uint16_t crc = v2styxlib_crc16_calculate(buffer, length);
-        WAIT_FOR_TXE();
-        UART1->DR = (crc >> 8) & 0xFF; // send high byte of CRC
-        WAIT_FOR_TXE();
-        UART1->DR = crc & 0xFF; // send low byte of CRC
+        v2styxlib_send_byte(config, (crc >> 8) & 0xFF); // send high byte of CRC
+        v2styxlib_send_byte(config, crc & 0xFF); // send low byte of CRC
     } else {
         // send packet size
-        UART1->DR = length;
+        v2styxlib_send_byte(config, length);
     }
 
     // then send the actual data
     for (BufferSize_t i = 0; i < length; i++) {
-        WAIT_FOR_TXE();
-        UART1->DR = buffer[i];
+        v2styxlib_send_byte(config, buffer[i]);
     }
 }
diff --git a/c/l4/src/Channel_c.c b/c/l4/src/Channel_c.c
@@ -23,16 +23,22 @@ uint16_t v2styxlib_crc16_calculate(const uint8_t *data, BufferSize_t length) {
 void v2styxlib_uart_configure_proto(
     V2styxlibUartConfig *config,
     bool useStreamingMode,
-    bool sendCrc16
+    bool sendCrc16,
+    bool useSoftUartTx
 ) {
     if (useStreamingMode) {
-        config->config |= V2STYXLIB_STREAMING_MODE;
+        config->config |= V2STYXLIB_CONFIG_STREAMING_MODE;
     } else {
-        config->config &= ~V2STYXLIB_STREAMING_MODE;
+        config->config &= ~V2STYXLIB_CONFIG_STREAMING_MODE;
     }
     if (sendCrc16) {
-        config->config |= V2STYXLIB_SEND_CRC16;
+        config->config |= V2STYXLIB_CONFIG_SEND_CRC16;
     } else {
-        config->config &= ~V2STYXLIB_SEND_CRC16;
+        config->config &= ~V2STYXLIB_CONFIG_SEND_CRC16;
+    }
+    if (useSoftUartTx) {
+        config->config |= V2STYXLIB_CONFIG_SOFT_UART_TX;
+    } else {
+        config->config &= ~V2STYXLIB_CONFIG_SOFT_UART_TX;
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -3,6 +3,7 @@`
`3`	`3`	`"version": "1.0.0",`
`4`	`4`	`"build": {`
`5`	`5`	`"srcFilter": [`
	`6`	`+ "+<Channel_c.c>",`
`6`	`7`	`"+<ChannelUartStm8.c>"`
`7`	`8`	`]`
`8`	`9`	`}`