Skip to content

Commit 8c43f84

Browse files
kapacuksalkinium
kapacuk
authored and
salkinium
committed
[stm32] Implement UART buffer for FreeRTOS
1 parent cfb90b0 commit 8c43f84

File tree

4 files changed

+325
-0
lines changed

4 files changed

+325
-0
lines changed

‎examples/black_pill_f401/uart_freertos/main.cpp

+70
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,70 @@
1+
/*
2+
* Copyright (c) 2016, Sascha Schade
3+
* Copyright (c) 2017, Niklas Hauser
4+
* Copyright (c) 2019, Raphael Lehmann
5+
*
6+
* This file is part of the modm project.
7+
*
8+
* This Source Code Form is subject to the terms of the Mozilla Public
9+
* License, v. 2.0. If a copy of the MPL was not distributed with this
10+
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
11+
*/
12+
// ----------------------------------------------------------------------------
13+
14+
#include <modm/board.hpp>
15+
#include <freertos/FreeRTOS.h>
16+
#include <freertos/queue.h>
17+
18+
/*
19+
* A single FreeRTOS task which reads symbols from Usart1
20+
* and sends them back, toggling the LED for every symbol
21+
*/
22+
23+
using namespace Board;
24+
using namespace modm::platform;
25+
26+
using Uart = BufferedUart<UsartHal1, UartTxBuffer<4>>;
27+
using FreeRtosUart = BufferedUart<UsartHal1, UartRxBufferFreeRtos<8>, UartTxBufferFreeRtos<4>>;
28+
29+
void
30+
taskMain(void *)
31+
{
32+
// Let's test the old driver first:
33+
Uart::connect<GpioOutputB6::Tx, GpioInputB7::Rx>();
34+
Uart::initialize<SystemClock, 115200_Bd>();
35+
Uart::writeBlocking( (uint8_t *)"Old UART\r\n", 10 );
36+
37+
while( (USART1->SR & USART_SR_TC) == 0 ); // Making sure the transmission has finished.
38+
// Maybe this should be exposed via UsartHal?
39+
40+
// The old UART driver and the new one can coexist, and you
41+
// can even switch between them at runtime:
42+
FreeRtosUart::connect<GpioOutputB6::Tx, GpioInputB7::Rx>();
43+
FreeRtosUart::initialize<SystemClock, 115200_Bd>();
44+
Led::set();
45+
46+
FreeRtosUart::writeBlocking( (uint8_t *)"FreeRTOS UART\r\n", 15 );
47+
48+
uint8_t chr;
49+
while (true)
50+
{
51+
FreeRtosUart::read( chr );
52+
FreeRtosUart::write( chr );
53+
Led::toggle();
54+
}
55+
}
56+
57+
constexpr int stack_size = 200;
58+
StackType_t stack[stack_size];
59+
StaticTask_t taskBuffer;
60+
61+
int
62+
main()
63+
{
64+
Board::initialize();
65+
66+
TaskHandle_t h_mainTask = xTaskCreateStatic(taskMain, "Main", stack_size, NULL, 2, stack, &taskBuffer);
67+
configASSERT( h_mainTask != NULL );
68+
vTaskStartScheduler();
69+
return 0;
70+
}

‎examples/black_pill_f401/uart_freertos/project.xml

+12
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,12 @@
1+
<library>
2+
<extends>modm:black-pill-f401</extends>
3+
<options>
4+
<option name="modm:build:build.path">../../../build/black_pill_f401/uart_freertos</option>
5+
</options>
6+
<modules>
7+
<module>modm:build:make</module>
8+
<module>modm:build:scons</module>
9+
<module>modm:platform:uart:1</module>
10+
<module>modm:freertos</module>
11+
</modules>
12+
</library>

‎ext/aws/uart_buffer_freertos.hpp

