[stm32] Implement UART buffers in C++ rather than lbuild

Author: kapacuk

src/modm/architecture/interface/uart.hpp

@@ -30,8 +30,11 @@ namespace modm
  */
 class Uart : public ::modm::PeripheralDriver
 {
-#ifdef __DOXYGEN__
 public:
+	struct RxBuffer { static constexpr bool HasRxBuffer = true; };
+	struct TxBuffer { static constexpr bool HasTxBuffer = true; };
+
+#ifdef __DOXYGEN__
 	/// Size of the receive buffer.
 	static constexpr size_t RxBufferSize = 16;
 

src/modm/platform/uart/stm32/module.lb

@@ -28,20 +28,6 @@ class Instance(Module):
 
     def prepare(self, module, options):
         module.depends(":platform:uart")
-
-        module.add_option(
-            NumericOption(
-                name="buffer.tx",
-                description="",
-                minimum=0, maximum="64Ki-2",
-                default=0))
-        module.add_option(
-            NumericOption(
-                name="buffer.rx",
-                description="",
-                minimum=0, maximum="64Ki-2",
-                default=0))
-
         return True
 
     def build(self, env):
@@ -53,7 +39,6 @@ class Instance(Module):
         props["uart_type"] = self.driver["name"].capitalize()
         props["name"] = self.driver["name"].capitalize() + str(self.instance)
         props["hal"] = self.driver["name"].capitalize() + "Hal" + str(self.instance)
-        props["buffered"] = env["buffer.tx"] or env["buffer.rx"]
 
         env.substitutions = props
         env.outbasepath = "modm/src/modm/platform/uart"
@@ -65,13 +50,8 @@ class Instance(Module):
 
         env.template("uart_hal.hpp.in", "{}_hal_{}.hpp".format(uart, self.instance))
         env.template("uart_hal_impl.hpp.in", "{}_hal_{}_impl.hpp".format(uart, self.instance))
-        env.template("uart.hpp.in", "{}_{}.hpp".format(uart, self.instance))
         env.template("uart.cpp.in", "{}_{}.cpp".format(uart, self.instance))
-
-        #props["instances"].append(props["name"])
-        if props["buffered"]:
-            props["buffered_instances"].append(props["name"])
-
+        props["instances"].append(props["name"])
 
 def init(module):
     module.name = ":platform:uart"
@@ -92,15 +72,15 @@ def prepare(module, options):
         ":math:algorithm",
         ":cmsis:device",
         ":platform:gpio",
-        ":platform:rcc")
+        ":platform:rcc",
+        ":utils")
 
     global props
     drivers = (device.get_all_drivers("uart") + device.get_all_drivers("usart") + device.get_all_drivers("lpuart"))
     props["extended_driver"] = ("extended" in drivers[0]["type"])
     props["over8"] = ("feature" in drivers[0]) and ("over8" in drivers[0]["feature"])
     props["tcbgt"] = ("feature" in drivers[0]) and ("tcbgt" in drivers[0]["feature"])
     props["instances"] = []
-    props["buffered_instances"] = []
 
     for driver in drivers:
         for instance in driver["instance"]:
@@ -142,7 +122,7 @@ def build(env):
     env.template("uart_base.hpp.in")
 
     props["uart_shared_irqs_data"] = dict()
-    for name in props["buffered_instances"]:
+    for name in props["instances"]:
         if name in props["shared_irqs"].keys():
             irq = props["shared_irqs"][name]
             if irq not in props["uart_shared_irqs_data"]:
@@ -154,3 +134,7 @@ def build(env):
             })
     if len(props["uart_shared_irqs_data"]):
         env.template("uart_shared.cpp.in")
+
+    env.copy("uart.hpp")
+    env.copy("uart_buffer.hpp")
+

src/modm/platform/uart/stm32/uart.cpp.in

@@ -16,254 +16,28 @@
  */
 // ----------------------------------------------------------------------------
 
-#include "../device.hpp"
 %% if "Lpuart" in uart_type
-#include "lpuart_{{ id }}.hpp"
+#include "lpuart_hal_{{ id }}.hpp"
 %% else
-#include "uart_{{ id }}.hpp"
+#include "uart_hal_{{ id }}.hpp"
 %%endif
 
