SystemPeripheralsGpio.h

Go to the documentation of this file.

// (c) IMT - Information Management Technology AG, CH-9470 Buchs, www.imt.ch.
 
#ifndef SYSTEMPERIPHERALSGPIO_H
#define SYSTEMPERIPHERALSGPIO_H
 
#include <Imt.Base.Core.Diagnostics/Diagnostics.h>
#include <Imt.Base.Core.Platform/Platform.h>
#include <Imt.Base.Core.Util/ReadOnlyPolicy.h>
#include <Imt.Base.Core.Util/ReadWritePolicy.h>
#include <Imt.Base.Core.Util/Register.h>
#include <Imt.Base.Core.Util/WriteOnlyPolicy.h>
 
#include "SystemMemoryMap.h"
 
enum GpioName {
    GPIOA = 0,
    GPIOB = 1,
    GPIOC = 2,
    GPIOD = 3,
    GPIOE = 4
};
 
template<uint32_t base>
struct gpio_base_addr;
 
template<>
struct gpio_base_addr<GPIOA> {
    static constexpr uint32_t value = GPIOA_BASE;
};
 
template<>
struct gpio_base_addr<GPIOB> {
    static constexpr uint32_t value = GPIOB_BASE;
};
 
template<>
struct gpio_base_addr<GPIOC> {
    static constexpr uint32_t value = GPIOC_BASE;
};
 
template<>
struct gpio_base_addr<GPIOD> {
    static constexpr uint32_t value = GPIOD_BASE;
};
 
template<>
struct gpio_base_addr<GPIOE> {
    static constexpr uint32_t value = GPIOE_BASE;
};
 
template<int base>
struct gpio {
    // Derive base address
    static constexpr uint32_t bsrr_base_addr = gpio_base_addr<base>::value + 0x10;
 
    struct BSRR {
        using BSR = ::imt::base::core::util::Register<imt::base::core::util::WriteOnlyPolicy, bsrr_base_addr, 0, 0x10>;
        using BRR = ::imt::base::core::util::Register<imt::base::core::util::WriteOnlyPolicy, bsrr_base_addr, 0x10, 0x10>;
    };
 
    static constexpr uint32_t crl_base_addr = gpio_base_addr<base>::value + 0x00;
    struct CRL {
        using CRL_READ = ::imt::base::core::util::Register<imt::base::core::util::ReadOnlyPolicy, crl_base_addr, 0, 0x20>;
        using CRL_WRITE = ::imt::base::core::util::Register<imt::base::core::util::WriteOnlyPolicy, crl_base_addr, 0, 0x20>;
    };
 
    static constexpr uint32_t crh_base_addr = gpio_base_addr<base>::value + 0x04;
    struct CRH {
        using CRH_READ = ::imt::base::core::util::Register<imt::base::core::util::ReadOnlyPolicy, crh_base_addr, 0, 0x20>;
        using CRH_WRITE = ::imt::base::core::util::Register<imt::base::core::util::WriteOnlyPolicy, crh_base_addr, 0, 0x20>;
    };
 
    static constexpr uint32_t idr_base_addr = gpio_base_addr<base>::value + 0x08;
    using IDR = ::imt::base::core::util::Register<imt::base::core::util::ReadOnlyPolicy, idr_base_addr, 0, 0x10>;
 
    static constexpr uint32_t odr_base_addr = gpio_base_addr<base>::value + 0x0C;
    struct ODR {
        using BSRR = ::imt::base::core::util::Register<imt::base::core::util::WriteOnlyPolicy, odr_base_addr, 0, 0x10>;
        using ODR_RW = ::imt::base::core::util::Register<imt::base::core::util::ReadWritePolicy, odr_base_addr, 0, 0x10>;
    };
 
    static constexpr uint32_t lckr_base_addr = gpio_base_addr<base>::value + 0x18;
    using LCKR = ::imt::base::core::util::Register<imt::base::core::util::ReadWritePolicy, lckr_base_addr, 0, 0x10>;
};
 
typedef enum {
    GPIO_ModuleAddress_GPIOA = GPIOA_BASE,
    GPIO_ModuleAddress_GPIOB = GPIOB_BASE,
    GPIO_ModuleAddress_GPIOC = GPIOC_BASE,
    GPIO_ModuleAddress_GPIOD = GPIOD_BASE,
    GPIO_ModuleAddress_GPIOE = GPIOE_BASE
} GPIO_ModuleAddress;
 
typedef enum {
    GPIO_Speed_10MHz = 1,
    GPIO_Speed_2MHz,
    GPIO_Speed_50MHz
} GPIO_Speed;
 
