Program Listing for File rtc.h

↰ Return to documentation for file (src/generated/structs/rtc.h)

#pragma once

#include "../ifgen/common.h"

namespace RP2040
{

struct [[gnu::packed]] rtc
{
    /* Constant attributes. */
    static constexpr std::size_t size = 48;
    /* Fields. */
    uint32_t
        CLKDIV_M1;
    uint32_t SETUP_0;
    uint32_t SETUP_1;
    uint32_t CTRL;
    uint32_t IRQ_SETUP_0;
    uint32_t IRQ_SETUP_1;
    const uint32_t RTC_1 = {};
    const uint32_t RTC_0 = {};
    const uint32_t INTR = {};
    uint32_t INTE;
    uint32_t INTF;
    const uint32_t INTS =
        {};
    /* Methods. */

    inline uint16_t get_CLKDIV_M1_CLKDIV_M1() volatile
    {
        return (CLKDIV_M1 >> 0u) & 0b1111111111111111u;
    }

    inline void set_CLKDIV_M1_CLKDIV_M1(uint16_t value) volatile
    {
        uint32_t curr = CLKDIV_M1;

        curr &= ~(0b1111111111111111u << 0u);
        curr |= (value & 0b1111111111111111u) << 0u;

        CLKDIV_M1 = curr;
    }

    inline uint8_t get_SETUP_0_DAY() volatile
    {
        return (SETUP_0 >> 0u) & 0b11111u;
    }

    inline void set_SETUP_0_DAY(uint8_t value) volatile
    {
        uint32_t curr = SETUP_0;

        curr &= ~(0b11111u << 0u);
        curr |= (value & 0b11111u) << 0u;

        SETUP_0 = curr;
    }

    inline uint8_t get_SETUP_0_MONTH() volatile
    {
        return (SETUP_0 >> 8u) & 0b1111u;
    }

    inline void set_SETUP_0_MONTH(uint8_t value) volatile
    {
        uint32_t curr = SETUP_0;

        curr &= ~(0b1111u << 8u);
        curr |= (value & 0b1111u) << 8u;

        SETUP_0 = curr;
    }

    inline uint16_t get_SETUP_0_YEAR() volatile
    {
        return (SETUP_0 >> 12u) & 0b111111111111u;
    }

    inline void set_SETUP_0_YEAR(uint16_t value) volatile
    {
        uint32_t curr = SETUP_0;

        curr &= ~(0b111111111111u << 12u);
        curr |= (value & 0b111111111111u) << 12u;

        SETUP_0 = curr;
    }

    inline void get_SETUP_0(uint8_t &DAY, uint8_t &MONTH,
                            uint16_t &YEAR) volatile
    {
        uint32_t curr = SETUP_0;

        DAY = (curr >> 0u) & 0b11111u;
        MONTH = (curr >> 8u) & 0b1111u;
        YEAR = (curr >> 12u) & 0b111111111111u;
    }

    inline void set_SETUP_0(uint8_t DAY, uint8_t MONTH, uint16_t YEAR) volatile
    {
        uint32_t curr = SETUP_0;

        curr &= ~(0b11111u << 0u);
        curr |= (DAY & 0b11111u) << 0u;
        curr &= ~(0b1111u << 8u);
        curr |= (MONTH & 0b1111u) << 8u;
        curr &= ~(0b111111111111u << 12u);
        curr |= (YEAR & 0b111111111111u) << 12u;

        SETUP_0 = curr;
    }

    inline uint8_t get_SETUP_1_SEC() volatile
    {
        return (SETUP_1 >> 0u) & 0b111111u;
    }

    inline void set_SETUP_1_SEC(uint8_t value) volatile
    {
        uint32_t curr = SETUP_1;

        curr &= ~(0b111111u << 0u);
        curr |= (value & 0b111111u) << 0u;

        SETUP_1 = curr;
    }

    inline uint8_t get_SETUP_1_MIN() volatile
    {
        return (SETUP_1 >> 8u) & 0b111111u;
    }

