swaitsandClaude Opus 4.6
3102fc747a
Implement full SSD1306 OLED display support: - Splash screen on boot (1.5s) with project name, version, board - Dashboard showing radio state, config, counters, RSSI/SNR - RSSI history sparkline (64-sample ring buffer, 2px-wide bars) - DisplayOn/DisplayOff host commands routed via dedicated channel - Pure render functions against generic DrawTarget (no hardware coupling) - Display on/off control bypasses radio task entirely Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
438 lines
14 KiB
Rust
438 lines
14 KiB
Rust
#[doc = "Register `IFCONFIG0` reader"]
|
|
pub struct R(crate::R<IFCONFIG0_SPEC>);
|
|
impl core::ops::Deref for R {
|
|
type Target = crate::R<IFCONFIG0_SPEC>;
|
|
#[inline(always)]
|
|
fn deref(&self) -> &Self::Target {
|
|
&self.0
|
|
}
|
|
}
|
|
impl From<crate::R<IFCONFIG0_SPEC>> for R {
|
|
#[inline(always)]
|
|
fn from(reader: crate::R<IFCONFIG0_SPEC>) -> Self {
|
|
R(reader)
|
|
}
|
|
}
|
|
#[doc = "Register `IFCONFIG0` writer"]
|
|
pub struct W(crate::W<IFCONFIG0_SPEC>);
|
|
impl core::ops::Deref for W {
|
|
type Target = crate::W<IFCONFIG0_SPEC>;
|
|
#[inline(always)]
|
|
fn deref(&self) -> &Self::Target {
|
|
&self.0
|
|
}
|
|
}
|
|
impl core::ops::DerefMut for W {
|
|
#[inline(always)]
|
|
fn deref_mut(&mut self) -> &mut Self::Target {
|
|
&mut self.0
|
|
}
|
|
}
|
|
impl From<crate::W<IFCONFIG0_SPEC>> for W {
|
|
#[inline(always)]
|
|
fn from(writer: crate::W<IFCONFIG0_SPEC>) -> Self {
|
|
W(writer)
|
|
}
|
|
}
|
|
#[doc = "Field `READOC` reader - Configure number of data lines and opcode used for reading."]
|
|
pub type READOC_R = crate::FieldReader<u8, READOC_A>;
|
|
#[doc = "Configure number of data lines and opcode used for reading.\n\nValue on reset: 0"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
#[repr(u8)]
|
|
pub enum READOC_A {
|
|
#[doc = "0: Single data line SPI. FAST_READ (opcode 0x0B)."]
|
|
FASTREAD = 0,
|
|
#[doc = "1: Dual data line SPI. READ2O (opcode 0x3B)."]
|
|
READ2O = 1,
|
|
#[doc = "2: Dual data line SPI. READ2IO (opcode 0xBB)."]
|
|
READ2IO = 2,
|
|
#[doc = "3: Quad data line SPI. READ4O (opcode 0x6B)."]
|
|
READ4O = 3,
|
|
#[doc = "4: Quad data line SPI. READ4IO (opcode 0xEB)."]
|
|
READ4IO = 4,
|
|
}
|
|
impl From<READOC_A> for u8 {
|
|
#[inline(always)]
|
|
fn from(variant: READOC_A) -> Self {
|
|
variant as _
|
|
}
|
|
}
|
|
impl READOC_R {
|
|
#[doc = "Get enumerated values variant"]
|
|
#[inline(always)]
|
|
pub fn variant(&self) -> Option<READOC_A> {
|
|
match self.bits {
|
|
0 => Some(READOC_A::FASTREAD),
|
|
1 => Some(READOC_A::READ2O),
|
|
2 => Some(READOC_A::READ2IO),
|
|
3 => Some(READOC_A::READ4O),
|
|
4 => Some(READOC_A::READ4IO),
|
|
_ => None,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `FASTREAD`"]
|
|
#[inline(always)]
|
|
pub fn is_fastread(&self) -> bool {
|
|
*self == READOC_A::FASTREAD
|
|
}
|
|
#[doc = "Checks if the value of the field is `READ2O`"]
|
|
#[inline(always)]
|
|
pub fn is_read2o(&self) -> bool {
|
|
*self == READOC_A::READ2O
|
|
}
|
|
#[doc = "Checks if the value of the field is `READ2IO`"]
|
|
#[inline(always)]
|
|
pub fn is_read2io(&self) -> bool {
|
|
*self == READOC_A::READ2IO
|
|
}
|
|
#[doc = "Checks if the value of the field is `READ4O`"]
|
|
#[inline(always)]
|
|
pub fn is_read4o(&self) -> bool {
|
|
*self == READOC_A::READ4O
|
|
}
|
|
#[doc = "Checks if the value of the field is `READ4IO`"]
|
|
#[inline(always)]
|
|
pub fn is_read4io(&self) -> bool {
|
|
*self == READOC_A::READ4IO
|
|
}
|
|
}
|
|
#[doc = "Field `READOC` writer - Configure number of data lines and opcode used for reading."]
|
|
pub type READOC_W<'a, const O: u8> =
|
|
crate::FieldWriter<'a, u32, IFCONFIG0_SPEC, u8, READOC_A, 3, O>;
|
|
impl<'a, const O: u8> READOC_W<'a, O> {
|
|
#[doc = "Single data line SPI. FAST_READ (opcode 0x0B)."]
|
|
#[inline(always)]
|
|
pub fn fastread(self) -> &'a mut W {
|
|
self.variant(READOC_A::FASTREAD)
|
|
}
|
|
#[doc = "Dual data line SPI. READ2O (opcode 0x3B)."]
|
|
#[inline(always)]
|
|
pub fn read2o(self) -> &'a mut W {
|
|
self.variant(READOC_A::READ2O)
|
|
}
|
|
#[doc = "Dual data line SPI. READ2IO (opcode 0xBB)."]
|
|
#[inline(always)]
|
|
pub fn read2io(self) -> &'a mut W {
|
|
self.variant(READOC_A::READ2IO)
|
|
}
|
|
#[doc = "Quad data line SPI. READ4O (opcode 0x6B)."]
|
|
#[inline(always)]
|
|
pub fn read4o(self) -> &'a mut W {
|
|
self.variant(READOC_A::READ4O)
|
|
}
|
|
#[doc = "Quad data line SPI. READ4IO (opcode 0xEB)."]
|
|
#[inline(always)]
|
|
pub fn read4io(self) -> &'a mut W {
|
|
self.variant(READOC_A::READ4IO)
|
|
}
|
|
}
|
|
#[doc = "Field `WRITEOC` reader - Configure number of data lines and opcode used for writing."]
|
|
pub type WRITEOC_R = crate::FieldReader<u8, WRITEOC_A>;
|
|
#[doc = "Configure number of data lines and opcode used for writing.\n\nValue on reset: 0"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
#[repr(u8)]
|
|
pub enum WRITEOC_A {
|
|
#[doc = "0: Single data line SPI. PP (opcode 0x02)."]
|
|
PP = 0,
|
|
#[doc = "1: Dual data line SPI. PP2O (opcode 0xA2)."]
|
|
PP2O = 1,
|
|
#[doc = "2: Quad data line SPI. PP4O (opcode 0x32)."]
|
|
PP4O = 2,
|
|
#[doc = "3: Quad data line SPI. PP4IO (opcode 0x38)."]
|
|
PP4IO = 3,
|
|
}
|
|
impl From<WRITEOC_A> for u8 {
|
|
#[inline(always)]
|
|
fn from(variant: WRITEOC_A) -> Self {
|
|
variant as _
|
|
}
|
|
}
|
|
impl WRITEOC_R {
|
|
#[doc = "Get enumerated values variant"]
|
|
#[inline(always)]
|
|
pub fn variant(&self) -> Option<WRITEOC_A> {
|
|
match self.bits {
|
|
0 => Some(WRITEOC_A::PP),
|
|
1 => Some(WRITEOC_A::PP2O),
|
|
2 => Some(WRITEOC_A::PP4O),
|
|
3 => Some(WRITEOC_A::PP4IO),
|
|
_ => None,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `PP`"]
|
|
#[inline(always)]
|
|
pub fn is_pp(&self) -> bool {
|
|
*self == WRITEOC_A::PP
|
|
}
|
|
#[doc = "Checks if the value of the field is `PP2O`"]
|
|
#[inline(always)]
|
|
pub fn is_pp2o(&self) -> bool {
|
|
*self == WRITEOC_A::PP2O
|
|
}
|
|
#[doc = "Checks if the value of the field is `PP4O`"]
|
|
#[inline(always)]
|
|
pub fn is_pp4o(&self) -> bool {
|
|
*self == WRITEOC_A::PP4O
|
|
}
|
|
#[doc = "Checks if the value of the field is `PP4IO`"]
|
|
#[inline(always)]
|
|
pub fn is_pp4io(&self) -> bool {
|
|
*self == WRITEOC_A::PP4IO
|
|
}
|
|
}
|
|
#[doc = "Field `WRITEOC` writer - Configure number of data lines and opcode used for writing."]
|
|
pub type WRITEOC_W<'a, const O: u8> =
|
|
crate::FieldWriter<'a, u32, IFCONFIG0_SPEC, u8, WRITEOC_A, 3, O>;
|
|
impl<'a, const O: u8> WRITEOC_W<'a, O> {
|
|
#[doc = "Single data line SPI. PP (opcode 0x02)."]
|
|
#[inline(always)]
|
|
pub fn pp(self) -> &'a mut W {
|
|
self.variant(WRITEOC_A::PP)
|
|
}
|
|
#[doc = "Dual data line SPI. PP2O (opcode 0xA2)."]
|
|
#[inline(always)]
|
|
pub fn pp2o(self) -> &'a mut W {
|
|
self.variant(WRITEOC_A::PP2O)
|
|
}
|
|
#[doc = "Quad data line SPI. PP4O (opcode 0x32)."]
|
|
#[inline(always)]
|
|
pub fn pp4o(self) -> &'a mut W {
|
|
self.variant(WRITEOC_A::PP4O)
|
|
}
|
|
#[doc = "Quad data line SPI. PP4IO (opcode 0x38)."]
|
|
#[inline(always)]
|
|
pub fn pp4io(self) -> &'a mut W {
|
|
self.variant(WRITEOC_A::PP4IO)
|
|
}
|
|
}
|
|
#[doc = "Field `ADDRMODE` reader - Addressing mode."]
|
|
pub type ADDRMODE_R = crate::BitReader<ADDRMODE_A>;
|
|
#[doc = "Addressing mode.\n\nValue on reset: 0"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum ADDRMODE_A {
|
|
#[doc = "0: 24-bit addressing."]
|
|
_24BIT = 0,
|
|
#[doc = "1: 32-bit addressing."]
|
|
_32BIT = 1,
|
|
}
|
|
impl From<ADDRMODE_A> for bool {
|
|
#[inline(always)]
|
|
fn from(variant: ADDRMODE_A) -> Self {
|
|
variant as u8 != 0
|
|
}
|
|
}
|
|
impl ADDRMODE_R {
|
|
#[doc = "Get enumerated values variant"]
|
|
#[inline(always)]
|
|
pub fn variant(&self) -> ADDRMODE_A {
|
|
match self.bits {
|
|
false => ADDRMODE_A::_24BIT,
|
|
true => ADDRMODE_A::_32BIT,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `_24BIT`"]
|
|
#[inline(always)]
|
|
pub fn is_24bit(&self) -> bool {
|
|
*self == ADDRMODE_A::_24BIT
|
|
}
|
|
#[doc = "Checks if the value of the field is `_32BIT`"]
|
|
#[inline(always)]
|
|
pub fn is_32bit(&self) -> bool {
|
|
*self == ADDRMODE_A::_32BIT
|
|
}
|
|
}
|
|
#[doc = "Field `ADDRMODE` writer - Addressing mode."]
|
|
pub type ADDRMODE_W<'a, const O: u8> = crate::BitWriter<'a, u32, IFCONFIG0_SPEC, ADDRMODE_A, O>;
|
|
impl<'a, const O: u8> ADDRMODE_W<'a, O> {
|
|
#[doc = "24-bit addressing."]
|
|
#[inline(always)]
|
|
pub fn _24bit(self) -> &'a mut W {
|
|
self.variant(ADDRMODE_A::_24BIT)
|
|
}
|
|
#[doc = "32-bit addressing."]
|
|
#[inline(always)]
|
|
pub fn _32bit(self) -> &'a mut W {
|
|
self.variant(ADDRMODE_A::_32BIT)
|
|
}
|
|
}
|
|
#[doc = "Field `DPMENABLE` reader - Enable deep power-down mode (DPM) feature."]
|
|
pub type DPMENABLE_R = crate::BitReader<DPMENABLE_A>;
|
|
#[doc = "Enable deep power-down mode (DPM) feature.\n\nValue on reset: 0"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum DPMENABLE_A {
|
|
#[doc = "0: Disable DPM feature."]
|
|
DISABLE = 0,
|
|
#[doc = "1: Enable DPM feature."]
|
|
ENABLE = 1,
|
|
}
|
|
impl From<DPMENABLE_A> for bool {
|
|
#[inline(always)]
|
|
fn from(variant: DPMENABLE_A) -> Self {
|
|
variant as u8 != 0
|
|
}
|
|
}
|
|
impl DPMENABLE_R {
|
|
#[doc = "Get enumerated values variant"]
|
|
#[inline(always)]
|
|
pub fn variant(&self) -> DPMENABLE_A {
|
|
match self.bits {
|
|
false => DPMENABLE_A::DISABLE,
|
|
true => DPMENABLE_A::ENABLE,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `DISABLE`"]
|
|
#[inline(always)]
|
|
pub fn is_disable(&self) -> bool {
|
|
*self == DPMENABLE_A::DISABLE
|
|
}
|
|
#[doc = "Checks if the value of the field is `ENABLE`"]
|
|
#[inline(always)]
|
|
pub fn is_enable(&self) -> bool {
|
|
*self == DPMENABLE_A::ENABLE
|
|
}
|
|
}
|
|
#[doc = "Field `DPMENABLE` writer - Enable deep power-down mode (DPM) feature."]
|
|
pub type DPMENABLE_W<'a, const O: u8> = crate::BitWriter<'a, u32, IFCONFIG0_SPEC, DPMENABLE_A, O>;
|
|
impl<'a, const O: u8> DPMENABLE_W<'a, O> {
|
|
#[doc = "Disable DPM feature."]
|
|
#[inline(always)]
|
|
pub fn disable(self) -> &'a mut W {
|
|
self.variant(DPMENABLE_A::DISABLE)
|
|
}
|
|
#[doc = "Enable DPM feature."]
|
|
#[inline(always)]
|
|
pub fn enable(self) -> &'a mut W {
|
|
self.variant(DPMENABLE_A::ENABLE)
|
|
}
|
|
}
|
|
#[doc = "Field `PPSIZE` reader - Page size for commands PP, PP2O, PP4O and PP4IO."]
|
|
pub type PPSIZE_R = crate::BitReader<PPSIZE_A>;
|
|
#[doc = "Page size for commands PP, PP2O, PP4O and PP4IO.\n\nValue on reset: 0"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum PPSIZE_A {
|
|
#[doc = "0: 256 bytes."]
|
|
_256BYTES = 0,
|
|
#[doc = "1: 512 bytes."]
|
|
_512BYTES = 1,
|
|
}
|
|
impl From<PPSIZE_A> for bool {
|
|
#[inline(always)]
|
|
fn from(variant: PPSIZE_A) -> Self {
|
|
variant as u8 != 0
|
|
}
|
|
}
|
|
impl PPSIZE_R {
|
|
#[doc = "Get enumerated values variant"]
|
|
#[inline(always)]
|
|
pub fn variant(&self) -> PPSIZE_A {
|
|
match self.bits {
|
|
false => PPSIZE_A::_256BYTES,
|
|
true => PPSIZE_A::_512BYTES,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `_256BYTES`"]
|
|
#[inline(always)]
|
|
pub fn is_256bytes(&self) -> bool {
|
|
*self == PPSIZE_A::_256BYTES
|
|
}
|
|
#[doc = "Checks if the value of the field is `_512BYTES`"]
|
|
#[inline(always)]
|
|
pub fn is_512bytes(&self) -> bool {
|
|
*self == PPSIZE_A::_512BYTES
|
|
}
|
|
}
|
|
#[doc = "Field `PPSIZE` writer - Page size for commands PP, PP2O, PP4O and PP4IO."]
|
|
pub type PPSIZE_W<'a, const O: u8> = crate::BitWriter<'a, u32, IFCONFIG0_SPEC, PPSIZE_A, O>;
|
|
impl<'a, const O: u8> PPSIZE_W<'a, O> {
|
|
#[doc = "256 bytes."]
|
|
#[inline(always)]
|
|
pub fn _256bytes(self) -> &'a mut W {
|
|
self.variant(PPSIZE_A::_256BYTES)
|
|
}
|
|
#[doc = "512 bytes."]
|
|
#[inline(always)]
|
|
pub fn _512bytes(self) -> &'a mut W {
|
|
self.variant(PPSIZE_A::_512BYTES)
|
|
}
|
|
}
|
|
impl R {
|
|
#[doc = "Bits 0:2 - Configure number of data lines and opcode used for reading."]
|
|
#[inline(always)]
|
|
pub fn readoc(&self) -> READOC_R {
|
|
READOC_R::new((self.bits & 7) as u8)
|
|
}
|
|
#[doc = "Bits 3:5 - Configure number of data lines and opcode used for writing."]
|
|
#[inline(always)]
|
|
pub fn writeoc(&self) -> WRITEOC_R {
|
|
WRITEOC_R::new(((self.bits >> 3) & 7) as u8)
|
|
}
|
|
#[doc = "Bit 6 - Addressing mode."]
|
|
#[inline(always)]
|
|
pub fn addrmode(&self) -> ADDRMODE_R {
|
|
ADDRMODE_R::new(((self.bits >> 6) & 1) != 0)
|
|
}
|
|
#[doc = "Bit 7 - Enable deep power-down mode (DPM) feature."]
|
|
#[inline(always)]
|
|
pub fn dpmenable(&self) -> DPMENABLE_R {
|
|
DPMENABLE_R::new(((self.bits >> 7) & 1) != 0)
|
|
}
|
|
#[doc = "Bit 12 - Page size for commands PP, PP2O, PP4O and PP4IO."]
|
|
#[inline(always)]
|
|
pub fn ppsize(&self) -> PPSIZE_R {
|
|
PPSIZE_R::new(((self.bits >> 12) & 1) != 0)
|
|
}
|
|
}
|
|
impl W {
|
|
#[doc = "Bits 0:2 - Configure number of data lines and opcode used for reading."]
|
|
#[inline(always)]
|
|
pub fn readoc(&mut self) -> READOC_W<0> {
|
|
READOC_W::new(self)
|
|
}
|
|
#[doc = "Bits 3:5 - Configure number of data lines and opcode used for writing."]
|
|
#[inline(always)]
|
|
pub fn writeoc(&mut self) -> WRITEOC_W<3> {
|
|
WRITEOC_W::new(self)
|
|
}
|
|
#[doc = "Bit 6 - Addressing mode."]
|
|
#[inline(always)]
|
|
pub fn addrmode(&mut self) -> ADDRMODE_W<6> {
|
|
ADDRMODE_W::new(self)
|
|
}
|
|
#[doc = "Bit 7 - Enable deep power-down mode (DPM) feature."]
|
|
#[inline(always)]
|
|
pub fn dpmenable(&mut self) -> DPMENABLE_W<7> {
|
|
DPMENABLE_W::new(self)
|
|
}
|
|
#[doc = "Bit 12 - Page size for commands PP, PP2O, PP4O and PP4IO."]
|
|
#[inline(always)]
|
|
pub fn ppsize(&mut self) -> PPSIZE_W<12> {
|
|
PPSIZE_W::new(self)
|
|
}
|
|
#[doc = "Writes raw bits to the register."]
|
|
#[inline(always)]
|
|
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
|
self.0.bits(bits);
|
|
self
|
|
}
|
|
}
|
|
#[doc = "Interface configuration.\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [ifconfig0](index.html) module"]
|
|
pub struct IFCONFIG0_SPEC;
|
|
impl crate::RegisterSpec for IFCONFIG0_SPEC {
|
|
type Ux = u32;
|
|
}
|
|
#[doc = "`read()` method returns [ifconfig0::R](R) reader structure"]
|
|
impl crate::Readable for IFCONFIG0_SPEC {
|
|
type Reader = R;
|
|
}
|
|
#[doc = "`write(|w| ..)` method takes [ifconfig0::W](W) writer structure"]
|
|
impl crate::Writable for IFCONFIG0_SPEC {
|
|
type Writer = W;
|
|
}
|
|
#[doc = "`reset()` method sets IFCONFIG0 to value 0"]
|
|
impl crate::Resettable for IFCONFIG0_SPEC {
|
|
#[inline(always)]
|
|
fn reset_value() -> Self::Ux {
|
|
0
|
|
}
|
|
}
|