Program Listing for File pwm.h#
↰ Return to documentation for file (src/generated/structs/pwm.h)
#pragma once
#include "../enums/PWM_CH0_CSR_DIVMODE.h"
#include "../enums/PWM_CH1_CSR_DIVMODE.h"
#include "../enums/PWM_CH2_CSR_DIVMODE.h"
#include "../enums/PWM_CH3_CSR_DIVMODE.h"
#include "../enums/PWM_CH4_CSR_DIVMODE.h"
#include "../enums/PWM_CH5_CSR_DIVMODE.h"
#include "../enums/PWM_CH6_CSR_DIVMODE.h"
#include "../enums/PWM_CH7_CSR_DIVMODE.h"
#include "../ifgen/common.h"
namespace RP2040
{
struct [[gnu::packed]] pwm
{
/* Constant attributes. */
static constexpr std::size_t size = 180;
/* Fields. */
uint32_t CH0_CSR;
uint32_t
CH0_DIV;
uint32_t CH0_CTR;
uint32_t CH0_CC;
uint32_t CH0_TOP;
uint32_t CH1_CSR;
uint32_t
CH1_DIV;
uint32_t CH1_CTR;
uint32_t CH1_CC;
uint32_t CH1_TOP;
uint32_t CH2_CSR;
uint32_t
CH2_DIV;
uint32_t CH2_CTR;
uint32_t CH2_CC;
uint32_t CH2_TOP;
uint32_t CH3_CSR;
uint32_t
CH3_DIV;
uint32_t CH3_CTR;
uint32_t CH3_CC;
uint32_t CH3_TOP;
uint32_t CH4_CSR;
uint32_t
CH4_DIV;
uint32_t CH4_CTR;
uint32_t CH4_CC;
uint32_t CH4_TOP;
uint32_t CH5_CSR;
uint32_t
CH5_DIV;
uint32_t CH5_CTR;
uint32_t CH5_CC;
uint32_t CH5_TOP;
uint32_t CH6_CSR;
uint32_t
CH6_DIV;
uint32_t CH6_CTR;
uint32_t CH6_CC;
uint32_t CH6_TOP;
uint32_t CH7_CSR;
uint32_t
CH7_DIV;
uint32_t CH7_CTR;
uint32_t CH7_CC;
uint32_t CH7_TOP;
uint32_t EN;
uint32_t INTR;
uint32_t INTE;
uint32_t INTF;
const uint32_t INTS =
{};
/* Methods. */
inline bool get_CH0_CSR_EN() volatile
{
return CH0_CSR & (1u << 0u);
}
inline void set_CH0_CSR_EN() volatile
{
CH0_CSR |= 1u << 0u;
}
inline void clear_CH0_CSR_EN() volatile
{
CH0_CSR &= ~(1u << 0u);
}
inline void toggle_CH0_CSR_EN() volatile
{
CH0_CSR ^= 1u << 0u;
}
inline bool get_CH0_CSR_PH_CORRECT() volatile
{
return CH0_CSR & (1u << 1u);
}
inline void set_CH0_CSR_PH_CORRECT() volatile
{
CH0_CSR |= 1u << 1u;
}
inline void clear_CH0_CSR_PH_CORRECT() volatile
{
CH0_CSR &= ~(1u << 1u);
}
inline void toggle_CH0_CSR_PH_CORRECT() volatile
{
CH0_CSR ^= 1u << 1u;
}
inline bool get_CH0_CSR_A_INV() volatile
{
return CH0_CSR & (1u << 2u);
}
inline void set_CH0_CSR_A_INV() volatile
{
CH0_CSR |= 1u << 2u;
}
inline void clear_CH0_CSR_A_INV() volatile
{
CH0_CSR &= ~(1u << 2u);
}
inline void toggle_CH0_CSR_A_INV() volatile
{
CH0_CSR ^= 1u << 2u;
}
inline bool get_CH0_CSR_B_INV() volatile
{
return CH0_CSR & (1u << 3u);
}
inline void set_CH0_CSR_B_INV() volatile
{
CH0_CSR |= 1u << 3u;
}
inline void clear_CH0_CSR_B_INV() volatile
{
CH0_CSR &= ~(1u << 3u);
}
inline void toggle_CH0_CSR_B_INV() volatile
{
CH0_CSR ^= 1u << 3u;
}
inline PWM_CH0_CSR_DIVMODE get_CH0_CSR_DIVMODE() volatile
{
return PWM_CH0_CSR_DIVMODE((CH0_CSR >> 4u) & 0b11u);
}
inline void set_CH0_CSR_DIVMODE(PWM_CH0_CSR_DIVMODE value) volatile
{
uint32_t curr = CH0_CSR;
curr &= ~(0b11u << 4u);
curr |= (std::to_underlying(value) & 0b11u) << 4u;
CH0_CSR = curr;
}
inline bool get_CH0_CSR_PH_RET() volatile
{
return CH0_CSR & (1u << 6u);
}
inline void set_CH0_CSR_PH_RET() volatile
{
CH0_CSR |= 1u << 6u;
}
inline void clear_CH0_CSR_PH_RET() volatile
{
CH0_CSR &= ~(1u << 6u);
}
inline void toggle_CH0_CSR_PH_RET() volatile
{
CH0_CSR ^= 1u << 6u;
}
inline bool get_CH0_CSR_PH_ADV() volatile
{
return CH0_CSR & (1u << 7u);
}
inline void set_CH0_CSR_PH_ADV() volatile
{
CH0_CSR |= 1u << 7u;
}
inline void clear_CH0_CSR_PH_ADV() volatile
{
CH0_CSR &= ~(1u << 7u);
}
inline void toggle_CH0_CSR_PH_ADV() volatile
{
CH0_CSR ^= 1u << 7u;
}
inline void get_CH0_CSR(bool &EN, bool &PH_CORRECT, bool &A_INV,
bool &B_INV, PWM_CH0_CSR_DIVMODE &DIVMODE,
bool &PH_RET, bool &PH_ADV) volatile
{
uint32_t curr = CH0_CSR;
EN = curr & (1u << 0u);
PH_CORRECT = curr & (1u << 1u);
A_INV = curr & (1u << 2u);
B_INV = curr & (1u << 3u);
DIVMODE = PWM_CH0_CSR_DIVMODE((curr >> 4u) & 0b11u);
PH_RET = curr & (1u << 6u);
PH_ADV = curr & (1u << 7u);
}
inline void set_CH0_CSR(bool EN, bool PH_CORRECT, bool A_INV, bool B_INV,
PWM_CH0_CSR_DIVMODE DIVMODE, bool PH_RET,
bool PH_ADV) volatile
{
uint32_t curr = CH0_CSR;
curr &= ~(0b1u << 0u);
curr |= (EN & 0b1u) << 0u;
curr &= ~(0b1u << 1u);
curr |= (PH_CORRECT & 0b1u) << 1u;
curr &= ~(0b1u << 2u);
curr |= (A_INV & 0b1u) << 2u;
curr &= ~(0b1u << 3u);
curr |= (B_INV & 0b1u) << 3u;
curr &= ~(0b11u << 4u);
curr |= (std::to_underlying(DIVMODE) & 0b11u) << 4u;
curr &= ~(0b1u << 6u);
curr |= (PH_RET & 0b1u) << 6u;
curr &= ~(0b1u << 7u);
curr |= (PH_ADV & 0b1u) << 7u;
CH0_CSR = curr;
}
inline uint8_t get_CH0_DIV_FRAC() volatile
{
return (CH0_DIV >> 0u) & 0b1111u;
}
inline void set_CH0_DIV_FRAC(uint8_t value) volatile
{
uint32_t curr = CH0_DIV;
curr &= ~(0b1111u << 0u);
curr |= (value & 0b1111u) << 0u;
CH0_DIV = curr;
}
inline uint8_t get_CH0_DIV_INT() volatile
{
return (CH0_DIV >> 4u) & 0b11111111u;
}
inline void set_CH0_DIV_INT(uint8_t value) volatile
{
uint32_t curr = CH0_DIV;
curr &= ~(0b11111111u << 4u);
curr |= (value & 0b11111111u) << 4u;
CH0_DIV = curr;
}
inline void get_CH0_DIV(uint8_t &FRAC, uint8_t &INT) volatile
{
uint32_t curr = CH0_DIV;
FRAC = (curr >> 0u) & 0b1111u;
INT = (curr >> 4u) & 0b11111111u;
}
inline void set_CH0_DIV(uint8_t FRAC, uint8_t INT) volatile
{
uint32_t curr = CH0_DIV;
curr &= ~(0b1111u << 0u);
curr |= (FRAC & 0b1111u) << 0u;
curr &= ~(0b11111111u << 4u);
curr |= (INT & 0b11111111u) << 4u;
CH0_DIV = curr;
}
inline uint16_t get_CH0_CTR_CH0_CTR() volatile
{
return (CH0_CTR >> 0u) & 0b1111111111111111u;
}
inline void set_CH0_CTR_CH0_CTR(uint16_t value) volatile
{
uint32_t curr = CH0_CTR;
curr &= ~(0b1111111111111111u << 0u);
curr |= (value & 0b1111111111111111u) << 0u;
CH0_CTR = curr;
}
inline uint16_t get_CH0_CC_A() volatile
{
return (CH0_CC >> 0u) & 0b1111111111111111u;
}
inline void set_CH0_CC_A(uint16_t value) volatile
{
uint32_t curr = CH0_CC;
curr &= ~(0b1111111111111111u << 0u);
curr |= (value & 0b1111111111111111u) << 0u;
CH0_CC = curr;
}
inline uint16_t get_CH0_CC_B() volatile
{
return (CH0_CC >> 16u) & 0b1111111111111111u;
}
inline void set_CH0_CC_B(uint16_t value) volatile
{
uint32_t curr = CH0_CC;
curr &= ~(0b1111111111111111u << 16u);
curr |= (value & 0b1111111111111111u) << 16u;
CH0_CC = curr;
}
inline void get_CH0_CC(uint16_t &A, uint16_t &B) volatile
{
uint32_t curr = CH0_CC;
A = (curr >> 0u) & 0b1111111111111111u;
B = (curr >> 16u) & 0b1111111111111111u;
}
inline void set_CH0_CC(uint16_t A, uint16_t B) volatile
{
uint32_t curr = CH0_CC;
curr &= ~(0b1111111111111111u << 0u);
curr |= (A & 0b1111111111111111u) << 0u;
curr &= ~(0b1111111111111111u << 16u);
curr |= (B & 0b1111111111111111u) << 16u;
CH0_CC = curr;
}
inline uint16_t get_CH0_TOP_CH0_TOP() volatile
{
return (CH0_TOP >> 0u) & 0b1111111111111111u;
}
inline void set_CH0_TOP_CH0_TOP(uint16_t value) volatile
{
uint32_t curr = CH0_TOP;
curr &= ~(0b1111111111111111u << 0u);
curr |= (value & 0b1111111111111111u) << 0u;
CH0_TOP = curr;
}
inline bool get_CH1_CSR_EN() volatile
{
return CH1_CSR & (1u << 0u);
}
inline void set_CH1_CSR_EN() volatile
{
CH1_CSR |= 1u << 0u;
}
inline void clear_CH1_CSR_EN() volatile
{
CH1_CSR &= ~(1u << 0u);
}
inline void toggle_CH1_CSR_EN() volatile
{
CH1_CSR ^= 1u << 0u;
}
inline bool get_CH1_CSR_PH_CORRECT() volatile
{
return CH1_CSR & (1u << 1u);
}
inline void set_CH1_CSR_PH_CORRECT() volatile
{
CH1_CSR |= 1u << 1u;
}
inline void clear_CH1_CSR_PH_CORRECT() volatile
{
CH1_CSR &= ~(1u << 1u);
}
inline void toggle_CH1_CSR_PH_CORRECT() volatile
{
CH1_CSR ^= 1u << 1u;
}
inline bool get_CH1_CSR_A_INV() volatile
{
return CH1_CSR & (1u << 2u);
}
inline void set_CH1_CSR_A_INV() volatile
{
CH1_CSR |= 1u << 2u;
}
inline void clear_CH1_CSR_A_INV() volatile
{
CH1_CSR &= ~(1u << 2u);
}
inline void toggle_CH1_CSR_A_INV() volatile
{
CH1_CSR ^= 1u << 2u;
}
inline bool get_CH1_CSR_B_INV() volatile
{
return CH1_CSR & (1u << 3u);
}
inline void set_CH1_CSR_B_INV() volatile
{
CH1_CSR |= 1u << 3u;
}
inline void clear_CH1_CSR_B_INV() volatile
{
CH1_CSR &= ~(1u << 3u);
}
inline void toggle_CH1_CSR_B_INV() volatile
{
CH1_CSR ^= 1u << 3u;
}
inline PWM_CH1_CSR_DIVMODE get_CH1_CSR_DIVMODE() volatile
{
return PWM_CH1_CSR_DIVMODE((CH1_CSR >> 4u) & 0b11u);
}
inline void set_CH1_CSR_DIVMODE(PWM_CH1_CSR_DIVMODE value) volatile
{
uint32_t curr = CH1_CSR;
curr &= ~(0b11u << 4u);
curr |= (std::to_underlying(value) & 0b11u) << 4u;
CH1_CSR = curr;
}
inline bool get_CH1_CSR_PH_RET() volatile
{
return CH1_CSR & (1u << 6u);
}
inline void set_CH1_CSR_PH_RET() volatile
{
CH1_CSR |= 1u << 6u;
}
inline void clear_CH1_CSR_PH_RET() volatile
{
CH1_CSR &= ~(1u << 6u);
}
inline void toggle_CH1_CSR_PH_RET() volatile
{
CH1_CSR ^= 1u << 6u;
}
inline bool get_CH1_CSR_PH_ADV() volatile
{
return CH1_CSR & (1u << 7u);
}
inline void set_CH1_CSR_PH_ADV() volatile
{
CH1_CSR |= 1u << 7u;
}
inline void clear_CH1_CSR_PH_ADV() volatile
{
CH1_CSR &= ~(1u << 7u);
}
inline void toggle_CH1_CSR_PH_ADV() volatile
{
CH1_CSR ^= 1u << 7u;
}
inline void get_CH1_CSR(bool &EN, bool &PH_CORRECT, bool &A_INV,
bool &B_INV, PWM_CH1_CSR_DIVMODE &DIVMODE,
bool &PH_RET, bool &PH_ADV) volatile
{
uint32_t curr = CH1_CSR;
EN = curr & (1u << 0u);
PH_CORRECT = curr & (1u << 1u);
A_INV = curr & (1u << 2u);
B_INV = curr & (1u << 3u);
DIVMODE = PWM_CH1_CSR_DIVMODE((curr >> 4u) & 0b11u);
PH_RET = curr & (1u << 6u);
PH_ADV = curr & (1u << 7u);
}
inline void set_CH1_CSR(bool EN, bool PH_CORRECT, bool A_INV, bool B_INV,
PWM_CH1_CSR_DIVMODE DIVMODE, bool PH_RET,
bool PH_ADV) volatile
{
uint32_t curr = CH1_CSR;
curr &= ~(0b1u << 0u);
curr |= (EN & 0b1u) << 0u;
curr &= ~(0b1u << 1u);
curr |= (PH_CORRECT & 0b1u) << 1u;
curr &= ~(0b1u << 2u);
curr |= (A_INV & 0b1u) << 2u;
curr &= ~(0b1u << 3u);
curr |= (B_INV & 0b1u) << 3u;
curr &= ~(0b11u << 4u);
curr |= (std::to_underlying(DIVMODE) & 0b11u) << 4u;
curr &= ~(0b1u << 6u);
curr |= (PH_RET & 0b1u) << 6u;
curr &= ~(0b1u << 7u);
curr |= (PH_ADV & 0b1u) << 7u;
CH1_CSR = curr;
}
inline uint8_t get_CH1_DIV_FRAC() volatile
{
return (CH1_DIV >> 0u) & 0b1111u;
}
inline void set_CH1_DIV_FRAC(uint8_t value) volatile
{
uint32_t curr = CH1_DIV;
curr &= ~(0b1111u << 0u);
curr |= (value & 0b1111u) << 0u;
CH1_DIV = curr;
}
inline uint8_t get_CH1_DIV_INT() volatile
{
return (CH1_DIV >> 4u) & 0b11111111u;
}
inline void set_CH1_DIV_INT(uint8_t value) volatile
{
uint32_t curr = CH1_DIV;
curr &= ~(0b11111111u << 4u);
curr |= (value & 0b11111111u) << 4u;
CH1_DIV = curr;
}
inline void get_CH1_DIV(uint8_t &FRAC, uint8_t &INT) volatile
{
uint32_t curr = CH1_DIV;
FRAC = (curr >> 0u) & 0b1111u;
INT = (curr >> 4u) & 0b11111111u;
}
inline void set_CH1_DIV(uint8_t FRAC, uint8_t INT) volatile
{
uint32_t curr = CH1_DIV;
curr &= ~(0b1111u << 0u);
curr |= (FRAC & 0b1111u) << 0u;
curr &= ~(0b11111111u << 4u);
curr |= (INT & 0b11111111u) << 4u;
CH1_DIV = curr;
}
inline uint16_t get_CH1_CTR_CH1_CTR() volatile
{
return (CH1_CTR >> 0u) & 0b1111111111111111u;
}
inline void set_CH1_CTR_CH1_CTR(uint16_t value) volatile
{
uint32_t curr = CH1_CTR;
curr &= ~(0b1111111111111111u << 0u);
curr |= (value & 0b1111111111111111u) << 0u;
CH1_CTR = curr;
}
inline uint16_t get_CH1_CC_A() volatile
{
return (CH1_CC >> 0u) & 0b1111111111111111u;
}
inline void set_CH1_CC_A(uint16_t value) volatile
{
uint32_t curr = CH1_CC;
curr &= ~(0b1111111111111111u << 0u);
curr |= (value & 0b1111111111111111u) << 0u;
CH1_CC = curr;
}
inline uint16_t get_CH1_CC_B() volatile
{
return (CH1_CC >> 16u) & 0b1111111111111111u;
}
inline void set_CH1_CC_B(uint16_t value) volatile
{
uint32_t curr = CH1_CC;
curr &= ~(0b1111111111111111u << 16u);
curr |= (value & 0b1111111111111111u) << 16u;
CH1_CC = curr;
}
inline void get_CH1_CC(uint16_t &A, uint16_t &B) volatile
{
uint32_t curr = CH1_CC;
A = (curr >> 0u) & 0b1111111111111111u;
B = (curr >> 16u) & 0b1111111111111111u;
}
inline void set_CH1_CC(uint16_t A, uint16_t B) volatile
{
uint32_t curr = CH1_CC;
curr &= ~(0b1111111111111111u << 0u);
curr |= (A & 0b1111111111111111u) << 0u;
curr &= ~(0b1111111111111111u << 16u);
curr |= (B & 0b1111111111111111u) << 16u;
CH1_CC = curr;
}
inline uint16_t get_CH1_TOP_CH1_TOP() volatile
{
return (CH1_TOP >> 0u) & 0b1111111111111111u;
}
inline void set_CH1_TOP_CH1_TOP(uint16_t value) volatile
{
uint32_t curr = CH1_TOP;
curr &= ~(0b1111111111111111u << 0u);
curr |= (value & 0b1111111111111111u) << 0u;
CH1_TOP = curr;
}
inline bool get_CH2_CSR_EN() volatile
{
return CH2_CSR & (1u << 0u);
}
inline void set_CH2_CSR_EN() volatile
{
CH2_CSR |= 1u << 0u;
}
inline void clear_CH2_CSR_EN() volatile
{
CH2_CSR &= ~(1u << 0u);
}
inline void toggle_CH2_CSR_EN() volatile
{
CH2_CSR ^= 1u << 0u;
}
inline bool get_CH2_CSR_PH_CORRECT() volatile
{
return CH2_CSR & (1u << 1u);
}
inline void set_CH2_CSR_PH_CORRECT() volatile
{
CH2_CSR |= 1u << 1u;
}
inline void clear_CH2_CSR_PH_CORRECT() volatile
{
CH2_CSR &= ~(1u << 1u);
}
inline void toggle_CH2_CSR_PH_CORRECT() volatile
{
CH2_CSR ^= 1u << 1u;
}
inline bool get_CH2_CSR_A_INV() volatile
{
return CH2_CSR & (1u << 2u);
}
inline void set_CH2_CSR_A_INV() volatile
{
CH2_CSR |= 1u << 2u;
}
inline void clear_CH2_CSR_A_INV() volatile
{
CH2_CSR &= ~(1u << 2u);
}
inline void toggle_CH2_CSR_A_INV() volatile
{
CH2_CSR ^= 1u << 2u;
}
inline bool get_CH2_CSR_B_INV() volatile
{
return CH2_CSR & (1u << 3u);
}
inline void set_CH2_CSR_B_INV() volatile
{
CH2_CSR |= 1u << 3u;
}
inline void clear_CH2_CSR_B_INV() volatile
{
CH2_CSR &= ~(1u << 3u);
}
inline void toggle_CH2_CSR_B_INV() volatile
{
CH2_CSR ^= 1u << 3u;
}
inline PWM_CH2_CSR_DIVMODE get_CH2_CSR_DIVMODE() volatile
{
return PWM_CH2_CSR_DIVMODE((CH2_CSR >> 4u) & 0b11u);
}
inline void set_CH2_CSR_DIVMODE(PWM_CH2_CSR_DIVMODE value) volatile
{
uint32_t curr = CH2_CSR;
curr &= ~(0b11u << 4u);
curr |= (std::to_underlying(value) & 0b11u) << 4u;
CH2_CSR = curr;
}
inline bool get_CH2_CSR_PH_RET() volatile
{
return CH2_CSR & (1u << 6u);
}
inline void set_CH2_CSR_PH_RET() volatile
{
CH2_CSR |= 1u << 6u;
}
inline void clear_CH2_CSR_PH_RET() volatile
{
CH2_CSR &= ~(1u << 6u);
}
inline void toggle_CH2_CSR_PH_RET() volatile
{
CH2_CSR ^= 1u << 6u;
}
inline bool get_CH2_CSR_PH_ADV() volatile
{
return CH2_CSR & (1u << 7u);
}
inline void set_CH2_CSR_PH_ADV() volatile
{
CH2_CSR |= 1u << 7u;
}
inline void clear_CH2_CSR_PH_ADV() volatile
{
CH2_CSR &= ~(1u << 7u);
}
inline void toggle_CH2_CSR_PH_ADV() volatile
{
CH2_CSR ^= 1u << 7u;
}
inline void get_CH2_CSR(bool &EN, bool &PH_CORRECT, bool &A_INV,
bool &B_INV, PWM_CH2_CSR_DIVMODE &DIVMODE,
bool &PH_RET, bool &PH_ADV) volatile
{
uint32_t curr = CH2_CSR;
EN = curr & (1u << 0u);
PH_CORRECT = curr & (1u << 1u);
A_INV = curr & (1u << 2u);
B_INV = curr & (1u << 3u);
DIVMODE = PWM_CH2_CSR_DIVMODE((curr >> 4u) & 0b11u);
PH_RET = curr & (1u << 6u);
PH_ADV = curr & (1u << 7u);
}
inline void set_CH2_CSR(bool EN, bool PH_CORRECT, bool A_INV, bool B_INV,
PWM_CH2_CSR_DIVMODE DIVMODE, bool PH_RET,
bool PH_ADV) volatile
{
uint32_t curr = CH2_CSR;
curr &= ~(0b1u << 0u);
curr |= (EN & 0b1u) << 0u;
curr &= ~(0b1u << 1u);
curr |= (PH_CORRECT & 0b1u) << 1u;
curr &= ~(0b1u << 2u);
curr |= (A_INV & 0b1u) << 2u;
curr &= ~(0b1u << 3u);
curr |= (B_INV & 0b1u) << 3u;
curr &= ~(0b11u << 4u);
curr |= (std::to_underlying(DIVMODE) & 0b11u) << 4u;
curr &= ~(0b1u << 6u);
curr |= (PH_RET & 0b1u) << 6u;
curr &= ~(0b1u << 7u);
curr |= (PH_ADV & 0b1u) << 7u;
CH2_CSR = curr;
}
inline uint8_t get_CH2_DIV_FRAC() volatile
{
return (CH2_DIV >> 0u) & 0b1111u;
}
inline void set_CH2_DIV_FRAC(uint8_t value) volatile
{
uint32_t curr = CH2_DIV;
curr &= ~(0b1111u << 0u);
curr |= (value & 0b1111u) << 0u;
CH2_DIV = curr;
}
inline uint8_t get_CH2_DIV_INT() volatile
{
return (CH2_DIV >> 4u) & 0b11111111u;
}
inline void set_CH2_DIV_INT(uint8_t value) volatile
{
uint32_t curr = CH2_DIV;
curr &= ~(0b11111111u << 4u);
curr |= (value & 0b11111111u) << 4u;
CH2_DIV = curr;
}
inline void get_CH2_DIV(uint8_t &FRAC, uint8_t &INT) volatile
{
uint32_t curr = CH2_DIV;
FRAC = (curr >> 0u) & 0b1111u;
INT = (curr >> 4u) & 0b11111111u;
}
inline void set_CH2_DIV(uint8_t FRAC, uint8_t INT) volatile
{
uint32_t curr = CH2_DIV;
curr &= ~(0b1111u << 0u);
curr |= (FRAC & 0b1111u) << 0u;
curr &= ~(0b11111111u << 4u);
curr |= (INT & 0b11111111u) << 4u;
CH2_DIV = curr;
}
inline uint16_t get_CH2_CTR_CH2_CTR() volatile
{
return (CH2_CTR >> 0u) & 0b1111111111111111u;
}
inline void set_CH2_CTR_CH2_CTR(uint16_t value) volatile
{
uint32_t curr = CH2_CTR;
curr &= ~(0b1111111111111111u << 0u);
curr |= (value & 0b1111111111111111u) << 0u;
CH2_CTR = curr;
}
inline uint16_t get_CH2_CC_A() volatile
{
return (CH2_CC >> 0u) & 0b1111111111111111u;
}
inline void set_CH2_CC_A(uint16_t value) volatile
{
uint32_t curr = CH2_CC;
curr &= ~(0b1111111111111111u << 0u);
curr |= (value & 0b1111111111111111u) << 0u;
CH2_CC = curr;
}
inline uint16_t get_CH2_CC_B() volatile
{
return (CH2_CC >> 16u) & 0b1111111111111111u;
}
inline void set_CH2_CC_B(uint16_t value) volatile
{
uint32_t curr = CH2_CC;
curr &= ~(0b1111111111111111u << 16u);
curr |= (value & 0b1111111111111111u) << 16u;
CH2_CC = curr;
}
inline void get_CH2_CC(uint16_t &A, uint16_t &B) volatile
{
uint32_t curr = CH2_CC;
A = (curr >> 0u) & 0b1111111111111111u;
B = (curr >> 16u) & 0b1111111111111111u;
}
inline void set_CH2_CC(uint16_t A, uint16_t B) volatile
{
uint32_t curr = CH2_CC;
curr &= ~(0b1111111111111111u << 0u);
curr |= (A & 0b1111111111111111u) << 0u;
curr &= ~(0b1111111111111111u << 16u);
curr |= (B & 0b1111111111111111u) << 16u;
CH2_CC = curr;
}
inline uint16_t get_CH2_TOP_CH2_TOP() volatile
{
return (CH2_TOP >> 0u) & 0b1111111111111111u;
}
inline void set_CH2_TOP_CH2_TOP(uint16_t value) volatile
{
uint32_t curr = CH2_TOP;
curr &= ~(0b1111111111111111u << 0u);
curr |= (value & 0b1111111111111111u) << 0u;
CH2_TOP = curr;
}
inline bool get_CH3_CSR_EN() volatile
{
return CH3_CSR & (1u << 0u);
}
inline void set_CH3_CSR_EN() volatile
{
CH3_CSR |= 1u << 0u;
}
inline void clear_CH3_CSR_EN() volatile
{
CH3_CSR &= ~(1u << 0u);
}
inline void toggle_CH3_CSR_EN() volatile
{
CH3_CSR ^= 1u << 0u;
}
inline bool get_CH3_CSR_PH_CORRECT() volatile
{
return CH3_CSR & (1u << 1u);
}
inline void set_CH3_CSR_PH_CORRECT() volatile
{
CH3_CSR |= 1u << 1u;
}
inline void clear_CH3_CSR_PH_CORRECT() volatile
{
CH3_CSR &= ~(1u << 1u);
}
inline void toggle_CH3_CSR_PH_CORRECT() volatile
{
CH3_CSR ^= 1u << 1u;
}
inline bool get_CH3_CSR_A_INV() volatile
{
return CH3_CSR & (1u << 2u);
}
inline void set_CH3_CSR_A_INV() volatile
{
CH3_CSR |= 1u << 2u;
}
inline void clear_CH3_CSR_A_INV() volatile
{
CH3_CSR &= ~(1u << 2u);
}
inline void toggle_CH3_CSR_A_INV() volatile
{
CH3_CSR ^= 1u << 2u;
}
inline bool get_CH3_CSR_B_INV() volatile
{
return CH3_CSR & (1u << 3u);
}
inline void set_CH3_CSR_B_INV() volatile
{
CH3_CSR |= 1u << 3u;
}
inline void clear_CH3_CSR_B_INV() volatile
{
CH3_CSR &= ~(1u << 3u);
}
inline void toggle_CH3_CSR_B_INV() volatile
{
CH3_CSR ^= 1u << 3u;
}
inline PWM_CH3_CSR_DIVMODE get_CH3_CSR_DIVMODE() volatile
{
return PWM_CH3_CSR_DIVMODE((CH3_CSR >> 4u) & 0b11u);
}
inline void set_CH3_CSR_DIVMODE(PWM_CH3_CSR_DIVMODE value) volatile
{
uint32_t curr = CH3_CSR;
curr &= ~(0b11u << 4u);
curr |= (std::to_underlying(value) & 0b11u) << 4u;
CH3_CSR = curr;
}
inline bool get_CH3_CSR_PH_RET() volatile
{
return CH3_CSR & (1u << 6u);
}
inline void set_CH3_CSR_PH_RET() volatile
{
CH3_CSR |= 1u << 6u;
}
inline void clear_CH3_CSR_PH_RET() volatile
{
CH3_CSR &= ~(1u << 6u);
}
inline void toggle_CH3_CSR_PH_RET() volatile
{
CH3_CSR ^= 1u << 6u;
}
inline bool get_CH3_CSR_PH_ADV() volatile
{
return CH3_CSR & (1u << 7u);
}
inline void set_CH3_CSR_PH_ADV() volatile
{
CH3_CSR |= 1u << 7u;
}
inline void clear_CH3_CSR_PH_ADV() volatile
{
CH3_CSR &= ~(1u << 7u);
}
inline void toggle_CH3_CSR_PH_ADV() volatile
{
CH3_CSR ^= 1u << 7u;
}
inline void get_CH3_CSR(bool &EN, bool &PH_CORRECT, bool &A_INV,
bool &B_INV, PWM_CH3_CSR_DIVMODE &DIVMODE,
bool &PH_RET, bool &PH_ADV) volatile
{
uint32_t curr = CH3_CSR;
EN = curr & (1u << 0u);
PH_CORRECT = curr & (1u << 1u);
A_INV = curr & (1u << 2u);
B_INV = curr & (1u << 3u);
DIVMODE = PWM_CH3_CSR_DIVMODE((curr >> 4u) & 0b11u);
PH_RET = curr & (1u << 6u);
PH_ADV = curr & (1u << 7u);
}
inline void set_CH3_CSR(bool EN, bool PH_CORRECT, bool A_INV, bool B_INV,
PWM_CH3_CSR_DIVMODE DIVMODE, bool PH_RET,
bool PH_ADV) volatile
{
uint32_t curr = CH3_CSR;
curr &= ~(0b1u << 0u);
curr |= (EN & 0b1u) << 0u;
curr &= ~(0b1u << 1u);
curr |= (PH_CORRECT & 0b1u) << 1u;
curr &= ~(0b1u << 2u);
curr |= (A_INV & 0b1u) << 2u;
curr &= ~(0b1u << 3u);
curr |= (B_INV & 0b1u) << 3u;
curr &= ~(0b11u << 4u);
curr |= (std::to_underlying(DIVMODE) & 0b11u) << 4u;
curr &= ~(0b1u << 6u);
curr |= (PH_RET & 0b1u) << 6u;
curr &= ~(0b1u << 7u);
curr |= (PH_ADV & 0b1u) << 7u;
CH3_CSR = curr;
}
inline uint8_t get_CH3_DIV_FRAC() volatile
{
return (CH3_DIV >> 0u) & 0b1111u;
}
inline void set_CH3_DIV_FRAC(uint8_t value) volatile
{
uint32_t curr = CH3_DIV;
curr &= ~(0b1111u << 0u);
curr |= (value & 0b1111u) << 0u;
CH3_DIV = curr;
}
inline uint8_t get_CH3_DIV_INT() volatile
{
return (CH3_DIV >> 4u) & 0b11111111u;
}
inline void set_CH3_DIV_INT(uint8_t value) volatile
{
uint32_t curr = CH3_DIV;
curr &= ~(0b11111111u << 4u);
curr |= (value & 0b11111111u) << 4u;
CH3_DIV = curr;
}
inline void get_CH3_DIV(uint8_t &FRAC, uint8_t &INT) volatile
{
uint32_t curr = CH3_DIV;
FRAC = (curr >> 0u) & 0b1111u;
INT = (curr >> 4u) & 0b11111111u;
}
inline void set_CH3_DIV(uint8_t FRAC, uint8_t INT) volatile
{
uint32_t curr = CH3_DIV;
curr &= ~(0b1111u << 0u);
curr |= (FRAC & 0b1111u) << 0u;
curr &= ~(0b11111111u << 4u);
curr |= (INT & 0b11111111u) << 4u;
CH3_DIV = curr;
}
inline uint16_t get_CH3_CTR_CH3_CTR() volatile
{
return (CH3_CTR >> 0u) & 0b1111111111111111u;
}
inline void set_CH3_CTR_CH3_CTR(uint16_t value) volatile
{
uint32_t curr = CH3_CTR;
curr &= ~(0b1111111111111111u << 0u);
curr |= (value & 0b1111111111111111u) << 0u;
CH3_CTR = curr;
}
inline uint16_t get_CH3_CC_A() volatile
{
return (CH3_CC >> 0u) & 0b1111111111111111u;
}
inline void set_CH3_CC_A(uint16_t value) volatile
{
uint32_t curr = CH3_CC;
curr &= ~(0b1111111111111111u << 0u);
curr |= (value & 0b1111111111111111u) << 0u;
CH3_CC = curr;
}
inline uint16_t get_CH3_CC_B() volatile
{
return (CH3_CC >> 16u) & 0b1111111111111111u;
}
inline void set_CH3_CC_B(uint16_t value) volatile
{
uint32_t curr = CH3_CC;
curr &= ~(0b1111111111111111u << 16u);
curr |= (value & 0b1111111111111111u) << 16u;
CH3_CC = curr;
}
inline void get_CH3_CC(uint16_t &A, uint16_t &B) volatile
{
uint32_t curr = CH3_CC;
A = (curr >> 0u) & 0b1111111111111111u;
B = (curr >> 16u) & 0b1111111111111111u;
}
inline void set_CH3_CC(uint16_t A, uint16_t B) volatile
{
uint32_t curr = CH3_CC;
curr &= ~(0b1111111111111111u << 0u);
curr |= (A & 0b1111111111111111u) << 0u;
curr &= ~(0b1111111111111111u << 16u);
curr |= (B & 0b1111111111111111u) << 16u;
CH3_CC = curr;
}
inline uint16_t get_CH3_TOP_CH3_TOP() volatile
{
return (CH3_TOP >> 0u) & 0b1111111111111111u;
}
inline void set_CH3_TOP_CH3_TOP(uint16_t value) volatile
{
uint32_t curr = CH3_TOP;
curr &= ~(0b1111111111111111u << 0u);
curr |= (value & 0b1111111111111111u) << 0u;
CH3_TOP = curr;
}
inline bool get_CH4_CSR_EN() volatile
{
return CH4_CSR & (1u << 0u);
}
inline void set_CH4_CSR_EN() volatile
{
CH4_CSR |= 1u << 0u;
}
inline void clear_CH4_CSR_EN() volatile
{
CH4_CSR &= ~(1u << 0u);
}
inline void toggle_CH4_CSR_EN() volatile
{
CH4_CSR ^= 1u << 0u;
}
inline bool get_CH4_CSR_PH_CORRECT() volatile
{
return CH4_CSR & (1u << 1u);
}
inline void set_CH4_CSR_PH_CORRECT() volatile
{
CH4_CSR |= 1u << 1u;
}
inline void clear_CH4_CSR_PH_CORRECT() volatile
{
CH4_CSR &= ~(1u << 1u);
}
inline void toggle_CH4_CSR_PH_CORRECT() volatile
{
CH4_CSR ^= 1u << 1u;
}
inline bool get_CH4_CSR_A_INV() volatile
{
return CH4_CSR & (1u << 2u);
}
inline void set_CH4_CSR_A_INV() volatile
{
CH4_CSR |= 1u << 2u;
}
inline void clear_CH4_CSR_A_INV() volatile
{
CH4_CSR &= ~(1u << 2u);
}
inline void toggle_CH4_CSR_A_INV() volatile
{
CH4_CSR ^= 1u << 2u;
}
inline bool get_CH4_CSR_B_INV() volatile
{
return CH4_CSR & (1u << 3u);
}
inline void set_CH4_CSR_B_INV() volatile
{
CH4_CSR |= 1u << 3u;
}
inline void clear_CH4_CSR_B_INV() volatile
{
CH4_CSR &= ~(1u << 3u);
}
inline void toggle_CH4_CSR_B_INV() volatile
{
CH4_CSR ^= 1u << 3u;
}
inline PWM_CH4_CSR_DIVMODE get_CH4_CSR_DIVMODE() volatile
{
return PWM_CH4_CSR_DIVMODE((CH4_CSR >> 4u) & 0b11u);
}
inline void set_CH4_CSR_DIVMODE(PWM_CH4_CSR_DIVMODE value) volatile
{
uint32_t curr = CH4_CSR;
curr &= ~(0b11u << 4u);
curr |= (std::to_underlying(value) & 0b11u) << 4u;
CH4_CSR = curr;
}
inline bool get_CH4_CSR_PH_RET() volatile
{
return CH4_CSR & (1u << 6u);
}
inline void set_CH4_CSR_PH_RET() volatile
{
CH4_CSR |= 1u << 6u;
}
inline void clear_CH4_CSR_PH_RET() volatile
{
CH4_CSR &= ~(1u << 6u);
}
inline void toggle_CH4_CSR_PH_RET() volatile
{
CH4_CSR ^= 1u << 6u;
}
inline bool get_CH4_CSR_PH_ADV() volatile
{
return CH4_CSR & (1u << 7u);
}
inline void set_CH4_CSR_PH_ADV() volatile
{
CH4_CSR |= 1u << 7u;
}
inline void clear_CH4_CSR_PH_ADV() volatile
{
CH4_CSR &= ~(1u << 7u);
}
inline void toggle_CH4_CSR_PH_ADV() volatile
{
CH4_CSR ^= 1u << 7u;
}
inline void get_CH4_CSR(bool &EN, bool &PH_CORRECT, bool &A_INV,
bool &B_INV, PWM_CH4_CSR_DIVMODE &DIVMODE,
bool &PH_RET, bool &PH_ADV) volatile
{
uint32_t curr = CH4_CSR;
EN = curr & (1u << 0u);
PH_CORRECT = curr & (1u << 1u);
A_INV = curr & (1u << 2u);
B_INV = curr & (1u << 3u);
DIVMODE = PWM_CH4_CSR_DIVMODE((curr >> 4u) & 0b11u);
PH_RET = curr & (1u << 6u);
PH_ADV = curr & (1u << 7u);
}
inline void set_CH4_CSR(bool EN, bool PH_CORRECT, bool A_INV, bool B_INV,
PWM_CH4_CSR_DIVMODE DIVMODE, bool PH_RET,
bool PH_ADV) volatile
{
uint32_t curr = CH4_CSR;
curr &= ~(0b1u << 0u);
curr |= (EN & 0b1u) << 0u;
curr &= ~(0b1u << 1u);
curr |= (PH_CORRECT & 0b1u) << 1u;
curr &= ~(0b1u << 2u);
curr |= (A_INV & 0b1u) << 2u;
curr &= ~(0b1u << 3u);
curr |= (B_INV & 0b1u) << 3u;
curr &= ~(0b11u << 4u);
curr |= (std::to_underlying(DIVMODE) & 0b11u) << 4u;
curr &= ~(0b1u << 6u);
curr |= (PH_RET & 0b1u) << 6u;
curr &= ~(0b1u << 7u);
curr |= (PH_ADV & 0b1u) << 7u;
CH4_CSR = curr;
}
inline uint8_t get_CH4_DIV_FRAC() volatile
{
return (CH4_DIV >> 0u) & 0b1111u;
}
inline void set_CH4_DIV_FRAC(uint8_t value) volatile
{
uint32_t curr = CH4_DIV;
curr &= ~(0b1111u << 0u);
curr |= (value & 0b1111u) << 0u;
CH4_DIV = curr;
}
inline uint8_t get_CH4_DIV_INT() volatile
{
return (CH4_DIV >> 4u) & 0b11111111u;
}
inline void set_CH4_DIV_INT(uint8_t value) volatile
{
uint32_t curr = CH4_DIV;
curr &= ~(0b11111111u << 4u);
curr |= (value & 0b11111111u) << 4u;
CH4_DIV = curr;
}
inline void get_CH4_DIV(uint8_t &FRAC, uint8_t &INT) volatile
{
uint32_t curr = CH4_DIV;
FRAC = (curr >> 0u) & 0b1111u;
INT = (curr >> 4u) & 0b11111111u;
}
inline void set_CH4_DIV(uint8_t FRAC, uint8_t INT) volatile
{
uint32_t curr = CH4_DIV;
curr &= ~(0b1111u << 0u);
curr |= (FRAC & 0b1111u) << 0u;
curr &= ~(0b11111111u << 4u);
curr |= (INT & 0b11111111u) << 4u;
CH4_DIV = curr;
}
inline uint16_t get_CH4_CTR_CH4_CTR() volatile
{
return (CH4_CTR >> 0u) & 0b1111111111111111u;
}
inline void set_CH4_CTR_CH4_CTR(uint16_t value) volatile
{
uint32_t curr = CH4_CTR;
curr &= ~(0b1111111111111111u << 0u);
curr |= (value & 0b1111111111111111u) << 0u;
CH4_CTR = curr;
}
inline uint16_t get_CH4_CC_A() volatile
{
return (CH4_CC >> 0u) & 0b1111111111111111u;
}
inline void set_CH4_CC_A(uint16_t value) volatile
{
uint32_t curr = CH4_CC;
curr &= ~(0b1111111111111111u << 0u);
curr |= (value & 0b1111111111111111u) << 0u;
CH4_CC = curr;
}
inline uint16_t get_CH4_CC_B() volatile
{
return (CH4_CC >> 16u) & 0b1111111111111111u;
}
inline void set_CH4_CC_B(uint16_t value) volatile
{
uint32_t curr = CH4_CC;
curr &= ~(0b1111111111111111u << 16u);
curr |= (value & 0b1111111111111111u) << 16u;
CH4_CC = curr;
}
inline void get_CH4_CC(uint16_t &A, uint16_t &B) volatile
{
uint32_t curr = CH4_CC;
A = (curr >> 0u) & 0b1111111111111111u;
B = (curr >> 16u) & 0b1111111111111111u;
}
inline void set_CH4_CC(uint16_t A, uint16_t B) volatile
{
uint32_t curr = CH4_CC;
curr &= ~(0b1111111111111111u << 0u);
curr |= (A & 0b1111111111111111u) << 0u;
curr &= ~(0b1111111111111111u << 16u);
curr |= (B & 0b1111111111111111u) << 16u;
CH4_CC = curr;
}
inline uint16_t get_CH4_TOP_CH4_TOP() volatile
{
return (CH4_TOP >> 0u) & 0b1111111111111111u;
}
inline void set_CH4_TOP_CH4_TOP(uint16_t value) volatile
{
uint32_t curr = CH4_TOP;
curr &= ~(0b1111111111111111u << 0u);
curr |= (value & 0b1111111111111111u) << 0u;
CH4_TOP = curr;
}
inline bool get_CH5_CSR_EN() volatile
{
return CH5_CSR & (1u << 0u);
}
inline void set_CH5_CSR_EN() volatile
{
CH5_CSR |= 1u << 0u;
}
inline void clear_CH5_CSR_EN() volatile
{
CH5_CSR &= ~(1u << 0u);
}
inline void toggle_CH5_CSR_EN() volatile
{
CH5_CSR ^= 1u << 0u;
}
inline bool get_CH5_CSR_PH_CORRECT() volatile
{
return CH5_CSR & (1u << 1u);
}
inline void set_CH5_CSR_PH_CORRECT() volatile
{
CH5_CSR |= 1u << 1u;
}
inline void clear_CH5_CSR_PH_CORRECT() volatile
{
CH5_CSR &= ~(1u << 1u);
}
inline void toggle_CH5_CSR_PH_CORRECT() volatile
{
CH5_CSR ^= 1u << 1u;
}
inline bool get_CH5_CSR_A_INV() volatile
{
return CH5_CSR & (1u << 2u);
}
inline void set_CH5_CSR_A_INV() volatile
{
CH5_CSR |= 1u << 2u;
}
inline void clear_CH5_CSR_A_INV() volatile
{
CH5_CSR &= ~(1u << 2u);
}
inline void toggle_CH5_CSR_A_INV() volatile
{
CH5_CSR ^= 1u << 2u;
}
inline bool get_CH5_CSR_B_INV() volatile
{
return CH5_CSR & (1u << 3u);
}
inline void set_CH5_CSR_B_INV() volatile
{
CH5_CSR |= 1u << 3u;
}
inline void clear_CH5_CSR_B_INV() volatile
{
CH5_CSR &= ~(1u << 3u);
}
inline void toggle_CH5_CSR_B_INV() volatile
{
CH5_CSR ^= 1u << 3u;
}
inline PWM_CH5_CSR_DIVMODE get_CH5_CSR_DIVMODE() volatile
{
return PWM_CH5_CSR_DIVMODE((CH5_CSR >> 4u) & 0b11u);
}
inline void set_CH5_CSR_DIVMODE(PWM_CH5_CSR_DIVMODE value) volatile
{
uint32_t curr = CH5_CSR;
curr &= ~(0b11u << 4u);
curr |= (std::to_underlying(value) & 0b11u) << 4u;
CH5_CSR = curr;
}
inline bool get_CH5_CSR_PH_RET() volatile
{
return CH5_CSR & (1u << 6u);
}
inline void set_CH5_CSR_PH_RET() volatile
{
CH5_CSR |= 1u << 6u;
}
inline void clear_CH5_CSR_PH_RET() volatile
{
CH5_CSR &= ~(1u << 6u);
}
inline void toggle_CH5_CSR_PH_RET() volatile
{
CH5_CSR ^= 1u << 6u;
}
inline bool get_CH5_CSR_PH_ADV() volatile
{
return CH5_CSR & (1u << 7u);
}
inline void set_CH5_CSR_PH_ADV() volatile
{
CH5_CSR |= 1u << 7u;
}
inline void clear_CH5_CSR_PH_ADV() volatile
{
CH5_CSR &= ~(1u << 7u);
}
inline void toggle_CH5_CSR_PH_ADV() volatile
{
CH5_CSR ^= 1u << 7u;
}
inline void get_CH5_CSR(bool &EN, bool &PH_CORRECT, bool &A_INV,
bool &B_INV, PWM_CH5_CSR_DIVMODE &DIVMODE,
bool &PH_RET, bool &PH_ADV) volatile
{
uint32_t curr = CH5_CSR;
EN = curr & (1u << 0u);
PH_CORRECT = curr & (1u << 1u);
A_INV = curr & (1u << 2u);
B_INV = curr & (1u << 3u);
DIVMODE = PWM_CH5_CSR_DIVMODE((curr >> 4u) & 0b11u);
PH_RET = curr & (1u << 6u);
PH_ADV = curr & (1u << 7u);
}
inline void set_CH5_CSR(bool EN, bool PH_CORRECT, bool A_INV, bool B_INV,
PWM_CH5_CSR_DIVMODE DIVMODE, bool PH_RET,
bool PH_ADV) volatile
{
uint32_t curr = CH5_CSR;
curr &= ~(0b1u << 0u);
curr |= (EN & 0b1u) << 0u;
curr &= ~(0b1u << 1u);
curr |= (PH_CORRECT & 0b1u) << 1u;
curr &= ~(0b1u << 2u);
curr |= (A_INV & 0b1u) << 2u;
curr &= ~(0b1u << 3u);
curr |= (B_INV & 0b1u) << 3u;
curr &= ~(0b11u << 4u);
curr |= (std::to_underlying(DIVMODE) & 0b11u) << 4u;
curr &= ~(0b1u << 6u);
curr |= (PH_RET & 0b1u) << 6u;
curr &= ~(0b1u << 7u);
curr |= (PH_ADV & 0b1u) << 7u;
CH5_CSR = curr;
}
inline uint8_t get_CH5_DIV_FRAC() volatile
{
return (CH5_DIV >> 0u) & 0b1111u;
}
inline void set_CH5_DIV_FRAC(uint8_t value) volatile
{
uint32_t curr = CH5_DIV;
curr &= ~(0b1111u << 0u);
curr |= (value & 0b1111u) << 0u;
CH5_DIV = curr;
}
inline uint8_t get_CH5_DIV_INT() volatile
{
return (CH5_DIV >> 4u) & 0b11111111u;
}
inline void set_CH5_DIV_INT(uint8_t value) volatile
{
uint32_t curr = CH5_DIV;
curr &= ~(0b11111111u << 4u);
curr |= (value & 0b11111111u) << 4u;
CH5_DIV = curr;
}
inline void get_CH5_DIV(uint8_t &FRAC, uint8_t &INT) volatile
{
uint32_t curr = CH5_DIV;
FRAC = (curr >> 0u) & 0b1111u;
INT = (curr >> 4u) & 0b11111111u;
}
inline void set_CH5_DIV(uint8_t FRAC, uint8_t INT) volatile
{
uint32_t curr = CH5_DIV;
curr &= ~(0b1111u << 0u);
curr |= (FRAC & 0b1111u) << 0u;
curr &= ~(0b11111111u << 4u);
curr |= (INT & 0b11111111u) << 4u;
CH5_DIV = curr;
}
inline uint16_t get_CH5_CTR_CH5_CTR() volatile
{
return (CH5_CTR >> 0u) & 0b1111111111111111u;
}
inline void set_CH5_CTR_CH5_CTR(uint16_t value) volatile
{
uint32_t curr = CH5_CTR;
curr &= ~(0b1111111111111111u << 0u);
curr |= (value & 0b1111111111111111u) << 0u;
CH5_CTR = curr;
}
inline uint16_t get_CH5_CC_A() volatile
{
return (CH5_CC >> 0u) & 0b1111111111111111u;
}
inline void set_CH5_CC_A(uint16_t value) volatile
{
uint32_t curr = CH5_CC;
curr &= ~(0b1111111111111111u << 0u);
curr |= (value & 0b1111111111111111u) << 0u;
CH5_CC = curr;
}
inline uint16_t get_CH5_CC_B() volatile
{
return (CH5_CC >> 16u) & 0b1111111111111111u;
}
inline void set_CH5_CC_B(uint16_t value) volatile
{
uint32_t curr = CH5_CC;
curr &= ~(0b1111111111111111u << 16u);
curr |= (value & 0b1111111111111111u) << 16u;
CH5_CC = curr;
}
inline void get_CH5_CC(uint16_t &A, uint16_t &B) volatile
{
uint32_t curr = CH5_CC;
A = (curr >> 0u) & 0b1111111111111111u;
B = (curr >> 16u) & 0b1111111111111111u;
}
inline void set_CH5_CC(uint16_t A, uint16_t B) volatile
{
uint32_t curr = CH5_CC;
curr &= ~(0b1111111111111111u << 0u);
curr |= (A & 0b1111111111111111u) << 0u;
curr &= ~(0b1111111111111111u << 16u);
curr |= (B & 0b1111111111111111u) << 16u;
CH5_CC = curr;
}
inline uint16_t get_CH5_TOP_CH5_TOP() volatile
{
return (CH5_TOP >> 0u) & 0b1111111111111111u;
}
inline void set_CH5_TOP_CH5_TOP(uint16_t value) volatile
{
uint32_t curr = CH5_TOP;
curr &= ~(0b1111111111111111u << 0u);
curr |= (value & 0b1111111111111111u) << 0u;
CH5_TOP = curr;
}
inline bool get_CH6_CSR_EN() volatile
{
return CH6_CSR & (1u << 0u);
}
inline void set_CH6_CSR_EN() volatile
{
CH6_CSR |= 1u << 0u;
}
inline void clear_CH6_CSR_EN() volatile
{
CH6_CSR &= ~(1u << 0u);
}
inline void toggle_CH6_CSR_EN() volatile
{
CH6_CSR ^= 1u << 0u;
}
inline bool get_CH6_CSR_PH_CORRECT() volatile
{
return CH6_CSR & (1u << 1u);
}
inline void set_CH6_CSR_PH_CORRECT() volatile
{
CH6_CSR |= 1u << 1u;
}
inline void clear_CH6_CSR_PH_CORRECT() volatile
{
CH6_CSR &= ~(1u << 1u);
}
inline void toggle_CH6_CSR_PH_CORRECT() volatile
{
CH6_CSR ^= 1u << 1u;
}
inline bool get_CH6_CSR_A_INV() volatile
{
return CH6_CSR & (1u << 2u);
}
inline void set_CH6_CSR_A_INV() volatile
{
CH6_CSR |= 1u << 2u;
}
inline void clear_CH6_CSR_A_INV() volatile
{
CH6_CSR &= ~(1u << 2u);
}
inline void toggle_CH6_CSR_A_INV() volatile
{
CH6_CSR ^= 1u << 2u;
}
inline bool get_CH6_CSR_B_INV() volatile
{
return CH6_CSR & (1u << 3u);
}
inline void set_CH6_CSR_B_INV() volatile
{
CH6_CSR |= 1u << 3u;
}
inline void clear_CH6_CSR_B_INV() volatile
{
CH6_CSR &= ~(1u << 3u);
}
inline void toggle_CH6_CSR_B_INV() volatile
{
CH6_CSR ^= 1u << 3u;
}
inline PWM_CH6_CSR_DIVMODE get_CH6_CSR_DIVMODE() volatile
{
return PWM_CH6_CSR_DIVMODE((CH6_CSR >> 4u) & 0b11u);
}
inline void set_CH6_CSR_DIVMODE(PWM_CH6_CSR_DIVMODE value) volatile
{
uint32_t curr = CH6_CSR;
curr &= ~(0b11u << 4u);
curr |= (std::to_underlying(value) & 0b11u) << 4u;
CH6_CSR = curr;
}
inline bool get_CH6_CSR_PH_RET() volatile
{
return CH6_CSR & (1u << 6u);
}
inline void set_CH6_CSR_PH_RET() volatile
{
CH6_CSR |= 1u << 6u;
}
inline void clear_CH6_CSR_PH_RET() volatile
{
CH6_CSR &= ~(1u << 6u);
}
inline void toggle_CH6_CSR_PH_RET() volatile
{
CH6_CSR ^= 1u << 6u;
}
inline bool get_CH6_CSR_PH_ADV() volatile
{
return CH6_CSR & (1u << 7u);
}
inline void set_CH6_CSR_PH_ADV() volatile
{
CH6_CSR |= 1u << 7u;
}
inline void clear_CH6_CSR_PH_ADV() volatile
{
CH6_CSR &= ~(1u << 7u);
}
inline void toggle_CH6_CSR_PH_ADV() volatile
{
CH6_CSR ^= 1u << 7u;
}
inline void get_CH6_CSR(bool &EN, bool &PH_CORRECT, bool &A_INV,
bool &B_INV, PWM_CH6_CSR_DIVMODE &DIVMODE,
bool &PH_RET, bool &PH_ADV) volatile
{
uint32_t curr = CH6_CSR;
EN = curr & (1u << 0u);
PH_CORRECT = curr & (1u << 1u);
A_INV = curr & (1u << 2u);
B_INV = curr & (1u << 3u);
DIVMODE = PWM_CH6_CSR_DIVMODE((curr >> 4u) & 0b11u);
PH_RET = curr & (1u << 6u);
PH_ADV = curr & (1u << 7u);
}
inline void set_CH6_CSR(bool EN, bool PH_CORRECT, bool A_INV, bool B_INV,
PWM_CH6_CSR_DIVMODE DIVMODE, bool PH_RET,
bool PH_ADV) volatile
{
uint32_t curr = CH6_CSR;
curr &= ~(0b1u << 0u);
curr |= (EN & 0b1u) << 0u;
curr &= ~(0b1u << 1u);
curr |= (PH_CORRECT & 0b1u) << 1u;
curr &= ~(0b1u << 2u);
curr |= (A_INV & 0b1u) << 2u;
curr &= ~(0b1u << 3u);
curr |= (B_INV & 0b1u) << 3u;
curr &= ~(0b11u << 4u);
curr |= (std::to_underlying(DIVMODE) & 0b11u) << 4u;
curr &= ~(0b1u << 6u);
curr |= (PH_RET & 0b1u) << 6u;
curr &= ~(0b1u << 7u);
curr |= (PH_ADV & 0b1u) << 7u;
CH6_CSR = curr;
}
inline uint8_t get_CH6_DIV_FRAC() volatile
{
return (CH6_DIV >> 0u) & 0b1111u;
}
inline void set_CH6_DIV_FRAC(uint8_t value) volatile
{
uint32_t curr = CH6_DIV;
curr &= ~(0b1111u << 0u);
curr |= (value & 0b1111u) << 0u;
CH6_DIV = curr;
}
inline uint8_t get_CH6_DIV_INT() volatile
{
return (CH6_DIV >> 4u) & 0b11111111u;
}
inline void set_CH6_DIV_INT(uint8_t value) volatile
{
uint32_t curr = CH6_DIV;
curr &= ~(0b11111111u << 4u);
curr |= (value & 0b11111111u) << 4u;
CH6_DIV = curr;
}
inline void get_CH6_DIV(uint8_t &FRAC, uint8_t &INT) volatile
{
uint32_t curr = CH6_DIV;
FRAC = (curr >> 0u) & 0b1111u;
INT = (curr >> 4u) & 0b11111111u;
}
inline void set_CH6_DIV(uint8_t FRAC, uint8_t INT) volatile
{
uint32_t curr = CH6_DIV;
curr &= ~(0b1111u << 0u);
curr |= (FRAC & 0b1111u) << 0u;
curr &= ~(0b11111111u << 4u);
curr |= (INT & 0b11111111u) << 4u;
CH6_DIV = curr;
}
inline uint16_t get_CH6_CTR_CH6_CTR() volatile
{
return (CH6_CTR >> 0u) & 0b1111111111111111u;
}
inline void set_CH6_CTR_CH6_CTR(uint16_t value) volatile
{
uint32_t curr = CH6_CTR;
curr &= ~(0b1111111111111111u << 0u);
curr |= (value & 0b1111111111111111u) << 0u;
CH6_CTR = curr;
}
inline uint16_t get_CH6_CC_A() volatile
{
return (CH6_CC >> 0u) & 0b1111111111111111u;
}
inline void set_CH6_CC_A(uint16_t value) volatile
{
uint32_t curr = CH6_CC;
curr &= ~(0b1111111111111111u << 0u);
curr |= (value & 0b1111111111111111u) << 0u;
CH6_CC = curr;
}
inline uint16_t get_CH6_CC_B() volatile
{
return (CH6_CC >> 16u) & 0b1111111111111111u;
}
inline void set_CH6_CC_B(uint16_t value) volatile
{
uint32_t curr = CH6_CC;
curr &= ~(0b1111111111111111u << 16u);
curr |= (value & 0b1111111111111111u) << 16u;
CH6_CC = curr;
}
inline void get_CH6_CC(uint16_t &A, uint16_t &B) volatile
{
uint32_t curr = CH6_CC;
A = (curr >> 0u) & 0b1111111111111111u;
B = (curr >> 16u) & 0b1111111111111111u;
}
inline void set_CH6_CC(uint16_t A, uint16_t B) volatile
{
uint32_t curr = CH6_CC;
curr &= ~(0b1111111111111111u << 0u);
curr |= (A & 0b1111111111111111u) << 0u;
curr &= ~(0b1111111111111111u << 16u);
curr |= (B & 0b1111111111111111u) << 16u;
CH6_CC = curr;
}
inline uint16_t get_CH6_TOP_CH6_TOP() volatile
{
return (CH6_TOP >> 0u) & 0b1111111111111111u;
}
inline void set_CH6_TOP_CH6_TOP(uint16_t value) volatile
{
uint32_t curr = CH6_TOP;
curr &= ~(0b1111111111111111u << 0u);
curr |= (value & 0b1111111111111111u) << 0u;
CH6_TOP = curr;
}
inline bool get_CH7_CSR_EN() volatile
{
return CH7_CSR & (1u << 0u);
}
inline void set_CH7_CSR_EN() volatile
{
CH7_CSR |= 1u << 0u;
}
inline void clear_CH7_CSR_EN() volatile
{
CH7_CSR &= ~(1u << 0u);
}
inline void toggle_CH7_CSR_EN() volatile
{
CH7_CSR ^= 1u << 0u;
}
inline bool get_CH7_CSR_PH_CORRECT() volatile
{
return CH7_CSR & (1u << 1u);
}
inline void set_CH7_CSR_PH_CORRECT() volatile
{
CH7_CSR |= 1u << 1u;
}
inline void clear_CH7_CSR_PH_CORRECT() volatile
{
CH7_CSR &= ~(1u << 1u);
}
inline void toggle_CH7_CSR_PH_CORRECT() volatile
{
CH7_CSR ^= 1u << 1u;
}
inline bool get_CH7_CSR_A_INV() volatile
{
return CH7_CSR & (1u << 2u);
}
inline void set_CH7_CSR_A_INV() volatile
{
CH7_CSR |= 1u << 2u;
}
inline void clear_CH7_CSR_A_INV() volatile
{
CH7_CSR &= ~(1u << 2u);
}
inline void toggle_CH7_CSR_A_INV() volatile
{
CH7_CSR ^= 1u << 2u;
}
inline bool get_CH7_CSR_B_INV() volatile
{
return CH7_CSR & (1u << 3u);
}
inline void set_CH7_CSR_B_INV() volatile
{
CH7_CSR |= 1u << 3u;
}
inline void clear_CH7_CSR_B_INV() volatile
{
CH7_CSR &= ~(1u << 3u);
}
inline void toggle_CH7_CSR_B_INV() volatile
{
CH7_CSR ^= 1u << 3u;
}
inline PWM_CH7_CSR_DIVMODE get_CH7_CSR_DIVMODE() volatile
{
return PWM_CH7_CSR_DIVMODE((CH7_CSR >> 4u) & 0b11u);
}
inline void set_CH7_CSR_DIVMODE(PWM_CH7_CSR_DIVMODE value) volatile
{
uint32_t curr = CH7_CSR;
curr &= ~(0b11u << 4u);
curr |= (std::to_underlying(value) & 0b11u) << 4u;
CH7_CSR = curr;
}
inline bool get_CH7_CSR_PH_RET() volatile
{
return CH7_CSR & (1u << 6u);
}
inline void set_CH7_CSR_PH_RET() volatile
{
CH7_CSR |= 1u << 6u;
}
inline void clear_CH7_CSR_PH_RET() volatile
{
CH7_CSR &= ~(1u << 6u);
}
inline void toggle_CH7_CSR_PH_RET() volatile
{
CH7_CSR ^= 1u << 6u;
}
inline bool get_CH7_CSR_PH_ADV() volatile
{
return CH7_CSR & (1u << 7u);
}
inline void set_CH7_CSR_PH_ADV() volatile
{
CH7_CSR |= 1u << 7u;
}
inline void clear_CH7_CSR_PH_ADV() volatile
{
CH7_CSR &= ~(1u << 7u);
}
inline void toggle_CH7_CSR_PH_ADV() volatile
{
CH7_CSR ^= 1u << 7u;
}
inline void get_CH7_CSR(bool &EN, bool &PH_CORRECT, bool &A_INV,
bool &B_INV, PWM_CH7_CSR_DIVMODE &DIVMODE,
bool &PH_RET, bool &PH_ADV) volatile
{
uint32_t curr = CH7_CSR;
EN = curr & (1u << 0u);
PH_CORRECT = curr & (1u << 1u);
A_INV = curr & (1u << 2u);
B_INV = curr & (1u << 3u);
DIVMODE = PWM_CH7_CSR_DIVMODE((curr >> 4u) & 0b11u);
PH_RET = curr & (1u << 6u);
PH_ADV = curr & (1u << 7u);
}
inline void set_CH7_CSR(bool EN, bool PH_CORRECT, bool A_INV, bool B_INV,
PWM_CH7_CSR_DIVMODE DIVMODE, bool PH_RET,
bool PH_ADV) volatile
{
uint32_t curr = CH7_CSR;
curr &= ~(0b1u << 0u);
curr |= (EN & 0b1u) << 0u;
curr &= ~(0b1u << 1u);
curr |= (PH_CORRECT & 0b1u) << 1u;
curr &= ~(0b1u << 2u);
curr |= (A_INV & 0b1u) << 2u;
curr &= ~(0b1u << 3u);
curr |= (B_INV & 0b1u) << 3u;
curr &= ~(0b11u << 4u);
curr |= (std::to_underlying(DIVMODE) & 0b11u) << 4u;
curr &= ~(0b1u << 6u);
curr |= (PH_RET & 0b1u) << 6u;
curr &= ~(0b1u << 7u);
curr |= (PH_ADV & 0b1u) << 7u;
CH7_CSR = curr;
}
inline uint8_t get_CH7_DIV_FRAC() volatile
{
return (CH7_DIV >> 0u) & 0b1111u;
}
inline void set_CH7_DIV_FRAC(uint8_t value) volatile
{
uint32_t curr = CH7_DIV;
curr &= ~(0b1111u << 0u);
curr |= (value & 0b1111u) << 0u;
CH7_DIV = curr;
}
inline uint8_t get_CH7_DIV_INT() volatile
{
return (CH7_DIV >> 4u) & 0b11111111u;
}
inline void set_CH7_DIV_INT(uint8_t value) volatile
{
uint32_t curr = CH7_DIV;
curr &= ~(0b11111111u << 4u);
curr |= (value & 0b11111111u) << 4u;
CH7_DIV = curr;
}
inline void get_CH7_DIV(uint8_t &FRAC, uint8_t &INT) volatile
{
uint32_t curr = CH7_DIV;
FRAC = (curr >> 0u) & 0b1111u;
INT = (curr >> 4u) & 0b11111111u;
}
inline void set_CH7_DIV(uint8_t FRAC, uint8_t INT) volatile
{
uint32_t curr = CH7_DIV;
curr &= ~(0b1111u << 0u);
curr |= (FRAC & 0b1111u) << 0u;
curr &= ~(0b11111111u << 4u);
curr |= (INT & 0b11111111u) << 4u;
CH7_DIV = curr;
}
inline uint16_t get_CH7_CTR_CH7_CTR() volatile
{
return (CH7_CTR >> 0u) & 0b1111111111111111u;
}
inline void set_CH7_CTR_CH7_CTR(uint16_t value) volatile
{
uint32_t curr = CH7_CTR;
curr &= ~(0b1111111111111111u << 0u);
curr |= (value & 0b1111111111111111u) << 0u;
CH7_CTR = curr;
}
inline uint16_t get_CH7_CC_A() volatile
{
return (CH7_CC >> 0u) & 0b1111111111111111u;
}
inline void set_CH7_CC_A(uint16_t value) volatile
{
uint32_t curr = CH7_CC;
curr &= ~(0b1111111111111111u << 0u);
curr |= (value & 0b1111111111111111u) << 0u;
CH7_CC = curr;
}
inline uint16_t get_CH7_CC_B() volatile
{
return (CH7_CC >> 16u) & 0b1111111111111111u;
}
inline void set_CH7_CC_B(uint16_t value) volatile
{
uint32_t curr = CH7_CC;
curr &= ~(0b1111111111111111u << 16u);
curr |= (value & 0b1111111111111111u) << 16u;
CH7_CC = curr;
}
inline void get_CH7_CC(uint16_t &A, uint16_t &B) volatile
{
uint32_t curr = CH7_CC;
A = (curr >> 0u) & 0b1111111111111111u;
B = (curr >> 16u) & 0b1111111111111111u;
}
inline void set_CH7_CC(uint16_t A, uint16_t B) volatile
{
uint32_t curr = CH7_CC;
curr &= ~(0b1111111111111111u << 0u);
curr |= (A & 0b1111111111111111u) << 0u;
curr &= ~(0b1111111111111111u << 16u);
curr |= (B & 0b1111111111111111u) << 16u;
CH7_CC = curr;
}
inline uint16_t get_CH7_TOP_CH7_TOP() volatile
{
return (CH7_TOP >> 0u) & 0b1111111111111111u;
}
inline void set_CH7_TOP_CH7_TOP(uint16_t value) volatile
{
uint32_t curr = CH7_TOP;
curr &= ~(0b1111111111111111u << 0u);
curr |= (value & 0b1111111111111111u) << 0u;
CH7_TOP = curr;
}
inline bool get_EN_CH0() volatile
{
return EN & (1u << 0u);
}
inline void set_EN_CH0() volatile
{
EN |= 1u << 0u;
}
inline void clear_EN_CH0() volatile
{
EN &= ~(1u << 0u);
}
inline void toggle_EN_CH0() volatile
{
EN ^= 1u << 0u;
}
inline bool get_EN_CH1() volatile
{
return EN & (1u << 1u);
}
inline void set_EN_CH1() volatile
{
EN |= 1u << 1u;
}
inline void clear_EN_CH1() volatile
{
EN &= ~(1u << 1u);
}
inline void toggle_EN_CH1() volatile
{
EN ^= 1u << 1u;
}
inline bool get_EN_CH2() volatile
{
return EN & (1u << 2u);
}
inline void set_EN_CH2() volatile
{
EN |= 1u << 2u;
}
inline void clear_EN_CH2() volatile
{
EN &= ~(1u << 2u);
}
inline void toggle_EN_CH2() volatile
{
EN ^= 1u << 2u;
}
inline bool get_EN_CH3() volatile
{
return EN & (1u << 3u);
}
inline void set_EN_CH3() volatile
{
EN |= 1u << 3u;
}
inline void clear_EN_CH3() volatile
{
EN &= ~(1u << 3u);
}
inline void toggle_EN_CH3() volatile
{
EN ^= 1u << 3u;
}
inline bool get_EN_CH4() volatile
{
return EN & (1u << 4u);
}
inline void set_EN_CH4() volatile
{
EN |= 1u << 4u;
}
inline void clear_EN_CH4() volatile
{
EN &= ~(1u << 4u);
}
inline void toggle_EN_CH4() volatile
{
EN ^= 1u << 4u;
}
inline bool get_EN_CH5() volatile
{
return EN & (1u << 5u);
}
inline void set_EN_CH5() volatile
{
EN |= 1u << 5u;
}
inline void clear_EN_CH5() volatile
{
EN &= ~(1u << 5u);
}
inline void toggle_EN_CH5() volatile
{
EN ^= 1u << 5u;
}
inline bool get_EN_CH6() volatile
{
return EN & (1u << 6u);
}
inline void set_EN_CH6() volatile
{
EN |= 1u << 6u;
}
inline void clear_EN_CH6() volatile
{
EN &= ~(1u << 6u);
}
inline void toggle_EN_CH6() volatile
{
EN ^= 1u << 6u;
}
inline bool get_EN_CH7() volatile
{
return EN & (1u << 7u);
}
inline void set_EN_CH7() volatile
{
EN |= 1u << 7u;
}
inline void clear_EN_CH7() volatile
{
EN &= ~(1u << 7u);
}
inline void toggle_EN_CH7() volatile
{
EN ^= 1u << 7u;
}
inline void get_EN(bool &CH0, bool &CH1, bool &CH2, bool &CH3, bool &CH4,
bool &CH5, bool &CH6, bool &CH7) volatile
{
uint32_t curr = EN;
CH0 = curr & (1u << 0u);
CH1 = curr & (1u << 1u);
CH2 = curr & (1u << 2u);
CH3 = curr & (1u << 3u);
CH4 = curr & (1u << 4u);
CH5 = curr & (1u << 5u);
CH6 = curr & (1u << 6u);
CH7 = curr & (1u << 7u);
}
inline void set_EN(bool CH0, bool CH1, bool CH2, bool CH3, bool CH4,
bool CH5, bool CH6, bool CH7) volatile
{
uint32_t curr = EN;
curr &= ~(0b1u << 0u);
curr |= (CH0 & 0b1u) << 0u;
curr &= ~(0b1u << 1u);
curr |= (CH1 & 0b1u) << 1u;
curr &= ~(0b1u << 2u);
curr |= (CH2 & 0b1u) << 2u;
curr &= ~(0b1u << 3u);
curr |= (CH3 & 0b1u) << 3u;
curr &= ~(0b1u << 4u);
curr |= (CH4 & 0b1u) << 4u;
curr &= ~(0b1u << 5u);
curr |= (CH5 & 0b1u) << 5u;
curr &= ~(0b1u << 6u);
curr |= (CH6 & 0b1u) << 6u;
curr &= ~(0b1u << 7u);
curr |= (CH7 & 0b1u) << 7u;
EN = curr;
}
inline bool get_INTR_CH0() volatile
{
return INTR & (1u << 0u);
}
inline void set_INTR_CH0() volatile
{
INTR |= 1u << 0u;
}
inline void clear_INTR_CH0() volatile
{
INTR &= ~(1u << 0u);
}
inline void toggle_INTR_CH0() volatile
{
INTR ^= 1u << 0u;
}
inline bool get_INTR_CH1() volatile
{
return INTR & (1u << 1u);
}
inline void set_INTR_CH1() volatile
{
INTR |= 1u << 1u;
}
inline void clear_INTR_CH1() volatile
{
INTR &= ~(1u << 1u);
}
inline void toggle_INTR_CH1() volatile
{
INTR ^= 1u << 1u;
}
inline bool get_INTR_CH2() volatile
{
return INTR & (1u << 2u);
}
inline void set_INTR_CH2() volatile
{
INTR |= 1u << 2u;
}
inline void clear_INTR_CH2() volatile
{
INTR &= ~(1u << 2u);
}
inline void toggle_INTR_CH2() volatile
{
INTR ^= 1u << 2u;
}
inline bool get_INTR_CH3() volatile
{
return INTR & (1u << 3u);
}
inline void set_INTR_CH3() volatile
{
INTR |= 1u << 3u;
}
inline void clear_INTR_CH3() volatile
{
INTR &= ~(1u << 3u);
}
inline void toggle_INTR_CH3() volatile
{
INTR ^= 1u << 3u;
}
inline bool get_INTR_CH4() volatile
{
return INTR & (1u << 4u);
}
inline void set_INTR_CH4() volatile
{
INTR |= 1u << 4u;
}
inline void clear_INTR_CH4() volatile
{
INTR &= ~(1u << 4u);
}
inline void toggle_INTR_CH4() volatile
{
INTR ^= 1u << 4u;
}
inline bool get_INTR_CH5() volatile
{
return INTR & (1u << 5u);
}
inline void set_INTR_CH5() volatile
{
INTR |= 1u << 5u;
}
inline void clear_INTR_CH5() volatile
{
INTR &= ~(1u << 5u);
}
inline void toggle_INTR_CH5() volatile
{
INTR ^= 1u << 5u;
}
inline bool get_INTR_CH6() volatile
{
return INTR & (1u << 6u);
}
inline void set_INTR_CH6() volatile
{
INTR |= 1u << 6u;
}
inline void clear_INTR_CH6() volatile
{
INTR &= ~(1u << 6u);
}
inline void toggle_INTR_CH6() volatile
{
INTR ^= 1u << 6u;
}
inline bool get_INTR_CH7() volatile
{
return INTR & (1u << 7u);
}
inline void set_INTR_CH7() volatile
{
INTR |= 1u << 7u;
}
inline void clear_INTR_CH7() volatile
{
INTR &= ~(1u << 7u);
}
inline void toggle_INTR_CH7() volatile
{
INTR ^= 1u << 7u;
}
inline void get_INTR(bool &CH0, bool &CH1, bool &CH2, bool &CH3, bool &CH4,
bool &CH5, bool &CH6, bool &CH7) volatile
{
uint32_t curr = INTR;
CH0 = curr & (1u << 0u);
CH1 = curr & (1u << 1u);
CH2 = curr & (1u << 2u);
CH3 = curr & (1u << 3u);
CH4 = curr & (1u << 4u);
CH5 = curr & (1u << 5u);
CH6 = curr & (1u << 6u);
CH7 = curr & (1u << 7u);
}
inline void set_INTR(bool CH0, bool CH1, bool CH2, bool CH3, bool CH4,
bool CH5, bool CH6, bool CH7) volatile
{
uint32_t curr = INTR;
curr &= ~(0b1u << 0u);
curr |= (CH0 & 0b1u) << 0u;
curr &= ~(0b1u << 1u);
curr |= (CH1 & 0b1u) << 1u;
curr &= ~(0b1u << 2u);
curr |= (CH2 & 0b1u) << 2u;
curr &= ~(0b1u << 3u);
curr |= (CH3 & 0b1u) << 3u;
curr &= ~(0b1u << 4u);
curr |= (CH4 & 0b1u) << 4u;
curr &= ~(0b1u << 5u);
curr |= (CH5 & 0b1u) << 5u;
curr &= ~(0b1u << 6u);
curr |= (CH6 & 0b1u) << 6u;
curr &= ~(0b1u << 7u);
curr |= (CH7 & 0b1u) << 7u;
INTR = curr;
}
inline bool get_INTE_CH0() volatile
{
return INTE & (1u << 0u);
}
inline void set_INTE_CH0() volatile
{
INTE |= 1u << 0u;
}
inline void clear_INTE_CH0() volatile
{
INTE &= ~(1u << 0u);
}
inline void toggle_INTE_CH0() volatile
{
INTE ^= 1u << 0u;
}
inline bool get_INTE_CH1() volatile
{
return INTE & (1u << 1u);
}
inline void set_INTE_CH1() volatile
{
INTE |= 1u << 1u;
}
inline void clear_INTE_CH1() volatile
{
INTE &= ~(1u << 1u);
}
inline void toggle_INTE_CH1() volatile
{
INTE ^= 1u << 1u;
}
inline bool get_INTE_CH2() volatile
{
return INTE & (1u << 2u);
}
inline void set_INTE_CH2() volatile
{
INTE |= 1u << 2u;
}
inline void clear_INTE_CH2() volatile
{
INTE &= ~(1u << 2u);
}
inline void toggle_INTE_CH2() volatile
{
INTE ^= 1u << 2u;
}
inline bool get_INTE_CH3() volatile
{
return INTE & (1u << 3u);
}
inline void set_INTE_CH3() volatile
{
INTE |= 1u << 3u;
}
inline void clear_INTE_CH3() volatile
{
INTE &= ~(1u << 3u);
}
inline void toggle_INTE_CH3() volatile
{
INTE ^= 1u << 3u;
}
inline bool get_INTE_CH4() volatile
{
return INTE & (1u << 4u);
}
inline void set_INTE_CH4() volatile
{
INTE |= 1u << 4u;
}
inline void clear_INTE_CH4() volatile
{
INTE &= ~(1u << 4u);
}
inline void toggle_INTE_CH4() volatile
{
INTE ^= 1u << 4u;
}
inline bool get_INTE_CH5() volatile
{
return INTE & (1u << 5u);
}
inline void set_INTE_CH5() volatile
{
INTE |= 1u << 5u;
}
inline void clear_INTE_CH5() volatile
{
INTE &= ~(1u << 5u);
}
inline void toggle_INTE_CH5() volatile
{
INTE ^= 1u << 5u;
}
inline bool get_INTE_CH6() volatile
{
return INTE & (1u << 6u);
}
inline void set_INTE_CH6() volatile
{
INTE |= 1u << 6u;
}
inline void clear_INTE_CH6() volatile
{
INTE &= ~(1u << 6u);
}
inline void toggle_INTE_CH6() volatile
{
INTE ^= 1u << 6u;
}
inline bool get_INTE_CH7() volatile
{
return INTE & (1u << 7u);
}
inline void set_INTE_CH7() volatile
{
INTE |= 1u << 7u;
}
inline void clear_INTE_CH7() volatile
{
INTE &= ~(1u << 7u);
}
inline void toggle_INTE_CH7() volatile
{
INTE ^= 1u << 7u;
}
inline void get_INTE(bool &CH0, bool &CH1, bool &CH2, bool &CH3, bool &CH4,
bool &CH5, bool &CH6, bool &CH7) volatile
{
uint32_t curr = INTE;
CH0 = curr & (1u << 0u);
CH1 = curr & (1u << 1u);
CH2 = curr & (1u << 2u);
CH3 = curr & (1u << 3u);
CH4 = curr & (1u << 4u);
CH5 = curr & (1u << 5u);
CH6 = curr & (1u << 6u);
CH7 = curr & (1u << 7u);
}
inline void set_INTE(bool CH0, bool CH1, bool CH2, bool CH3, bool CH4,
bool CH5, bool CH6, bool CH7) volatile
{
uint32_t curr = INTE;
curr &= ~(0b1u << 0u);
curr |= (CH0 & 0b1u) << 0u;
curr &= ~(0b1u << 1u);
curr |= (CH1 & 0b1u) << 1u;
curr &= ~(0b1u << 2u);
curr |= (CH2 & 0b1u) << 2u;
curr &= ~(0b1u << 3u);
curr |= (CH3 & 0b1u) << 3u;
curr &= ~(0b1u << 4u);
curr |= (CH4 & 0b1u) << 4u;
curr &= ~(0b1u << 5u);
curr |= (CH5 & 0b1u) << 5u;
curr &= ~(0b1u << 6u);
curr |= (CH6 & 0b1u) << 6u;
curr &= ~(0b1u << 7u);
curr |= (CH7 & 0b1u) << 7u;
INTE = curr;
}
inline bool get_INTF_CH0() volatile
{
return INTF & (1u << 0u);
}
inline void set_INTF_CH0() volatile
{
INTF |= 1u << 0u;
}
inline void clear_INTF_CH0() volatile
{
INTF &= ~(1u << 0u);
}
inline void toggle_INTF_CH0() volatile
{
INTF ^= 1u << 0u;
}
inline bool get_INTF_CH1() volatile
{
return INTF & (1u << 1u);
}
inline void set_INTF_CH1() volatile
{
INTF |= 1u << 1u;
}
inline void clear_INTF_CH1() volatile
{
INTF &= ~(1u << 1u);
}
inline void toggle_INTF_CH1() volatile
{
INTF ^= 1u << 1u;
}
inline bool get_INTF_CH2() volatile
{
return INTF & (1u << 2u);
}
inline void set_INTF_CH2() volatile
{
INTF |= 1u << 2u;
}
inline void clear_INTF_CH2() volatile
{
INTF &= ~(1u << 2u);
}
inline void toggle_INTF_CH2() volatile
{
INTF ^= 1u << 2u;
}
inline bool get_INTF_CH3() volatile
{
return INTF & (1u << 3u);
}
inline void set_INTF_CH3() volatile
{
INTF |= 1u << 3u;
}
inline void clear_INTF_CH3() volatile
{
INTF &= ~(1u << 3u);
}
inline void toggle_INTF_CH3() volatile
{
INTF ^= 1u << 3u;
}
inline bool get_INTF_CH4() volatile
{
return INTF & (1u << 4u);
}
inline void set_INTF_CH4() volatile
{
INTF |= 1u << 4u;
}
inline void clear_INTF_CH4() volatile
{
INTF &= ~(1u << 4u);
}
inline void toggle_INTF_CH4() volatile
{
INTF ^= 1u << 4u;
}
inline bool get_INTF_CH5() volatile
{
return INTF & (1u << 5u);
}
inline void set_INTF_CH5() volatile
{
INTF |= 1u << 5u;
}
inline void clear_INTF_CH5() volatile
{
INTF &= ~(1u << 5u);
}
inline void toggle_INTF_CH5() volatile
{
INTF ^= 1u << 5u;
}
inline bool get_INTF_CH6() volatile
{
return INTF & (1u << 6u);
}
inline void set_INTF_CH6() volatile
{
INTF |= 1u << 6u;
}
inline void clear_INTF_CH6() volatile
{
INTF &= ~(1u << 6u);
}
inline void toggle_INTF_CH6() volatile
{
INTF ^= 1u << 6u;
}
inline bool get_INTF_CH7() volatile
{
return INTF & (1u << 7u);
}
inline void set_INTF_CH7() volatile
{
INTF |= 1u << 7u;
}
inline void clear_INTF_CH7() volatile
{
INTF &= ~(1u << 7u);
}
inline void toggle_INTF_CH7() volatile
{
INTF ^= 1u << 7u;
}
inline void get_INTF(bool &CH0, bool &CH1, bool &CH2, bool &CH3, bool &CH4,
bool &CH5, bool &CH6, bool &CH7) volatile
{
uint32_t curr = INTF;
CH0 = curr & (1u << 0u);
CH1 = curr & (1u << 1u);
CH2 = curr & (1u << 2u);
CH3 = curr & (1u << 3u);
CH4 = curr & (1u << 4u);
CH5 = curr & (1u << 5u);
CH6 = curr & (1u << 6u);
CH7 = curr & (1u << 7u);
}
inline void set_INTF(bool CH0, bool CH1, bool CH2, bool CH3, bool CH4,
bool CH5, bool CH6, bool CH7) volatile
{
uint32_t curr = INTF;
curr &= ~(0b1u << 0u);
curr |= (CH0 & 0b1u) << 0u;
curr &= ~(0b1u << 1u);
curr |= (CH1 & 0b1u) << 1u;
curr &= ~(0b1u << 2u);
curr |= (CH2 & 0b1u) << 2u;
curr &= ~(0b1u << 3u);
curr |= (CH3 & 0b1u) << 3u;
curr &= ~(0b1u << 4u);
curr |= (CH4 & 0b1u) << 4u;
curr &= ~(0b1u << 5u);
curr |= (CH5 & 0b1u) << 5u;
curr &= ~(0b1u << 6u);
curr |= (CH6 & 0b1u) << 6u;
curr &= ~(0b1u << 7u);
curr |= (CH7 & 0b1u) << 7u;
INTF = curr;
}
inline bool get_INTS_CH0() volatile
{
return INTS & (1u << 0u);
}
inline bool get_INTS_CH1() volatile
{
return INTS & (1u << 1u);
}
inline bool get_INTS_CH2() volatile
{
return INTS & (1u << 2u);
}
inline bool get_INTS_CH3() volatile
{
return INTS & (1u << 3u);
}
inline bool get_INTS_CH4() volatile
{
return INTS & (1u << 4u);
}
inline bool get_INTS_CH5() volatile
{
return INTS & (1u << 5u);
}
inline bool get_INTS_CH6() volatile
{
return INTS & (1u << 6u);
}
inline bool get_INTS_CH7() volatile
{
return INTS & (1u << 7u);
}
inline void get_INTS(bool &CH0, bool &CH1, bool &CH2, bool &CH3, bool &CH4,
bool &CH5, bool &CH6, bool &CH7) volatile
{
uint32_t curr = INTS;
CH0 = curr & (1u << 0u);
CH1 = curr & (1u << 1u);
CH2 = curr & (1u << 2u);
CH3 = curr & (1u << 3u);
CH4 = curr & (1u << 4u);
CH5 = curr & (1u << 5u);
CH6 = curr & (1u << 6u);
CH7 = curr & (1u << 7u);
}
};
static_assert(sizeof(pwm) == pwm::size);
static volatile pwm *const PWM = reinterpret_cast<pwm *>(0x40050000);
}; // namespace RP2040