    inline void set_SETUP_1_MIN(uint8_t value) volatile
    {
        uint32_t curr = SETUP_1;

        curr &= ~(0b111111u << 8u);
        curr |= (value & 0b111111u) << 8u;

        SETUP_1 = curr;
    }

    inline uint8_t get_SETUP_1_HOUR() volatile
    {
        return (SETUP_1 >> 16u) & 0b11111u;
    }

    inline void set_SETUP_1_HOUR(uint8_t value) volatile
    {
        uint32_t curr = SETUP_1;

        curr &= ~(0b11111u << 16u);
        curr |= (value & 0b11111u) << 16u;

        SETUP_1 = curr;
    }

    inline uint8_t get_SETUP_1_DOTW() volatile
    {
        return (SETUP_1 >> 24u) & 0b111u;
    }

    inline void set_SETUP_1_DOTW(uint8_t value) volatile
    {
        uint32_t curr = SETUP_1;

        curr &= ~(0b111u << 24u);
        curr |= (value & 0b111u) << 24u;

        SETUP_1 = curr;
    }

    inline void get_SETUP_1(uint8_t &SEC, uint8_t &MIN, uint8_t &HOUR,
                            uint8_t &DOTW) volatile
    {
        uint32_t curr = SETUP_1;

        SEC = (curr >> 0u) & 0b111111u;
        MIN = (curr >> 8u) & 0b111111u;
        HOUR = (curr >> 16u) & 0b11111u;
        DOTW = (curr >> 24u) & 0b111u;
    }

    inline void set_SETUP_1(uint8_t SEC, uint8_t MIN, uint8_t HOUR,
                            uint8_t DOTW) volatile
    {
        uint32_t curr = SETUP_1;

        curr &= ~(0b111111u << 0u);
        curr |= (SEC & 0b111111u) << 0u;
        curr &= ~(0b111111u << 8u);
        curr |= (MIN & 0b111111u) << 8u;
        curr &= ~(0b11111u << 16u);
        curr |= (HOUR & 0b11111u) << 16u;
        curr &= ~(0b111u << 24u);
        curr |= (DOTW & 0b111u) << 24u;

        SETUP_1 = curr;
    }

    inline bool get_CTRL_RTC_ENABLE() volatile
    {
        return CTRL & (1u << 0u);
    }

    inline void set_CTRL_RTC_ENABLE() volatile
    {
        CTRL |= 1u << 0u;
    }

    inline void clear_CTRL_RTC_ENABLE() volatile
    {
        CTRL &= ~(1u << 0u);
    }

    inline void toggle_CTRL_RTC_ENABLE() volatile
    {
        CTRL ^= 1u << 0u;
    }

    inline bool get_CTRL_RTC_ACTIVE() volatile
    {
        return CTRL & (1u << 1u);
    }

    inline bool get_CTRL_LOAD() volatile
    {
        return CTRL & (1u << 4u);
    }

    inline void set_CTRL_LOAD() volatile
    {
        CTRL |= 1u << 4u;
    }

    inline void clear_CTRL_LOAD() volatile
    {
        CTRL &= ~(1u << 4u);
    }

    inline void toggle_CTRL_LOAD() volatile
    {
        CTRL ^= 1u << 4u;
    }

    inline bool get_CTRL_FORCE_NOTLEAPYEAR() volatile
    {
        return CTRL & (1u << 8u);
    }

    inline void set_CTRL_FORCE_NOTLEAPYEAR() volatile
    {
        CTRL |= 1u << 8u;
    }

    inline void clear_CTRL_FORCE_NOTLEAPYEAR() volatile
    {
        CTRL &= ~(1u << 8u);
    }

    inline void toggle_CTRL_FORCE_NOTLEAPYEAR() volatile
    {
        CTRL ^= 1u << 8u;
    }

    inline void get_CTRL(bool &RTC_ENABLE, bool &RTC_ACTIVE, bool &LOAD,
                         bool &FORCE_NOTLEAPYEAR) volatile
    {
        uint32_t curr = CTRL;

        RTC_ENABLE = curr & (1u << 0u);
        RTC_ACTIVE = curr & (1u << 1u);
        LOAD = curr & (1u << 4u);
        FORCE_NOTLEAPYEAR = curr & (1u << 8u);
    }

