Program Listing for File adc.h

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

#pragma once

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

namespace RP2040
{

struct [[gnu::packed]] adc
{
    /* Constant attributes. */
    static constexpr std::size_t size = 36;
    /* Fields. */
    uint32_t CS;
    const uint32_t RESULT =
        {};
    uint32_t FCS;
    const uint32_t FIFO = {};
    uint32_t DIV;
    const uint32_t INTR = {};
    uint32_t INTE;
    uint32_t INTF;
    const uint32_t INTS =
        {};
    /* Methods. */

    inline bool get_CS_EN() volatile
    {
        return CS & (1u << 0u);
    }

    inline void set_CS_EN() volatile
    {
        CS |= 1u << 0u;
    }

    inline void clear_CS_EN() volatile
    {
        CS &= ~(1u << 0u);
    }

    inline void toggle_CS_EN() volatile
    {
        CS ^= 1u << 0u;
    }

    inline bool get_CS_TS_EN() volatile
    {
        return CS & (1u << 1u);
    }

    inline void set_CS_TS_EN() volatile
    {
        CS |= 1u << 1u;
    }

    inline void clear_CS_TS_EN() volatile
    {
        CS &= ~(1u << 1u);
    }

    inline void toggle_CS_TS_EN() volatile
    {
        CS ^= 1u << 1u;
    }

    inline bool get_CS_START_ONCE() volatile
    {
        return CS & (1u << 2u);
    }

    inline void set_CS_START_ONCE() volatile
    {
        CS |= 1u << 2u;
    }

    inline void clear_CS_START_ONCE() volatile
    {
        CS &= ~(1u << 2u);
    }

    inline void toggle_CS_START_ONCE() volatile
    {
        CS ^= 1u << 2u;
    }

    inline bool get_CS_START_MANY() volatile
    {
        return CS & (1u << 3u);
    }

    inline void set_CS_START_MANY() volatile
    {
        CS |= 1u << 3u;
    }

    inline void clear_CS_START_MANY() volatile
    {
        CS &= ~(1u << 3u);
    }

    inline void toggle_CS_START_MANY() volatile
    {
        CS ^= 1u << 3u;
    }

    inline bool get_CS_READY() volatile
    {
        return CS & (1u << 8u);
    }

    inline bool get_CS_ERR() volatile
    {
        return CS & (1u << 9u);
    }

    inline bool get_CS_ERR_STICKY() volatile
    {
        return CS & (1u << 10u);
    }

    inline void set_CS_ERR_STICKY() volatile
    {
        CS |= 1u << 10u;
    }

    inline void clear_CS_ERR_STICKY() volatile
    {
        CS &= ~(1u << 10u);
    }

    inline void toggle_CS_ERR_STICKY() volatile
    {
        CS ^= 1u << 10u;
    }

    inline uint8_t get_CS_AINSEL() volatile
    {
        return (CS >> 12u) & 0b111u;
    }

    inline void set_CS_AINSEL(uint8_t value) volatile
    {
        uint32_t curr = CS;

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

        CS = curr;
    }

    inline uint8_t get_CS_RROBIN() volatile
    {
        return (CS >> 16u) & 0b11111u;
    }

    inline void set_CS_RROBIN(uint8_t value) volatile
    {
        uint32_t curr = CS;

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

        CS = curr;
    }

    inline void get_CS(bool &EN, bool &TS_EN, bool &START_ONCE,
                       bool &START_MANY, bool &READY, bool &ERR,
                       bool &ERR_STICKY, uint8_t &AINSEL,
                       uint8_t &RROBIN) volatile
    {
        uint32_t curr = CS;

        EN = curr & (1u << 0u);
        TS_EN = curr & (1u << 1u);
        START_ONCE = curr & (1u << 2u);
        START_MANY = curr & (1u << 3u);
        READY = curr & (1u << 8u);
        ERR = curr & (1u << 9u);
        ERR_STICKY = curr & (1u << 10u);
        AINSEL = (curr >> 12u) & 0b111u;
        RROBIN = (curr >> 16u) & 0b11111u;
    }

