Hello, Habr!
For several years now, I have been doing all my projects for the stm32 microcontroller line in C ++.
During this time, I have accumulated a certain amount of material that may be of interest to other developers.
To avoid unnecessary questions: I use a bunch of QtCreator + gcc + gdb + openocd. How to work with it has been described many times, so I won’t stop there, but I’ll tell you more about my approaches to working with microcontrollers.
At the lower level of the project, as a rule, there are peripheral drivers. Let's start with them.
I try, if possible, not to mess with monsters like SPL, HAL and, God forgive me, CubeMX, except to finish up other people's projects for money. The ideology of the framework "as for large machines", in my opinion, is vicious there. Conceived by flexible and easy to use (although someone will argue with this) functions turn into a rather large and suboptimal machine code, where many unnecessary operations are performed on the microcontroller in runtime. Yes, modern controllers are powerful, but the computer on which we assemble the project is much more powerful, so let it do everything.
I determined for myself the basic requirements for the implementation of peripheral management:
- all constant expressions should be computed at the compilation stage and fall into machine code as numbers;
- the compiler must do the lion's share of the work, as well as control the types passed to functions;
- macros
Not needed should be used minimally, where this does not lead to weakening of type control; - The implementation programming interface should support code readability.
Probably only the lazy did not invent his bike to work with register fields. This is a shift plus logical operations a la CMSIS, and all sorts of macros that hide the same operations in their intricate bowels and are in the style of libraries from ST. At one time, I even worked through bit fields, until, finally, I came up with a solution, with which I want to introduce you.
Hereinafter, as an example, I will use the so beloved by the Chinese STM32f103 and its Flash access control register, which is one there, so the example will be simple and short.
flash CMSIS 72:
FLASH->ACR = (FLASH->ACR &
(~(FLASH_ACR_LATENCY_Msk
| FLASH_ACR_PRFTBE_Msk )))
| FLASH_ACR_LATENCY_1
| FLASH_ACR_PRFTBE;
, ? , - , , . . , , :
0x80001ec 04 4a ldr r2, [pc, #16] ; (0x8000200 <main()+20>)
0x80001ee <+ 2> 13 68 ldr r3, [r2, #0]
0x80001f0 <+ 4> 23 f0 17 03 bic.w r3, r3, #23
0x80001f4 <+ 8> 43 f0 12 03 orr.w r3, r3, #18
0x80001f8 <+ 12> 13 60 str r3, [r2, #0]
, : --. ?
. .
, . . flash :
struct Regs {
uint32_t ACR;
};
:
struct ACR {
constexpr static uint8_t LATENCY[]{ 0, 3 };
constexpr static uint8_t HLFCYA[]{ 3, 1 };
constexpr static uint8_t PRFTBE[]{ 4, 1 };
constexpr static uint8_t PRFTBS[]{ 5, 1 };
};
— , — . Python SVD .
, . constexpr :
constexpr static uint32_t base = 0x40022000;
INLINE constexpr static volatile Regs* rg()
{
return reinterpret_cast<volatile Regs*>(base);
}
base , (, , , , ) . .
INLINE
#ifndef INLINE
#define INLINE __attribute__((__always_inline__)) inline
#endif
, . , , gcc .
flash :
INLINE static void setLatency(Flash::Latency latency, bool prefetchBufferEnable = false)
{
setRegister(rg()->ACR,
ACR::LATENCY, static_cast<uint8_t>(latency),
ACR::PRFTBE, prefetchBufferEnable
);
}
, : , . latency , . static_cast<uint8_t>(latency) , , , Latency :
enum class Latency : uint8_t {
zeroWaitState = 0b000,
oneWaitState = 0b001,
twoWaitStates = 0b010
};
Flash::setLatency(Flash::Latency::twoWaitStates, true);
:
0x80001ec 04 4a ldr r2, [pc, #16] ; (0x8000200 <main()+20>)
0x80001ee <+ 2> 13 68 ldr r3, [r2, #0]
0x80001f0 <+ 4> 23 f0 17 03 bic.w r3, r3, #23
0x80001f4 <+ 8> 43 f0 12 03 orr.w r3, r3, #18
0x80001f8 <+ 12> 13 60 str r3, [r2, #0]
CMSIS: --, .
? setRegister. :
template<typename T, typename V, typename... Args>
INLINE constexpr static void setRegister(volatile uint32_t& reg,
const T field,
const V value,
const Args... args)
{
uint32_t mask = setMaskR(field, value, args...);
uint32_t val = setBitsR(field, value, args...);
reg = (reg & (~mask)) | val;
}
( uint32_t) — . .
:
template<typename V, typename T>
INLINE constexpr static uint32_t setBitsR(T field, V val)
{
return (val << (field[0]));
}
template<typename V, typename T, typename... Args>
INLINE constexpr static uint32_t setBitsR(T field, V val, Args... args)
{
return (val << (field[0])) | setBitsR(args...);
}
template<typename V, typename T>
INLINE constexpr static uint32_t setMaskR(T field, V val)
{
return ((((1 << field[1]) - 1) << field[0]));
}
template<typename V, typename T, typename... Args>
INLINE constexpr static uint32_t setMaskR(T field, V val, Args... args)
{
return ((((1 << field[1]) - 1) << field[0])) | setMaskR(args...);
}
"" . " " , , , , , , .
setRegister? . , - - — . , , , , volatile, , . , , .
. :
Flash::setLatency(Flash::Latency::twoWaitStates, true);
Flash::setLatency(Flash::Latency::oneWaitState, true);
--:
0x80001ec 07 4a ldr r2, [pc, #28] ; (0x800020c <main()+32>)
0x80001ee <+ 2> 13 68 ldr r3, [r2, #0]
0x80001f0 <+ 4> 23 f0 17 03 bic.w r3, r3, #23
0x80001f4 <+ 8> 43 f0 12 03 orr.w r3, r3, #18
0x80001f8 <+ 12> 13 60 str r3, [r2, #0] ;
0x80001fa <+ 14> 13 68 ldr r3, [r2, #0]
0x80001fc <+ 16> 23 f0 17 03 bic.w r3, r3, #23
0x8000200 <+ 20> 43 f0 11 03 orr.w r3, r3, #17
0x8000204 <+ 24> 13 60 str r3, [r2, #0] ;
:
template<typename T>
INLINE constexpr static uint32_t getRegField(volatile uint32_t& reg,
const T field)
{
uint32_t mask = (((1 << field[1]) - 1) << field[0]);
return ((reg & mask) >> field[0]);
}
.
— :
INLINE static bool getLatencyPrefetch()
{
return getRegField(rg()->ACR,
ACR::LATENCY,
ACR::PRFTBE);
}
flash :
struct Flash {
constexpr static uint32_t base = 0x40022000;
struct ACR {
constexpr static uint8_t LATENCY[]{ 0, 3 };
constexpr static uint8_t HLFCYA[]{ 3, 1 };
constexpr static uint8_t PRFTBE[]{ 4, 1 };
constexpr static uint8_t PRFTBS[]{ 5, 1 };
};
enum class Latency : uint8_t {
zeroWaitState = 0b000,
oneWaitState = 0b001,
twoWaitStates = 0b010
};
INLINE constexpr static volatile Regs* rg()
{
return reinterpret_cast<volatile Regs*>(base);
}
INLINE static void setLatency(Flash::Latency latency, bool prefetchBufferEnable = false)
{
Utility::setRegister(rg()->ACR,
ACR::LATENCY, static_cast<uint8_t>(latency),
ACR::PRFTBE, prefetchBufferEnable
);
}
INLINE static bool getLatencyPrefetch()
{
return getRegField(rg()->ACR,
ACR::LATENCY,
ACR::PRFTBE);
}
};
. , , . .
- , .
, . , DSP-. — .