    inline void set_CTRL(bool RTC_ENABLE, bool LOAD,
                         bool FORCE_NOTLEAPYEAR) volatile
    {
        uint32_t curr = CTRL;

        curr &= ~(0b1u << 0u);
        curr |= (RTC_ENABLE & 0b1u) << 0u;
        curr &= ~(0b1u << 4u);
        curr |= (LOAD & 0b1u) << 4u;
        curr &= ~(0b1u << 8u);
        curr |= (FORCE_NOTLEAPYEAR & 0b1u) << 8u;

        CTRL = curr;
    }

    inline uint8_t get_IRQ_SETUP_0_DAY() volatile
    {
        return (IRQ_SETUP_0 >> 0u) & 0b11111u;
    }

    inline void set_IRQ_SETUP_0_DAY(uint8_t value) volatile
    {
        uint32_t curr = IRQ_SETUP_0;

        curr &= ~(0b11111u << 0u);
        curr |= (value & 0b11111u) << 0u;

        IRQ_SETUP_0 = curr;
    }

    inline uint8_t get_IRQ_SETUP_0_MONTH() volatile
    {
        return (IRQ_SETUP_0 >> 8u) & 0b1111u;
    }

    inline void set_IRQ_SETUP_0_MONTH(uint8_t value) volatile
    {
        uint32_t curr = IRQ_SETUP_0;

        curr &= ~(0b1111u << 8u);
        curr |= (value & 0b1111u) << 8u;

        IRQ_SETUP_0 = curr;
    }

    inline uint16_t get_IRQ_SETUP_0_YEAR() volatile
    {
        return (IRQ_SETUP_0 >> 12u) & 0b111111111111u;
    }

    inline void set_IRQ_SETUP_0_YEAR(uint16_t value) volatile
    {
        uint32_t curr = IRQ_SETUP_0;

        curr &= ~(0b111111111111u << 12u);
        curr |= (value & 0b111111111111u) << 12u;

        IRQ_SETUP_0 = curr;
    }

    inline bool get_IRQ_SETUP_0_DAY_ENA() volatile
    {
        return IRQ_SETUP_0 & (1u << 24u);
    }

    inline void set_IRQ_SETUP_0_DAY_ENA() volatile
    {
        IRQ_SETUP_0 |= 1u << 24u;
    }

    inline void clear_IRQ_SETUP_0_DAY_ENA() volatile
    {
        IRQ_SETUP_0 &= ~(1u << 24u);
    }

    inline void toggle_IRQ_SETUP_0_DAY_ENA() volatile
    {
        IRQ_SETUP_0 ^= 1u << 24u;
    }

    inline bool get_IRQ_SETUP_0_MONTH_ENA() volatile
    {
        return IRQ_SETUP_0 & (1u << 25u);
    }

    inline void set_IRQ_SETUP_0_MONTH_ENA() volatile
    {
        IRQ_SETUP_0 |= 1u << 25u;
    }

    inline void clear_IRQ_SETUP_0_MONTH_ENA() volatile
    {
        IRQ_SETUP_0 &= ~(1u << 25u);
    }

    inline void toggle_IRQ_SETUP_0_MONTH_ENA() volatile
    {
        IRQ_SETUP_0 ^= 1u << 25u;
    }

    inline bool get_IRQ_SETUP_0_YEAR_ENA() volatile
    {
        return IRQ_SETUP_0 & (1u << 26u);
    }

    inline void set_IRQ_SETUP_0_YEAR_ENA() volatile
    {
        IRQ_SETUP_0 |= 1u << 26u;
    }

    inline void clear_IRQ_SETUP_0_YEAR_ENA() volatile
    {
        IRQ_SETUP_0 &= ~(1u << 26u);
    }

    inline void toggle_IRQ_SETUP_0_YEAR_ENA() volatile
    {
        IRQ_SETUP_0 ^= 1u << 26u;
    }