    inline void set_CS(bool EN, bool TS_EN, bool START_ONCE, bool START_MANY,
                       bool ERR_STICKY, uint8_t AINSEL,
                       uint8_t RROBIN) volatile
    {
        uint32_t curr = CS;

        curr &= ~(0b1u << 0u);
        curr |= (EN & 0b1u) << 0u;
        curr &= ~(0b1u << 1u);
        curr |= (TS_EN & 0b1u) << 1u;
        curr &= ~(0b1u << 2u);
        curr |= (START_ONCE & 0b1u) << 2u;
        curr &= ~(0b1u << 3u);
        curr |= (START_MANY & 0b1u) << 3u;
        curr &= ~(0b1u << 10u);
        curr |= (ERR_STICKY & 0b1u) << 10u;
        curr &= ~(0b111u << 12u);
        curr |= (AINSEL & 0b111u) << 12u;
        curr &= ~(0b11111u << 16u);
        curr |= (RROBIN & 0b11111u) << 16u;

        CS = curr;
    }

    inline uint16_t get_RESULT_RESULT() volatile
    {
        return (RESULT >> 0u) & 0b111111111111u;
    }

    inline bool get_FCS_EN() volatile
    {
        return FCS & (1u << 0u);
    }

    inline void set_FCS_EN() volatile
    {
        FCS |= 1u << 0u;
    }

    inline void clear_FCS_EN() volatile
    {
        FCS &= ~(1u << 0u);
    }

    inline void toggle_FCS_EN() volatile
    {
        FCS ^= 1u << 0u;
    }

    inline bool get_FCS_SHIFT() volatile
    {
        return FCS & (1u << 1u);
    }

    inline void set_FCS_SHIFT() volatile
    {
        FCS |= 1u << 1u;
    }

    inline void clear_FCS_SHIFT() volatile
    {
        FCS &= ~(1u << 1u);
    }

    inline void toggle_FCS_SHIFT() volatile
    {
        FCS ^= 1u << 1u;
    }

    inline bool get_FCS_ERR() volatile
    {
        return FCS & (1u << 2u);
    }

    inline void set_FCS_ERR() volatile
    {
        FCS |= 1u << 2u;
    }

    inline void clear_FCS_ERR() volatile
    {
        FCS &= ~(1u << 2u);
    }

    inline void toggle_FCS_ERR() volatile
    {
        FCS ^= 1u << 2u;
    }

    inline bool get_FCS_DREQ_EN() volatile
    {
        return FCS & (1u << 3u);
    }

    inline void set_FCS_DREQ_EN() volatile
    {
        FCS |= 1u << 3u;
    }

    inline void clear_FCS_DREQ_EN() volatile
    {
        FCS &= ~(1u << 3u);
    }

    inline void toggle_FCS_DREQ_EN() volatile
    {
        FCS ^= 1u << 3u;
    }

    inline bool get_FCS_EMPTY() volatile
    {
        return FCS & (1u << 8u);
    }

    inline bool get_FCS_FULL() volatile
    {
        return FCS & (1u << 9u);
    }

    inline bool get_FCS_UNDER() volatile
    {
        return FCS & (1u << 10u);
    }

    inline void set_FCS_UNDER() volatile
    {
        FCS |= 1u << 10u;
    }

    inline void clear_FCS_UNDER() volatile
    {
        FCS &= ~(1u << 10u);
    }

    inline void toggle_FCS_UNDER() volatile
    {
        FCS ^= 1u << 10u;
    }

    inline bool get_FCS_OVER() volatile
    {
        return FCS & (1u << 11u);
    }

    inline void set_FCS_OVER() volatile
    {
        FCS |= 1u << 11u;
    }

    inline void clear_FCS_OVER() volatile
    {
        FCS &= ~(1u << 11u);
    }

    inline void toggle_FCS_OVER() volatile
    {
        FCS ^= 1u << 11u;
    }