typedef enum {
    // Analog Input
    GPIO_Mode_AIN = 0x0,
    // Floating Input
    GPIO_Mode_IN_FLOATING = 0x04,
    // Input w/ PullDown
    GPIO_Mode_IPD = 0x28,
    // Input w/ PullUp
    GPIO_Mode_IPU = 0x48,
    // Output OpenDrain
    GPIO_Mode_Out_OD = 0x14,
    // Output PushPull
    GPIO_Mode_Out_PP = 0x10,
    // AlternateFunction OpenDrain
    GPIO_Mode_AF_OD = 0x1C,
    // AlternateFunction PushPull
    GPIO_Mode_AF_PP = 0x18
} GPIO_Mode;
 
typedef struct {
    uint16_t Pin;
    GPIO_Speed Speed;
    GPIO_Mode Mode;
} GPIO_InitStruct;
 
#define GPIO_Pin_0 ((uint16_t)0x0001)
#define GPIO_Pin_1 ((uint16_t)0x0002)
#define GPIO_Pin_2 ((uint16_t)0x0004)
#define GPIO_Pin_3 ((uint16_t)0x0008)
#define GPIO_Pin_4 ((uint16_t)0x0010)
#define GPIO_Pin_5 ((uint16_t)0x0020)
#define GPIO_Pin_6 ((uint16_t)0x0040)
#define GPIO_Pin_7 ((uint16_t)0x0080)
#define GPIO_Pin_8 ((uint16_t)0x0100)
#define GPIO_Pin_9 ((uint16_t)0x0200)
#define GPIO_Pin_10 ((uint16_t)0x0400)
#define GPIO_Pin_11 ((uint16_t)0x0800)
#define GPIO_Pin_12 ((uint16_t)0x1000)
#define GPIO_Pin_13 ((uint16_t)0x2000)
#define GPIO_Pin_14 ((uint16_t)0x4000)
#define GPIO_Pin_15 ((uint16_t)0x8000)
// All pins selected
#define GPIO_Pin_All ((uint16_t)0xFFFF)
 
typedef enum {
    GPIO_PortSourceA = ((uint8_t)0x00),
    GPIO_PortSourceB = ((uint8_t)0x01),
    GPIO_PortSourceC = ((uint8_t)0x02),
    GPIO_PortSourceD = ((uint8_t)0x03),
    GPIO_PortSourceE = ((uint8_t)0x04),
    GPIO_PortSourceF = ((uint8_t)0x05),
    GPIO_PortSourceG = ((uint8_t)0x06)
} GPIO_PortSource;
 
typedef enum {
    GPIO_PinSource0 = ((uint8_t)0x00),
    GPIO_PinSource1 = ((uint8_t)0x01),
    GPIO_PinSource2 = ((uint8_t)0x02),
    GPIO_PinSource3 = ((uint8_t)0x03),
    GPIO_PinSource4 = ((uint8_t)0x04),
    GPIO_PinSource5 = ((uint8_t)0x05),
    GPIO_PinSource6 = ((uint8_t)0x06),
    GPIO_PinSource7 = ((uint8_t)0x07),
    GPIO_PinSource8 = ((uint8_t)0x08),
    GPIO_PinSource9 = ((uint8_t)0x09),
    GPIO_PinSource10 = ((uint8_t)0x0A),
    GPIO_PinSource11 = ((uint8_t)0x0B),
    GPIO_PinSource12 = ((uint8_t)0x0C),
    GPIO_PinSource13 = ((uint8_t)0x0D),
    GPIO_PinSource14 = ((uint8_t)0x0E),
    GPIO_PinSource15 = ((uint8_t)0x0F)
} GPIO_PinSource;
 
typedef enum {
    // I2C1 Alternate Function mapping
    GPIO_Remap_I2C1 = ((uint32_t)0x00000001),
    // CAN1 Alternate Function mapping
    GPIO_Remap2_CAN1 = ((uint32_t)0x001D6000),
    // Full SWJ Enabled (JTAG-DP + SW-DP) but without JTRST
    GPIO_Remap_SWJ_NoJTRST = ((uint32_t)0x00300100)
} GPIO_Remap;
 
void GPIO_EXTILineConfig(GPIO_PortSource const portSource, GPIO_PinSource const pinSource);
 
void GPIO_PinRemapConfig(GPIO_Remap const remap, bool const doEnable);
 
void GPIO_Init(GPIO_ModuleAddress const module, GPIO_InitStruct const* const pInitStruct);
 
uint16_t GPIO_GetBits(GPIO_ModuleAddress const module, uint16_t const mask);
 
void GPIO_SetBits(GPIO_ModuleAddress const module, uint16_t const GPIO_Pin);
 
void GPIO_ResetBits(GPIO_ModuleAddress const module, uint16_t const GPIO_Pin);
 
#endif // SYSTEMPERIPHERALSGPIO_H