-%% if buffered
-#include <modm/architecture/interface/atomic_lock.hpp>
-#include <modm/architecture/driver/atomic/queue.hpp>
-
-namespace
-{
-%% if options["buffer.rx"]
-	static modm::atomic::Queue<uint8_t, {{ options["buffer.rx"] }}> rxBuffer;
-%% endif
-%% if options["buffer.tx"]
-	static modm::atomic::Queue<uint8_t, {{ options["buffer.tx"] }}> txBuffer;
-%% endif
-}
-%% endif
-
-namespace modm::platform
-{
-
-void
-{{ name }}::writeBlocking(uint8_t data)
-{
-	while(!{{ hal }}::isTransmitRegisterEmpty());
-	{{ hal }}::write(data);
-}
-
-void
-{{ name }}::writeBlocking(const uint8_t *data, std::size_t length)
+%% if name in shared_irqs.keys()
+namespace modm::platform::{{ name }}
 {
-	while (length-- != 0) {
-		writeBlocking(*data++);
-	}
-}
-
 void
-{{ name }}::flushWriteBuffer()
-{
-%% if options["buffer.tx"]
-	while(!isWriteFinished());
-%% else
-	return;
-%% endif
-}
-
-bool
-{{ name }}::write(uint8_t data)
-{
-%% if options["buffer.tx"]
-	if(txBuffer.isEmpty() && {{ hal }}::isTransmitRegisterEmpty()) {
-		{{ hal }}::write(data);
-	} else {
-		if (!txBuffer.push(data))
-			return false;
-		// Disable interrupts while enabling the transmit interrupt
-		atomic::Lock lock;
-		// Transmit Data Register Empty Interrupt Enable
-		{{ hal }}::enableInterrupt(Interrupt::TxEmpty);
-	}
-	return true;
-%% else
-	if({{ hal }}::isTransmitRegisterEmpty()) {
-		{{ hal }}::write(data);
-		return true;
-	} else {
-		return false;
-	}
-%% endif
-}
-
-std::size_t
-{{ name }}::write(const uint8_t *data, std::size_t length)
-{
-	uint32_t i = 0;
-	for (; i < length; ++i)
-	{
-		if (!write(*data++)) {
-			return i;
-		}
-	}
-	return i;
-}
-
-bool
-{{ name }}::isWriteFinished()
-{
-%% if options["buffer.tx"]
-	return txBuffer.isEmpty() && {{ hal }}::isTransmitRegisterEmpty();
-%% else
-	return {{ hal }}::isTransmitRegisterEmpty();
-%% endif
-}
-
-std::size_t
-{{ name }}::transmitBufferSize()
-{
-%% if options["buffer.tx"]
-	return txBuffer.getSize();
-%% else
-	return {{ hal }}::isTransmitRegisterEmpty() ? 0 : 1;
-%% endif
-}
-
-std::size_t
-{{ name }}::discardTransmitBuffer()
-{
-%% if options["buffer.tx"]
-	std::size_t count = 0;
-	// disable interrupt since buffer will be cleared
-	{{ hal }}::disableInterrupt({{ hal }}::Interrupt::TxEmpty);
-	while(!txBuffer.isEmpty()) {
-		++count;
-		txBuffer.pop();
-	}
-	return count;
-%% else
-	return 0;
-%% endif
-}
-
-bool
-{{ name }}::read(uint8_t &data)
-{
-%% if options["buffer.rx"]
-	if (rxBuffer.isEmpty()) {
-		return false;
-	} else {
-		data = rxBuffer.get();
-		rxBuffer.pop();
-		return true;
-	}
+irq()
 %% else
-	if({{ hal }}::isReceiveRegisterNotEmpty()) {
-		{{ hal }}::read(data);
-		return true;
-	} else {
-		return false;
-	}
+MODM_ISR({{ name | upper }})
 %% endif
-}
-
-std::size_t
-{{ name }}::read(uint8_t *data, std::size_t length)
 {
-%% if options["buffer.rx"]
-	uint32_t i = 0;
-	for (; i < length; ++i)
+	using namespace modm::platform;
+	if ({{ hal }}::InterruptCallback)
 	{
-		if (rxBuffer.isEmpty()) {
-			return i;
-		} else {
-			*data++ = rxBuffer.get();
-			rxBuffer.pop();
-		}
-	}
-	return i;
-%% else
-	(void)length; // avoid compiler warning
-	if(read(*data)) {
-		return 1;
-	} else {
-		return 0;
+		{{ hal }}::InterruptCallback(true);
 	}
-%% endif
 }
 
-std::size_t
-{{ name }}::receiveBufferSize()
-{
-%% if options["buffer.rx"]
-	return rxBuffer.getSize();
-%% else
-	return {{ hal }}::isReceiveRegisterNotEmpty() ? 1 : 0;
-%% endif
-}
-
-std::size_t
-{{ name }}::discardReceiveBuffer()
-{
-%% if options["buffer.rx"]
-	std::size_t count = 0;
-	while(!rxBuffer.isEmpty()) {
-		++count;
-		rxBuffer.pop();
-	}
-	return count;
-%% else
-	return 0;
-%% endif
-}
-
-bool
-{{ name }}::hasError()
-{
-	return {{ hal }}::getInterruptFlags().any(
-		{{ hal }}::InterruptFlag::ParityError |
-#ifdef USART_ISR_NE
-		{{ hal }}::InterruptFlag::NoiseError |
-#endif
-		{{ hal }}::InterruptFlag::OverrunError | {{ hal }}::InterruptFlag::FramingError);
-}
-void
-{{ name }}::clearError()
-{
-	return {{ hal }}::acknowledgeInterruptFlags(
-		{{ hal }}::InterruptFlag::ParityError |
-#ifdef USART_ISR_NE
-		{{ hal }}::InterruptFlag::NoiseError |
-#endif
-		{{ hal }}::InterruptFlag::OverrunError | {{ hal }}::InterruptFlag::FramingError);
-}
-
-}	// namespace modm::platform
-
-%% if buffered
 %% if name in shared_irqs.keys()
-void
-modm::platform::{{ name }}::irq()
-%% else
-MODM_ISR({{ name | upper }})
-%% endif
-{
-	using namespace modm::platform;
-%% if options["buffer.rx"]
-	if ({{ hal }}::isReceiveRegisterNotEmpty()) {
-		// TODO: save the errors
-		uint8_t data;
-		{{ hal }}::read(data);
-		rxBuffer.push(data);
-	}
-%% endif
-%% if options["buffer.tx"]
-	if ({{ hal }}::isTransmitRegisterEmpty()) {
-		if (txBuffer.isEmpty()) {
-			// transmission finished, disable TxEmpty interrupt
-			{{ hal }}::disableInterrupt({{ hal }}::Interrupt::TxEmpty);
-		}
-		else {
-			{{ hal }}::write(txBuffer.get());
-			txBuffer.pop();
-		}
-	}
-%% endif
-	{{ hal }}::acknowledgeInterruptFlags({{ hal }}::InterruptFlag::OverrunError);
-}
+} // namespace modm::platform::{{ name }}
 %% endif