+241
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,241 @@
1+
/*
2+
* Copyright (c) 2009-2012, Fabian Greif
3+
* Copyright (c) 2010, Martin Rosekeit
4+
* Copyright (c) 2011, Georgi Grinshpun
5+
* Copyright (c) 2011, 2013-2017, Niklas Hauser
6+
* Copyright (c) 2012, Sascha Schade
7+
* Copyright (c) 2013, 2016, Kevin Läufer
8+
* Copyright (c) 2021, Raphael Lehmann
9+
*
10+
* This file is part of the modm project.
11+
*
12+
* This Source Code Form is subject to the terms of the Mozilla Public
13+
* License, v. 2.0. If a copy of the MPL was not distributed with this
14+
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
15+
*/
16+
// ----------------------------------------------------------------------------
17+
18+
#pragma once
19+
20+
#include <freertos/FreeRTOS.h>
21+
#include <freertos/queue.h>
22+
#include <modm/architecture/interface/uart.hpp>
23+
#include "uart_base.hpp"
24+
25+
namespace modm::platform
26+
{
27+
28+
/**
29+
* Universal asynchronous receiver transmitter (implementation based on FreeRTOS queues)
30+
*
31+
* @author Kevin Laeufer
32+
* @author Niklas Hauser
33+
* @author Dima Barsky
34+
* @ingroup modm_platform_uart
35+
* @{
36+
*/
37+
template <size_t SIZE>
38+
class FreeRtosBuffer
39+
{
40+
StaticQueue_t queueStructure;
41+
uint8_t storage[SIZE];
42+
public:
43+
QueueHandle_t queue = xQueueCreateStatic(sizeof(storage), 1, storage, &queueStructure);
44+
};
45+
46+
template <size_t SIZE>
47+
class UartRxBufferFreeRtos : public modm::Uart::RxBuffer, public FreeRtosBuffer<SIZE>{};
48+
49+
template <size_t SIZE>
50+
class UartTxBufferFreeRtos : public modm::Uart::TxBuffer, public FreeRtosBuffer<SIZE>{};
51+
/// @}
52+
53+
/// @cond
54+
template< class Hal, class... Buffers>
55+
class BufferedUart;
56+
57+
template<size_t SIZE, class Hal, class... Buffers>
58+
class BufferedUart<Hal, UartTxBufferFreeRtos<SIZE>, Buffers...>: public BufferedUart<Hal, Buffers...>
59+
{
60+
template< class Hal_, class... Buffers_> friend class BufferedUart;
61+
using Parent = BufferedUart<Hal, Buffers...>;
62+
static_assert(not Parent::TxBufferSize, "BufferedUart accepts at most one TxBuffer type");
63+
static inline UartTxBufferFreeRtos<SIZE> txBuffer;
64+
65+
static bool
66+
InterruptCallback(bool first)
67+
{
68+
BaseType_t xHigherPriorityTaskWoken{false};
69+
if constexpr (Parent::RxBufferSize)
70+
xHigherPriorityTaskWoken = Parent::InterruptCallback(false);
71+
72+
if (Hal::isTransmitRegisterEmpty())
73+
{
74+
if (xQueueIsQueueEmptyFromISR(txBuffer.queue))
75+
// transmission finished, disable TxEmpty interrupt
76+
Hal::disableInterrupt(Hal::Interrupt::TxEmpty);
77+
else
78+
{
79+
uint8_t data;
80+
xQueueReceiveFromISR(txBuffer.queue, &data, &xHigherPriorityTaskWoken);
81+
Hal::write(data);
82+
}
83+
}
84+
if (first)
85+
{
86+
Hal::acknowledgeInterruptFlags(Hal::InterruptFlag::OverrunError);
87+
portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
88+
}
89+
return xHigherPriorityTaskWoken;
90+
}
91+
92+
public:
93+
static constexpr size_t TxBufferSize = SIZE;
94+
95+
template< class SystemClock, baudrate_t baudrate, percent_t tolerance=pct(1) >
96+
static inline void
97+
initialize(Hal::Parity parity=Hal::Parity::Disabled, Hal::WordLength length=Hal::WordLength::Bit8)
98+
{
99+
Parent::template initialize<SystemClock, baudrate, tolerance>(parity, length);
100+
Hal::InterruptCallback = InterruptCallback;
101+
}
102+
103+
static bool
104+
write(uint8_t data)
105+
{
106+
if (transmitBufferSize() == 0 and Hal::isTransmitRegisterEmpty())
107+
Hal::write(data);
108+
else
109+
{
110+
if (not xQueueSend(txBuffer.queue, &data, 0)) return false;
111+
// Disable interrupts while enabling the transmit interrupt
112+
atomic::Lock lock;
113+
// Transmit Data Register Empty Interrupt Enable
114+
Hal::enableInterrupt(Hal::Interrupt::TxEmpty);
115+
}
116+
return true;
117+
}
118+
119+
static std::size_t
120+
write(const uint8_t *data, std::size_t length)
121+
{
122+
std::size_t count{0};
123+
for (; count < length; ++count) if (not write(*data++)) break;
124+
return count;
125+
}
126+
127+
static void
128+
writeBlocking(uint8_t data)
129+
{
130+
if (transmitBufferSize() == 0 and Hal::isTransmitRegisterEmpty())
131+
Hal::write(data);
132+
else
133+
{
134+
xQueueSend(txBuffer.queue, &data, portMAX_DELAY);
135+
// Disable interrupts while enabling the transmit interrupt
136+
atomic::Lock lock;
137+
// Transmit Data Register Empty Interrupt Enable
138+
Hal::enableInterrupt(Hal::Interrupt::TxEmpty);
139+
}
140+
}
141+
142+
static void
143+
writeBlocking(const uint8_t *data, std::size_t length)
144+
{
145+
while (length-- != 0) writeBlocking(*data++);
146+
}
147+
148+
static void
149+
flushWriteBuffer() { while(not isWriteFinished()); }
150+
151+
bool
152+
isWriteFinished() { return transmitBufferSize() == 0 and Hal::isTransmitRegisterEmpty(); }
153+
154+
static std::size_t
155+
transmitBufferSize() { return uxQueueMessagesWaiting(txBuffer.queue); }
156+
157+
std::size_t
158+
discardTransmitBuffer()
159+
{
160+
// disable interrupt since buffer will be cleared
161+
Hal::disableInterrupt(Hal::Interrupt::TxEmpty);
162+
std::size_t count = transmitBufferSize();
163+
xQueueReset(txBuffer.queue);
164+
return count;
165+
}
166+
};
167+
168+
template<size_t SIZE, class Hal, class... Buffers>
169+
class BufferedUart<Hal, UartRxBufferFreeRtos<SIZE>, Buffers...>: public BufferedUart<Hal, Buffers...>
170+
{
171+
template< class Hal_, class... Buffers_> friend class BufferedUart;
172+
using Parent = BufferedUart<Hal, Buffers...>;
173+
static_assert(not Parent::RxBufferSize, "BufferedUart accepts at most one RxBuffer type");
174+
static inline UartRxBufferFreeRtos<SIZE> rxBuffer;
175+
176+
static bool
177+
InterruptCallback(bool first)
178+
{
179+
BaseType_t xHigherPriorityTaskWoken{false};
180+
if constexpr (Parent::TxBufferSize)
181+
xHigherPriorityTaskWoken = Parent::InterruptCallback(false);
182+
183+
if (Hal::isReceiveRegisterNotEmpty())
184+
{
185+
uint8_t data;
186+
Hal::read(data);
187+
xQueueSendFromISR(rxBuffer.queue, &data, &xHigherPriorityTaskWoken);
188+
}
189+
if (first)
190+
{
191+
Hal::acknowledgeInterruptFlags(Hal::InterruptFlag::OverrunError);
192+
portYIELD_FROM_ISR (xHigherPriorityTaskWoken);
193+
}
194+
return xHigherPriorityTaskWoken;
195+
}
196+
197+
public:
198+
static constexpr size_t RxBufferSize = SIZE;
199+
200+
template< class SystemClock, baudrate_t baudrate, percent_t tolerance=pct(1) >
201+
static inline void
202+
initialize(Hal::Parity parity=Hal::Parity::Disabled, Hal::WordLength length=Hal::WordLength::Bit8)
203+
{
204+
Parent::template initialize<SystemClock, baudrate, tolerance>(parity, length);
205+
Hal::InterruptCallback = InterruptCallback;
206+
Hal::enableInterrupt(Hal::Interrupt::RxNotEmpty);
207+
}
208+
209+
static bool
210+
read(uint8_t &data, TickType_t timeout=portMAX_DELAY)
211+
{ return bool(xQueueReceive(rxBuffer.queue, &data, timeout)); }
212+
213+
static std::size_t
214+
read(uint8_t *buffer, std::size_t length, TickType_t timeout=0)
215+
{
216+
std::size_t count{0};
217+
for (; count < length; ++count)
218+
if (not xQueueReceive(rxBuffer.queue, buffer++, timeout))
219+
break;
220+
return count;
221+
}
222+
223+
static std::size_t
224+
receiveBufferSize() { return uxQueueMessagesWaiting(rxBuffer.queue); }
225+
226+
static std::size_t
227+
discardReceiveBuffer()
228+
{
229+
std::size_t count = 0;
230+
uint8_t data;
231+
while(receiveBufferSize())
232+
{
233+
++count;
234+
xQueueReceive(rxBuffer.queue, &data, 0);
235+
}
236+
return count;
237+
}
238+
};
239+
/// @endcond
240+
241+
}

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

+2
Original file line numberDiff line numberDiff line change
@@ -137,4 +137,6 @@ def build(env):
137137

138138
env.copy("uart.hpp")
139139
env.copy("uart_buffer.hpp")
140+
if env.has_module(":freertos"):
141+
env.copy(repopath("ext/aws/uart_buffer_freertos.hpp"), "uart_buffer_freertos.hpp")
140142

0 commit comments

Comments
 (0)