    inline bool get_IRQ_SETUP_0_MATCH_ENA() volatile
    {
        return IRQ_SETUP_0 & (1u << 28u);
    }

    inline void set_IRQ_SETUP_0_MATCH_ENA() volatile
    {
        IRQ_SETUP_0 |= 1u << 28u;
    }

    inline void clear_IRQ_SETUP_0_MATCH_ENA() volatile
    {
        IRQ_SETUP_0 &= ~(1u << 28u);
    }

    inline void toggle_IRQ_SETUP_0_MATCH_ENA() volatile
    {
        IRQ_SETUP_0 ^= 1u << 28u;
    }

    inline bool get_IRQ_SETUP_0_MATCH_ACTIVE() volatile
    {
        return IRQ_SETUP_0 & (1u << 29u);
    }

    inline void get_IRQ_SETUP_0(uint8_t &DAY, uint8_t &MONTH, uint16_t &YEAR,
                                bool &DAY_ENA, bool &MONTH_ENA, bool &YEAR_ENA,
                                bool &MATCH_ENA, bool &MATCH_ACTIVE) volatile
    {
        uint32_t curr = IRQ_SETUP_0;

        DAY = (curr >> 0u) & 0b11111u;
        MONTH = (curr >> 8u) & 0b1111u;
        YEAR = (curr >> 12u) & 0b111111111111u;
        DAY_ENA = curr & (1u << 24u);
        MONTH_ENA = curr & (1u << 25u);
        YEAR_ENA = curr & (1u << 26u);
        MATCH_ENA = curr & (1u << 28u);
        MATCH_ACTIVE = curr & (1u << 29u);
    }

    inline void set_IRQ_SETUP_0(uint8_t DAY, uint8_t MONTH, uint16_t YEAR,
                                bool DAY_ENA, bool MONTH_ENA, bool YEAR_ENA,
                                bool MATCH_ENA) volatile
    {
        uint32_t curr = IRQ_SETUP_0;

        curr &= ~(0b11111u << 0u);
        curr |= (DAY & 0b11111u) << 0u;
        curr &= ~(0b1111u << 8u);
        curr |= (MONTH & 0b1111u) << 8u;
        curr &= ~(0b111111111111u << 12u);
        curr |= (YEAR & 0b111111111111u) << 12u;
        curr &= ~(0b1u << 24u);
        curr |= (DAY_ENA & 0b1u) << 24u;
        curr &= ~(0b1u << 25u);
        curr |= (MONTH_ENA & 0b1u) << 25u;
        curr &= ~(0b1u << 26u);
        curr |= (YEAR_ENA & 0b1u) << 26u;
        curr &= ~(0b1u << 28u);
        curr |= (MATCH_ENA & 0b1u) << 28u;

        IRQ_SETUP_0 = curr;
    }

    inline uint8_t get_IRQ_SETUP_1_SEC() volatile
    {
        return (IRQ_SETUP_1 >> 0u) & 0b111111u;
    }

    inline void set_IRQ_SETUP_1_SEC(uint8_t value) volatile
    {
        uint32_t curr = IRQ_SETUP_1;

        curr &= ~(0b111111u << 0u);
        curr |= (value & 0b111111u) << 0u;

        IRQ_SETUP_1 = curr;
    }

    inline uint8_t get_IRQ_SETUP_1_MIN() volatile
    {
        return (IRQ_SETUP_1 >> 8u) & 0b111111u;
    }

    inline void set_IRQ_SETUP_1_MIN(uint8_t value) volatile
    {
        uint32_t curr = IRQ_SETUP_1;

        curr &= ~(0b111111u << 8u);
        curr |= (value & 0b111111u) << 8u;

        IRQ_SETUP_1 = curr;
    }

    inline uint8_t get_IRQ_SETUP_1_HOUR() volatile
    {
        return (IRQ_SETUP_1 >> 16u) & 0b11111u;
    }

    inline void set_IRQ_SETUP_1_HOUR(uint8_t value) volatile
    {
        uint32_t curr = IRQ_SETUP_1;

        curr &= ~(0b11111u << 16u);
        curr |= (value & 0b11111u) << 16u;

        IRQ_SETUP_1 = curr;
    }

