Peripherals

It this chapter I will describe and give multiple examples of how to drive and control multiple hardware peripherals while using Device-Driver-Component model in conjunction with Event Loop.
All the generic, platform independent code provided here is implemented as part of embxx library while platform (Raspberry Pi) specific code is taken from embxx_on_rpi project.
All the platform specific peripheral control classes reside in src/device directory.
The src/app directory contains several simple applications, such as flashing the led or responding to button presses.
There are also common Component classes shared between the applications. They reside in src/component directory.
In order to compile all the applications please follow the instructions described in Contents of This Document.
Function Configuration
In ARM platform every pin needs to be configured as either gpio input, gpio output or having one of several alternative functions the microcontroller supports. The device::Function class defined in src/device/Function.h and src/device/Function.cpp implements simple interface which allows every Device class configure the pins it uses.
1
class Function
2
{
3
public:
4
    enum class FuncSel {
5
        Input,  // b000
6
        Output, // b001
7
        Alt5,   // b010
8
        Alt4,   // b011
9
        Alt0,   // b100
10
        Alt1,   // b101
11
        Alt2,   // b110
12
        Alt3    // b111
13
    };
14
​
15
    typedef unsigned PinIdxType;
16
​
17
    static const std::size_t NumOfLines = 54;
18
​
19
    void configure(PinIdxType idx, FuncSel sel);
20
};
Copied!
Every implemented Device class will receive reference to Function object in its constructor and will have to use it to configure the pins as required.
Interrupts Management
There is one more componenet that every Device will use. It's device::InterruptMgr defined in src/device/InterruptMgr.h. The main responsibility of the object of this class is to control global level interrupts, register interrupt handlers from various Devices and invoke the appropriate handler when interrupt occurs.
The interface of the device::InterruptMgr is defined as following:
1
template <typename THandler = embxx::util::StaticFunction<void ()> >
2
class InterruptMgr
3
{
4
public:
5
    typedef THandler HandlerFunc;
6
    enum IrqId {
7
        IrqId_Timer,
8
        IrqId_AuxInt,
9
        IrqId_Gpio1,
10
        IrqId_Gpio2,
11
        IrqId_Gpio3,
12
        IrqId_Gpio4,
13
        IrqId_I2C,
14
        IrqId_SPI,
15
        IrqId_NumOfIds // Must be last
16
    };
17
​
18
    InterruptMgr();
19
​
20
    template <typename TFunc>
21
    void registerHandler(IrqId id, TFunc&& handler);
22
​
23
    void enableInterrupt(IrqId id);
24
​
25
    void disableInterrupt(IrqId id);
26
​
27
    void handleInterrupt();
28
​
29
private:
30
    typedef std::uint32_t EntryType;
31
​
32
    struct IrqInfo {
33
        ... // Contains interrupt related information 
34
            // per single IrqId
35
    };
36
​
37
    typedef std::array<IrqInfo, IrqId_NumOfIds> IrqsArray;
38
​
39
    IrqsArray irqs_;
40
};
Copied!
Every Driver will use registerHandler() member function to register its member function as the handler for its IrqId. The enableInterrupt() and disableInterrupt() are also used by the Device objects to control their interrupts on global level.
In order to use the Interrupt Manager described above every application has to implement proper interrupt handler that will retrieve the reference to device::InterruptMgr object (via global/static variables) and invoke its handleInterrupt() function, which in turn check the appropriate status register(s) and invoke registered handler(s). Please note, that the handler will be executed in interrupt context.
The code will look something like this:
1
extern "C"
2
void interruptHandler()
3
{
4
    System::instance().interruptMgr().handleInterrupt();
5
}
Copied!
There may also be a need to enable/disable all the interrupts by toggling i flag in CPS register. The same src/device/InterruptMgr.h file provides two function for this purpose:
1
namespace device
2
{
3
​
4
namespace interrupt
5
{
6
​
7
inline
8
void enable()
9
{
10
    __asm volatile("cpsie i");
11
}
12
​
13
inline
14
void disable()
15
{
16
    __asm volatile("cpsid i");
17
}
18
​
19
}  // namespace interrupt
20
​
21
}  // namespace device
Copied!
Device-Driver-Component
Timer
Last modified 1yr ago
Copy link
Contents
Function Configuration
Interrupts Management