    inline uint8_t get_FCS_LEVEL() volatile
    {
        return (FCS >> 16u) & 0b1111u;
    }

    inline uint8_t get_FCS_THRESH() volatile
    {
        return (FCS >> 24u) & 0b1111u;
    }

    inline void set_FCS_THRESH(uint8_t value) volatile
    {
        uint32_t curr = FCS;

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

        FCS = curr;
    }

    inline void get_FCS(bool &EN, bool &SHIFT, bool &ERR, bool &DREQ_EN,
                        bool &EMPTY, bool &FULL, bool &UNDER, bool &OVER,
                        uint8_t &LEVEL, uint8_t &THRESH) volatile
    {
        uint32_t curr = FCS;

        EN = curr & (1u << 0u);
        SHIFT = curr & (1u << 1u);
        ERR = curr & (1u << 2u);
        DREQ_EN = curr & (1u << 3u);
        EMPTY = curr & (1u << 8u);
        FULL = curr & (1u << 9u);
        UNDER = curr & (1u << 10u);
        OVER = curr & (1u << 11u);
        LEVEL = (curr >> 16u) & 0b1111u;
        THRESH = (curr >> 24u) & 0b1111u;
    }

    inline void set_FCS(bool EN, bool SHIFT, bool ERR, bool DREQ_EN,
                        bool UNDER, bool OVER, uint8_t THRESH) volatile
    {
        uint32_t curr = FCS;

        curr &= ~(0b1u << 0u);
        curr |= (EN & 0b1u) << 0u;
        curr &= ~(0b1u << 1u);
        curr |= (SHIFT & 0b1u) << 1u;
        curr &= ~(0b1u << 2u);
        curr |= (ERR & 0b1u) << 2u;
        curr &= ~(0b1u << 3u);
        curr |= (DREQ_EN & 0b1u) << 3u;
        curr &= ~(0b1u << 10u);
        curr |= (UNDER & 0b1u) << 10u;
        curr &= ~(0b1u << 11u);
        curr |= (OVER & 0b1u) << 11u;
        curr &= ~(0b1111u << 24u);
        curr |= (THRESH & 0b1111u) << 24u;

        FCS = curr;
    }

    inline uint16_t get_FIFO_VAL() volatile
    {
        return (FIFO >> 0u) & 0b111111111111u;
    }

    inline bool get_FIFO_ERR() volatile
    {
        return FIFO & (1u << 15u);
    }

    inline void get_FIFO(uint16_t &VAL, bool &ERR) volatile
    {
        uint32_t curr = FIFO;

        VAL = (curr >> 0u) & 0b111111111111u;
        ERR = curr & (1u << 15u);
    }

    inline uint8_t get_DIV_FRAC() volatile
    {
        return (DIV >> 0u) & 0b11111111u;
    }

    inline void set_DIV_FRAC(uint8_t value) volatile
    {
        uint32_t curr = DIV;

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

        DIV = curr;
    }

    inline uint16_t get_DIV_INT() volatile
    {
        return (DIV >> 8u) & 0b1111111111111111u;
    }

    inline void set_DIV_INT(uint16_t value) volatile
    {
        uint32_t curr = DIV;

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

        DIV = curr;
    }

    inline void get_DIV(uint8_t &FRAC, uint16_t &INT) volatile
    {
        uint32_t curr = DIV;

        FRAC = (curr >> 0u) & 0b11111111u;
        INT = (curr >> 8u) & 0b1111111111111111u;
    }

    inline void set_DIV(uint8_t FRAC, uint16_t INT) volatile
    {
        uint32_t curr = DIV;

        curr &= ~(0b11111111u << 0u);
        curr |= (FRAC & 0b11111111u) << 0u;
        curr &= ~(0b1111111111111111u << 8u);
        curr |= (INT & 0b1111111111111111u) << 8u;

        DIV = curr;
    }

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

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

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

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

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

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

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

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

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

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

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

static volatile adc *const ADC = reinterpret_cast<adc *>(0x4004c000);

}; // namespace RP2040