    inline uint8_t get_IRQ_SETUP_1_DOTW() volatile
    {
        return (IRQ_SETUP_1 >> 24u) & 0b111u;
    }

    inline void set_IRQ_SETUP_1_DOTW(uint8_t value) volatile
    {
        uint32_t curr = IRQ_SETUP_1;

        curr &= ~(0b111u << 24u);
        curr |= (value & 0b111u) << 24u;

        IRQ_SETUP_1 = curr;
    }

    inline bool get_IRQ_SETUP_1_SEC_ENA() volatile
    {
        return IRQ_SETUP_1 & (1u << 28u);
    }

    inline void set_IRQ_SETUP_1_SEC_ENA() volatile
    {
        IRQ_SETUP_1 |= 1u << 28u;
    }

    inline void clear_IRQ_SETUP_1_SEC_ENA() volatile
    {
        IRQ_SETUP_1 &= ~(1u << 28u);
    }

    inline void toggle_IRQ_SETUP_1_SEC_ENA() volatile
    {
        IRQ_SETUP_1 ^= 1u << 28u;
    }

    inline bool get_IRQ_SETUP_1_MIN_ENA() volatile
    {
        return IRQ_SETUP_1 & (1u << 29u);
    }

    inline void set_IRQ_SETUP_1_MIN_ENA() volatile
    {
        IRQ_SETUP_1 |= 1u << 29u;
    }

    inline void clear_IRQ_SETUP_1_MIN_ENA() volatile
    {
        IRQ_SETUP_1 &= ~(1u << 29u);
    }

    inline void toggle_IRQ_SETUP_1_MIN_ENA() volatile
    {
        IRQ_SETUP_1 ^= 1u << 29u;
    }

    inline bool get_IRQ_SETUP_1_HOUR_ENA() volatile
    {
        return IRQ_SETUP_1 & (1u << 30u);
    }

    inline void set_IRQ_SETUP_1_HOUR_ENA() volatile
    {
        IRQ_SETUP_1 |= 1u << 30u;
    }

    inline void clear_IRQ_SETUP_1_HOUR_ENA() volatile
    {
        IRQ_SETUP_1 &= ~(1u << 30u);
    }

    inline void toggle_IRQ_SETUP_1_HOUR_ENA() volatile
    {
        IRQ_SETUP_1 ^= 1u << 30u;
    }

    inline bool get_IRQ_SETUP_1_DOTW_ENA() volatile
    {
        return IRQ_SETUP_1 & (1u << 31u);
    }

    inline void set_IRQ_SETUP_1_DOTW_ENA() volatile
    {
        IRQ_SETUP_1 |= 1u << 31u;
    }

    inline void clear_IRQ_SETUP_1_DOTW_ENA() volatile
    {
        IRQ_SETUP_1 &= ~(1u << 31u);
    }

    inline void toggle_IRQ_SETUP_1_DOTW_ENA() volatile
    {
        IRQ_SETUP_1 ^= 1u << 31u;
    }

    inline void get_IRQ_SETUP_1(uint8_t &SEC, uint8_t &MIN, uint8_t &HOUR,
                                uint8_t &DOTW, bool &SEC_ENA, bool &MIN_ENA,
                                bool &HOUR_ENA, bool &DOTW_ENA) volatile
    {
        uint32_t curr = IRQ_SETUP_1;

        SEC = (curr >> 0u) & 0b111111u;
        MIN = (curr >> 8u) & 0b111111u;
        HOUR = (curr >> 16u) & 0b11111u;
        DOTW = (curr >> 24u) & 0b111u;
        SEC_ENA = curr & (1u << 28u);
        MIN_ENA = curr & (1u << 29u);
        HOUR_ENA = curr & (1u << 30u);
        DOTW_ENA = curr & (1u << 31u);
    }

    inline void set_IRQ_SETUP_1(uint8_t SEC, uint8_t MIN, uint8_t HOUR,
                                uint8_t DOTW, bool SEC_ENA, bool MIN_ENA,
                                bool HOUR_ENA, bool DOTW_ENA) volatile
    {
        uint32_t curr = IRQ_SETUP_1;

        curr &= ~(0b111111u << 0u);
        curr |= (SEC & 0b111111u) << 0u;
        curr &= ~(0b111111u << 8u);
        curr |= (MIN & 0b111111u) << 8u;
        curr &= ~(0b11111u << 16u);
        curr |= (HOUR & 0b11111u) << 16u;
        curr &= ~(0b111u << 24u);
        curr |= (DOTW & 0b111u) << 24u;
        curr &= ~(0b1u << 28u);
        curr |= (SEC_ENA & 0b1u) << 28u;
        curr &= ~(0b1u << 29u);
        curr |= (MIN_ENA & 0b1u) << 29u;
        curr &= ~(0b1u << 30u);
        curr |= (HOUR_ENA & 0b1u) << 30u;
        curr &= ~(0b1u << 31u);
        curr |= (DOTW_ENA & 0b1u) << 31u;

        IRQ_SETUP_1 = curr;
    }

    inline uint8_t get_RTC_1_DAY() volatile
    {
        return (RTC_1 >> 0u) & 0b11111u;
    }

    inline uint8_t get_RTC_1_MONTH() volatile
    {
        return (RTC_1 >> 8u) & 0b1111u;
    }

    inline uint16_t get_RTC_1_YEAR() volatile
    {
        return (RTC_1 >> 12u) & 0b111111111111u;
    }

    inline void get_RTC_1(uint8_t &DAY, uint8_t &MONTH,
                          uint16_t &YEAR) volatile
    {
        uint32_t curr = RTC_1;

        DAY = (curr >> 0u) & 0b11111u;
        MONTH = (curr >> 8u) & 0b1111u;
        YEAR = (curr >> 12u) & 0b111111111111u;
    }

    inline uint8_t get_RTC_0_SEC() volatile
    {
        return (RTC_0 >> 0u) & 0b111111u;
    }

    inline uint8_t get_RTC_0_MIN() volatile
    {
        return (RTC_0 >> 8u) & 0b111111u;
    }

    inline uint8_t get_RTC_0_HOUR() volatile
    {
        return (RTC_0 >> 16u) & 0b11111u;
    }

    inline uint8_t get_RTC_0_DOTW() volatile
    {
        return (RTC_0 >> 24u) & 0b111u;
    }

    inline void get_RTC_0(uint8_t &SEC, uint8_t &MIN, uint8_t &HOUR,
                          uint8_t &DOTW) volatile
    {
        uint32_t curr = RTC_0;

        SEC = (curr >> 0u) & 0b111111u;
        MIN = (curr >> 8u) & 0b111111u;
        HOUR = (curr >> 16u) & 0b11111u;
        DOTW = (curr >> 24u) & 0b111u;
    }

    inline bool get_INTR_RTC() volatile
    {
        return INTR & (1u << 0u);
    }

    inline bool get_INTE_RTC() volatile
    {
        return INTE & (1u << 0u);
    }

    inline void set_INTE_RTC() volatile
    {
        INTE |= 1u << 0u;
    }

    inline void clear_INTE_RTC() volatile
    {
        INTE &= ~(1u << 0u);
    }

    inline void toggle_INTE_RTC() volatile
    {
        INTE ^= 1u << 0u;
    }

    inline bool get_INTF_RTC() volatile
    {
        return INTF & (1u << 0u);
    }

    inline void set_INTF_RTC() volatile
    {
        INTF |= 1u << 0u;
    }

    inline void clear_INTF_RTC() volatile
    {
        INTF &= ~(1u << 0u);
    }

    inline void toggle_INTF_RTC() volatile
    {
        INTF ^= 1u << 0u;
    }

    inline bool get_INTS_RTC() volatile
    {
        return INTS & (1u << 0u);
    }
};

static_assert(sizeof(rtc) == rtc::size);

static volatile rtc *const RTC = reinterpret_cast<rtc *>(0x4005c000);

}; // namespace RP2040