├── rustfmt.toml ├── data ├── tm4c123x.xml └── tm4c129x.xml ├── .gitignore ├── crates ├── .gitignore ├── Cargo.toml ├── tm4c123x │ ├── src │ │ ├── hib │ │ │ ├── rtcc.rs │ │ │ ├── rtcld.rs │ │ │ └── rtcm0.rs │ │ ├── qei0 │ │ │ ├── count.rs │ │ │ ├── speed.rs │ │ │ ├── time.rs │ │ │ ├── pos.rs │ │ │ ├── load.rs │ │ │ ├── maxpos.rs │ │ │ ├── stat.rs │ │ │ └── ris.rs │ │ ├── timer0 │ │ │ ├── tar.rs │ │ │ ├── tbr.rs │ │ │ ├── tapv.rs │ │ │ ├── tbps.rs │ │ │ ├── tbpv.rs │ │ │ ├── taps.rs │ │ │ ├── rtcpd.rs │ │ │ ├── tav.rs │ │ │ ├── tbv.rs │ │ │ ├── tailr.rs │ │ │ └── tbilr.rs │ │ ├── wtimer0 │ │ │ ├── tar.rs │ │ │ ├── tbr.rs │ │ │ ├── tapv.rs │ │ │ ├── tbps.rs │ │ │ ├── tbpv.rs │ │ │ ├── taps.rs │ │ │ ├── rtcpd.rs │ │ │ ├── tav.rs │ │ │ ├── tbv.rs │ │ │ ├── tailr.rs │ │ │ └── tbilr.rs │ │ ├── watchdog0 │ │ │ ├── value.rs │ │ │ ├── icr.rs │ │ │ ├── ris.rs │ │ │ ├── mis.rs │ │ │ └── load.rs │ │ ├── udma │ │ │ ├── swreq.rs │ │ │ ├── altbase.rs │ │ │ ├── waitstat.rs │ │ │ ├── chis.rs │ │ │ ├── altclr.rs │ │ │ ├── enaclr.rs │ │ │ ├── prioclr.rs │ │ │ ├── reqmaskclr.rs │ │ │ ├── useburstclr.rs │ │ │ └── cfg.rs │ │ ├── i2c0 │ │ │ ├── pc.rs │ │ │ ├── pp.rs │ │ │ ├── mbmon.rs │ │ │ ├── mmis.rs │ │ │ ├── mris.rs │ │ │ ├── sris.rs │ │ │ └── smis.rs │ │ ├── eeprom │ │ │ ├── pp.rs │ │ │ └── eesize.rs │ │ ├── sysctl │ │ │ ├── ppdma.rs │ │ │ ├── ppusb.rs │ │ │ ├── sysprop.rs │ │ │ ├── pllstat.rs │ │ │ ├── pphib.rs │ │ │ ├── prusb.rs │ │ │ ├── ppeeprom.rs │ │ │ ├── prdma.rs │ │ │ ├── ppacmp.rs │ │ │ ├── prhib.rs │ │ │ ├── preeprom.rs │ │ │ ├── nvmstat.rs │ │ │ ├── pracmp.rs │ │ │ ├── ppadc.rs │ │ │ ├── ppcan.rs │ │ │ ├── pppwm.rs │ │ │ ├── ppqei.rs │ │ │ ├── ppwd.rs │ │ │ ├── pradc.rs │ │ │ ├── prcan.rs │ │ │ ├── prpwm.rs │ │ │ ├── prqei.rs │ │ │ ├── prwd.rs │ │ │ ├── ppssi.rs │ │ │ ├── pri2c.rs │ │ │ └── prssi.rs │ │ ├── usb0 │ │ │ ├── count0.rs │ │ │ ├── frame.rs │ │ │ ├── vdcris.rs │ │ │ ├── epcris.rs │ │ │ ├── idvris.rs │ │ │ ├── drris.rs │ │ │ ├── rxcount1.rs │ │ │ ├── rxcount2.rs │ │ │ ├── rxcount3.rs │ │ │ ├── rxcount4.rs │ │ │ ├── rxcount5.rs │ │ │ ├── rxcount6.rs │ │ │ ├── rxcount7.rs │ │ │ ├── rqpktcount1.rs │ │ │ ├── rqpktcount2.rs │ │ │ └── rqpktcount3.rs │ │ ├── can0 │ │ │ ├── nwda1.rs │ │ │ ├── nwda2.rs │ │ │ ├── msg1int.rs │ │ │ ├── msg1val.rs │ │ │ ├── msg2int.rs │ │ │ ├── msg2val.rs │ │ │ ├── txrq1.rs │ │ │ ├── txrq2.rs │ │ │ └── err.rs │ │ ├── gpio_porta │ │ │ ├── mis.rs │ │ │ ├── ris.rs │ │ │ ├── cr.rs │ │ │ ├── is.rs │ │ │ ├── den.rs │ │ │ ├── dir.rs │ │ │ ├── ibe.rs │ │ │ ├── iev.rs │ │ │ ├── odr.rs │ │ │ ├── pdr.rs │ │ │ ├── pur.rs │ │ │ ├── slr.rs │ │ │ ├── data.rs │ │ │ ├── dr2r.rs │ │ │ ├── dr4r.rs │ │ │ ├── dr8r.rs │ │ │ ├── pctl.rs │ │ │ ├── afsel.rs │ │ │ ├── amsel.rs │ │ │ ├── adcctl.rs │ │ │ ├── dmactl.rs │ │ │ └── icr.rs │ │ ├── adc0 │ │ │ ├── ssfifo0.rs │ │ │ ├── ssfifo1.rs │ │ │ ├── ssfifo2.rs │ │ │ ├── ssfifo3.rs │ │ │ ├── ssfstat0.rs │ │ │ ├── ssfstat1.rs │ │ │ ├── ssfstat2.rs │ │ │ └── ssfstat3.rs │ │ ├── pwm0 │ │ │ ├── _0_count.rs │ │ │ ├── _1_count.rs │ │ │ ├── _2_count.rs │ │ │ ├── _3_count.rs │ │ │ └── status.rs │ │ ├── comp │ │ │ ├── acstat0.rs │ │ │ ├── acstat1.rs │ │ │ ├── acris.rs │ │ │ └── pp.rs │ │ ├── flash_ctrl │ │ │ ├── romswmap.rs │ │ │ ├── fmppe0.rs │ │ │ ├── fmppe1.rs │ │ │ ├── fmppe2.rs │ │ │ ├── fmppe3.rs │ │ │ ├── fmpre0.rs │ │ │ ├── fmpre1.rs │ │ │ ├── fmpre2.rs │ │ │ └── fmpre3.rs │ │ └── uart0 │ │ │ └── pp.rs │ ├── build.rs │ ├── README.md │ ├── Cargo.toml │ └── LICENSE-0BSD.txt └── tm4c129x │ ├── src │ ├── hib │ │ ├── rtcc.rs │ │ ├── tplog0.rs │ │ ├── tplog2.rs │ │ ├── tplog4.rs │ │ ├── tplog6.rs │ │ ├── rtcld.rs │ │ ├── rtcm0.rs │ │ └── pp.rs │ ├── qei0 │ │ ├── count.rs │ │ ├── speed.rs │ │ ├── time.rs │ │ ├── pos.rs │ │ ├── load.rs │ │ ├── maxpos.rs │ │ ├── stat.rs │ │ └── ris.rs │ ├── timer0 │ │ ├── tar.rs │ │ ├── tbr.rs │ │ ├── tbps.rs │ │ ├── taps.rs │ │ ├── rtcpd.rs │ │ ├── tav.rs │ │ ├── tbv.rs │ │ ├── tailr.rs │ │ └── tbilr.rs │ ├── watchdog0 │ │ ├── value.rs │ │ ├── icr.rs │ │ ├── ris.rs │ │ ├── mis.rs │ │ └── load.rs │ ├── udma │ │ ├── swreq.rs │ │ ├── altbase.rs │ │ ├── waitstat.rs │ │ ├── altclr.rs │ │ ├── enaclr.rs │ │ ├── prioclr.rs │ │ ├── reqmaskclr.rs │ │ └── useburstclr.rs │ ├── i2c0 │ │ ├── pc.rs │ │ ├── pp.rs │ │ ├── mbcnt.rs │ │ └── mbmon.rs │ ├── sysctl │ │ ├── ppdma.rs │ │ ├── ppepi.rs │ │ ├── ppfan.rs │ │ ├── pphim.rs │ │ ├── pplcd.rs │ │ ├── pplpc.rs │ │ ├── pppeci.rs │ │ ├── pppwm.rs │ │ ├── ppqei.rs │ │ ├── pprts.rs │ │ ├── ppusb.rs │ │ ├── sysprop.rs │ │ ├── pllstat.rs │ │ ├── pphib.rs │ │ ├── ppowire.rs │ │ ├── prepi.rs │ │ ├── prusb.rs │ │ ├── ppeeprom.rs │ │ ├── ppephy.rs │ │ ├── prdma.rs │ │ ├── prpwm.rs │ │ ├── prqei.rs │ │ ├── ppacmp.rs │ │ ├── ppccm.rs │ │ ├── ppemac.rs │ │ ├── prhib.rs │ │ ├── preeprom.rs │ │ ├── premac.rs │ │ ├── prephy.rs │ │ ├── nvmstat.rs │ │ ├── pracmp.rs │ │ ├── prccm.rs │ │ ├── ppwtimer.rs │ │ ├── ppadc.rs │ │ ├── ppcan.rs │ │ ├── ppwd.rs │ │ ├── pradc.rs │ │ ├── prcan.rs │ │ ├── prwd.rs │ │ ├── ppssi.rs │ │ └── prssi.rs │ ├── gpio_porta_ahb │ │ ├── pp.rs │ │ ├── wakestat.rs │ │ ├── cr.rs │ │ ├── is.rs │ │ ├── ibe.rs │ │ ├── iev.rs │ │ ├── ris.rs │ │ ├── mis.rs │ │ ├── den.rs │ │ ├── dir.rs │ │ └── odr.rs │ ├── usb0 │ │ ├── count0.rs │ │ ├── frame.rs │ │ ├── vdcris.rs │ │ ├── epcris.rs │ │ ├── drris.rs │ │ ├── rxcount1.rs │ │ ├── rxcount2.rs │ │ ├── rxcount3.rs │ │ ├── rxcount4.rs │ │ ├── rxcount5.rs │ │ ├── rxcount6.rs │ │ ├── rxcount7.rs │ │ ├── rqpktcount1.rs │ │ ├── rqpktcount2.rs │ │ ├── rqpktcount3.rs │ │ ├── epinfo.rs │ │ ├── raminfo.rs │ │ └── cc.rs │ ├── epi0 │ │ ├── rfifocnt.rs │ │ ├── readfifo0.rs │ │ ├── readfifo1.rs │ │ ├── readfifo2.rs │ │ ├── readfifo3.rs │ │ ├── readfifo4.rs │ │ ├── readfifo5.rs │ │ ├── readfifo6.rs │ │ ├── readfifo7.rs │ │ └── wfifocnt.rs │ ├── can0 │ │ ├── nwda1.rs │ │ ├── nwda2.rs │ │ ├── msg1int.rs │ │ ├── msg1val.rs │ │ ├── msg2int.rs │ │ ├── msg2val.rs │ │ ├── txrq1.rs │ │ ├── txrq2.rs │ │ └── err.rs │ ├── emac0 │ │ ├── timsec.rs │ │ ├── ephyris.rs │ │ ├── timnano.rs │ │ ├── hosrxba.rs │ │ ├── hostxba.rs │ │ ├── hosrxdesc.rs │ │ ├── hostxdesc.rs │ │ ├── rxcntgb.rs │ │ ├── rxcntguni.rs │ │ ├── pps0width.rs │ │ ├── rxcntcrcerr.rs │ │ ├── txcntgb.rs │ │ ├── txoctcntg.rs │ │ ├── rxcntalgnerr.rs │ │ ├── txcntscol.rs │ │ ├── txcntmcol.rs │ │ ├── cc.rs │ │ ├── timstat.rs │ │ ├── rxpolld.rs │ │ └── txpolld.rs │ ├── adc0 │ │ ├── ssfifo0.rs │ │ ├── ssfifo1.rs │ │ ├── ssfifo2.rs │ │ ├── ssfifo3.rs │ │ ├── ssfstat0.rs │ │ ├── ssfstat1.rs │ │ ├── ssfstat2.rs │ │ └── ssfstat3.rs │ ├── pwm0 │ │ ├── _0_count.rs │ │ ├── _1_count.rs │ │ ├── _2_count.rs │ │ └── _3_count.rs │ ├── comp │ │ ├── acstat0.rs │ │ ├── acstat1.rs │ │ ├── acstat2.rs │ │ └── acris.rs │ ├── ccm0 │ │ └── crcrsltpp.rs │ ├── flash_ctrl │ │ ├── fmppe0.rs │ │ ├── fmppe1.rs │ │ ├── fmppe2.rs │ │ ├── fmppe3.rs │ │ ├── fmppe4.rs │ │ ├── fmppe5.rs │ │ ├── fmppe6.rs │ │ ├── fmppe7.rs │ │ ├── fmpre0.rs │ │ ├── fmpre1.rs │ │ ├── fmpre2.rs │ │ ├── fmpre3.rs │ │ ├── fmpre4.rs │ │ ├── fmpre5.rs │ │ ├── fmpre6.rs │ │ └── fmpre7.rs │ ├── eeprom │ │ └── eesize.rs │ └── uart0 │ │ └── pp.rs │ ├── build.rs │ ├── README.md │ ├── Cargo.toml │ └── LICENSE-0BSD.txt ├── Gemfile ├── Gemfile.lock └── LICENSE-0BSD.txt /rustfmt.toml: -------------------------------------------------------------------------------- 1 | max_width = 4000 2 | -------------------------------------------------------------------------------- /data/tm4c123x.xml: -------------------------------------------------------------------------------- 1 | ../targetdb/devices/tm4c123gh6pm.xml -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | /targetdb 2 | /*.xml 3 | /vendor 4 | /.bundle -------------------------------------------------------------------------------- /data/tm4c129x.xml: -------------------------------------------------------------------------------- 1 | ../targetdb/devices/tm4c1294ncpdt.xml -------------------------------------------------------------------------------- /crates/.gitignore: -------------------------------------------------------------------------------- 1 | target/ 2 | **/*.rs.bk 3 | Cargo.lock 4 | -------------------------------------------------------------------------------- /crates/Cargo.toml: -------------------------------------------------------------------------------- 1 | [workspace] 2 | members = ["tm4c123x", "tm4c129x"] -------------------------------------------------------------------------------- /Gemfile: -------------------------------------------------------------------------------- 1 | source 'https://rubygems.org' 2 | 3 | gem 'oga' 4 | gem 'builder' 5 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/hib/rtcc.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register RTCC"] 2 | pub type R = crate::R; 3 | impl R {} 4 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/qei0/count.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register COUNT"] 2 | pub type R = crate::R; 3 | impl R {} 4 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/qei0/speed.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register SPEED"] 2 | pub type R = crate::R; 3 | impl R {} 4 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/qei0/time.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register TIME"] 2 | pub type R = crate::R; 3 | impl R {} 4 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/timer0/tar.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register TAR"] 2 | pub type R = crate::R; 3 | impl R {} 4 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/timer0/tbr.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register TBR"] 2 | pub type R = crate::R; 3 | impl R {} 4 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/wtimer0/tar.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register TAR"] 2 | pub type R = crate::R; 3 | impl R {} 4 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/wtimer0/tbr.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register TBR"] 2 | pub type R = crate::R; 3 | impl R {} 4 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/hib/rtcc.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register RTCC"] 2 | pub type R = crate::R; 3 | impl R {} 4 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/qei0/count.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register COUNT"] 2 | pub type R = crate::R; 3 | impl R {} 4 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/qei0/speed.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register SPEED"] 2 | pub type R = crate::R; 3 | impl R {} 4 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/qei0/time.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register TIME"] 2 | pub type R = crate::R; 3 | impl R {} 4 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/timer0/tar.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register TAR"] 2 | pub type R = crate::R; 3 | impl R {} 4 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/timer0/tbr.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register TBR"] 2 | pub type R = crate::R; 3 | impl R {} 4 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/watchdog0/value.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register VALUE"] 2 | pub type R = crate::R; 3 | impl R {} 4 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/watchdog0/value.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register VALUE"] 2 | pub type R = crate::R; 3 | impl R {} 4 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/watchdog0/icr.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register ICR"] 2 | pub type W = crate::W; 3 | #[doc = "Register ICR `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::ICR { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/watchdog0/icr.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register ICR"] 2 | pub type W = crate::W; 3 | #[doc = "Register ICR `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::ICR { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/udma/swreq.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register SWREQ"] 2 | pub type W = crate::W; 3 | #[doc = "Register SWREQ `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::SWREQ { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/udma/swreq.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register SWREQ"] 2 | pub type W = crate::W; 3 | #[doc = "Register SWREQ `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::SWREQ { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | impl W {} 12 | -------------------------------------------------------------------------------- /Gemfile.lock: -------------------------------------------------------------------------------- 1 | GEM 2 | remote: https://rubygems.org/ 3 | specs: 4 | ansi (1.5.0) 5 | ast (2.3.0) 6 | builder (3.2.2) 7 | oga (2.10) 8 | ast 9 | ruby-ll (~> 2.1) 10 | ruby-ll (2.1.2) 11 | ansi 12 | ast 13 | 14 | PLATFORMS 15 | ruby 16 | 17 | DEPENDENCIES 18 | builder 19 | oga 20 | 21 | BUNDLED WITH 22 | 1.13.6 23 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/i2c0/pc.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PC"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `HS`"] 4 | pub type HS_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - High-Speed Capable"] 7 | #[inline(always)] 8 | pub fn hs(&self) -> HS_R { 9 | HS_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/i2c0/pp.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PP"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `HS`"] 4 | pub type HS_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - High-Speed Capable"] 7 | #[inline(always)] 8 | pub fn hs(&self) -> HS_R { 9 | HS_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/i2c0/pc.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PC"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `HS`"] 4 | pub type HS_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - High-Speed Capable"] 7 | #[inline(always)] 8 | pub fn hs(&self) -> HS_R { 9 | HS_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/i2c0/pp.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PP"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `HS`"] 4 | pub type HS_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - High-Speed Capable"] 7 | #[inline(always)] 8 | pub fn hs(&self) -> HS_R { 9 | HS_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/eeprom/pp.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PP"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `SIZE`"] 4 | pub type SIZE_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:4 - EEPROM Size"] 7 | #[inline(always)] 8 | pub fn size(&self) -> SIZE_R { 9 | SIZE_R::new((self.bits & 0x1f) as u8) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/sysctl/ppdma.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PPDMA"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `P0`"] 4 | pub type P0_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - uDMA Module Present"] 7 | #[inline(always)] 8 | pub fn p0(&self) -> P0_R { 9 | P0_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/sysctl/ppusb.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PPUSB"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `P0`"] 4 | pub type P0_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - USB Module Present"] 7 | #[inline(always)] 8 | pub fn p0(&self) -> P0_R { 9 | P0_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/sysctl/sysprop.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register SYSPROP"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `FPU`"] 4 | pub type FPU_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - FPU Present"] 7 | #[inline(always)] 8 | pub fn fpu(&self) -> FPU_R { 9 | FPU_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/sysctl/ppdma.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PPDMA"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `P0`"] 4 | pub type P0_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - uDMA Module Present"] 7 | #[inline(always)] 8 | pub fn p0(&self) -> P0_R { 9 | P0_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/sysctl/ppepi.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PPEPI"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `P0`"] 4 | pub type P0_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - EPI Module Present"] 7 | #[inline(always)] 8 | pub fn p0(&self) -> P0_R { 9 | P0_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/sysctl/ppfan.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PPFAN"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `P0`"] 4 | pub type P0_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - FAN Module 0 Present"] 7 | #[inline(always)] 8 | pub fn p0(&self) -> P0_R { 9 | P0_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/sysctl/pphim.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PPHIM"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `P0`"] 4 | pub type P0_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - HIM Module Present"] 7 | #[inline(always)] 8 | pub fn p0(&self) -> P0_R { 9 | P0_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/sysctl/pplcd.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PPLCD"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `P0`"] 4 | pub type P0_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - LCD Module Present"] 7 | #[inline(always)] 8 | pub fn p0(&self) -> P0_R { 9 | P0_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/sysctl/pplpc.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PPLPC"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `P0`"] 4 | pub type P0_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - LPC Module Present"] 7 | #[inline(always)] 8 | pub fn p0(&self) -> P0_R { 9 | P0_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/sysctl/pppeci.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PPPECI"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `P0`"] 4 | pub type P0_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - PECI Module Present"] 7 | #[inline(always)] 8 | pub fn p0(&self) -> P0_R { 9 | P0_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/sysctl/pppwm.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PPPWM"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `P0`"] 4 | pub type P0_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - PWM Module 0 Present"] 7 | #[inline(always)] 8 | pub fn p0(&self) -> P0_R { 9 | P0_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/sysctl/ppqei.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PPQEI"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `P0`"] 4 | pub type P0_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - QEI Module 0 Present"] 7 | #[inline(always)] 8 | pub fn p0(&self) -> P0_R { 9 | P0_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/sysctl/pprts.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PPRTS"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `P0`"] 4 | pub type P0_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - RTS Module Present"] 7 | #[inline(always)] 8 | pub fn p0(&self) -> P0_R { 9 | P0_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/sysctl/ppusb.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PPUSB"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `P0`"] 4 | pub type P0_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - USB Module Present"] 7 | #[inline(always)] 8 | pub fn p0(&self) -> P0_R { 9 | P0_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/sysctl/sysprop.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register SYSPROP"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `FPU`"] 4 | pub type FPU_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - FPU Present"] 7 | #[inline(always)] 8 | pub fn fpu(&self) -> FPU_R { 9 | FPU_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/sysctl/pllstat.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PLLSTAT"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `LOCK`"] 4 | pub type LOCK_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - PLL Lock"] 7 | #[inline(always)] 8 | pub fn lock(&self) -> LOCK_R { 9 | LOCK_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/sysctl/pphib.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PPHIB"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `P0`"] 4 | pub type P0_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - Hibernation Module Present"] 7 | #[inline(always)] 8 | pub fn p0(&self) -> P0_R { 9 | P0_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/sysctl/prusb.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PRUSB"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `R0`"] 4 | pub type R0_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - USB Module Peripheral Ready"] 7 | #[inline(always)] 8 | pub fn r0(&self) -> R0_R { 9 | R0_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/usb0/count0.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register COUNT0"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `COUNT`"] 4 | pub type COUNT_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:6 - FIFO Count"] 7 | #[inline(always)] 8 | pub fn count(&self) -> COUNT_R { 9 | COUNT_R::new((self.bits & 0x7f) as u8) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/gpio_porta_ahb/pp.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PP"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `EDE`"] 4 | pub type EDE_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - Extended Drive Enable"] 7 | #[inline(always)] 8 | pub fn ede(&self) -> EDE_R { 9 | EDE_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/sysctl/pllstat.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PLLSTAT"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `LOCK`"] 4 | pub type LOCK_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - PLL Lock"] 7 | #[inline(always)] 8 | pub fn lock(&self) -> LOCK_R { 9 | LOCK_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/sysctl/pphib.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PPHIB"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `P0`"] 4 | pub type P0_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - Hibernation Module Present"] 7 | #[inline(always)] 8 | pub fn p0(&self) -> P0_R { 9 | P0_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/sysctl/ppowire.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PPOWIRE"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `P0`"] 4 | pub type P0_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - 1-Wire Module Present"] 7 | #[inline(always)] 8 | pub fn p0(&self) -> P0_R { 9 | P0_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/sysctl/prepi.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PREPI"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `R0`"] 4 | pub type R0_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - EPI Module Peripheral Ready"] 7 | #[inline(always)] 8 | pub fn r0(&self) -> R0_R { 9 | R0_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/sysctl/prusb.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PRUSB"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `R0`"] 4 | pub type R0_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - USB Module Peripheral Ready"] 7 | #[inline(always)] 8 | pub fn r0(&self) -> R0_R { 9 | R0_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/usb0/count0.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register COUNT0"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `COUNT`"] 4 | pub type COUNT_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:6 - FIFO Count"] 7 | #[inline(always)] 8 | pub fn count(&self) -> COUNT_R { 9 | COUNT_R::new((self.bits & 0x7f) as u8) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/sysctl/ppeeprom.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PPEEPROM"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `P0`"] 4 | pub type P0_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - EEPROM Module Present"] 7 | #[inline(always)] 8 | pub fn p0(&self) -> P0_R { 9 | P0_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/sysctl/prdma.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PRDMA"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `R0`"] 4 | pub type R0_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - uDMA Module Peripheral Ready"] 7 | #[inline(always)] 8 | pub fn r0(&self) -> R0_R { 9 | R0_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/usb0/frame.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register FRAME"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `FRAME`"] 4 | pub type FRAME_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:10 - Frame Number"] 7 | #[inline(always)] 8 | pub fn frame(&self) -> FRAME_R { 9 | FRAME_R::new((self.bits & 0x07ff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/usb0/vdcris.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register VDCRIS"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `VD`"] 4 | pub type VD_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - VBUS Droop Raw Interrupt Status"] 7 | #[inline(always)] 8 | pub fn vd(&self) -> VD_R { 9 | VD_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/epi0/rfifocnt.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register RFIFOCNT"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `COUNT`"] 4 | pub type COUNT_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:3 - FIFO Count"] 7 | #[inline(always)] 8 | pub fn count(&self) -> COUNT_R { 9 | COUNT_R::new((self.bits & 0x0f) as u8) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/i2c0/mbcnt.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register MBCNT"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `CNTL`"] 4 | pub type CNTL_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:7 - I2C Master Burst Count"] 7 | #[inline(always)] 8 | pub fn cntl(&self) -> CNTL_R { 9 | CNTL_R::new((self.bits & 0xff) as u8) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/sysctl/ppeeprom.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PPEEPROM"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `P0`"] 4 | pub type P0_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - EEPROM Module Present"] 7 | #[inline(always)] 8 | pub fn p0(&self) -> P0_R { 9 | P0_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/sysctl/ppephy.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PPEPHY"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `P0`"] 4 | pub type P0_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - Ethernet PHY Module Present"] 7 | #[inline(always)] 8 | pub fn p0(&self) -> P0_R { 9 | P0_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/sysctl/prdma.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PRDMA"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `R0`"] 4 | pub type R0_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - uDMA Module Peripheral Ready"] 7 | #[inline(always)] 8 | pub fn r0(&self) -> R0_R { 9 | R0_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/sysctl/prpwm.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PRPWM"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `R0`"] 4 | pub type R0_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - PWM Module 0 Peripheral Ready"] 7 | #[inline(always)] 8 | pub fn r0(&self) -> R0_R { 9 | R0_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/sysctl/prqei.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PRQEI"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `R0`"] 4 | pub type R0_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - QEI Module 0 Peripheral Ready"] 7 | #[inline(always)] 8 | pub fn r0(&self) -> R0_R { 9 | R0_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/usb0/frame.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register FRAME"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `FRAME`"] 4 | pub type FRAME_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:10 - Frame Number"] 7 | #[inline(always)] 8 | pub fn frame(&self) -> FRAME_R { 9 | FRAME_R::new((self.bits & 0x07ff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/usb0/vdcris.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register VDCRIS"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `VD`"] 4 | pub type VD_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - VBUS Droop Raw Interrupt Status"] 7 | #[inline(always)] 8 | pub fn vd(&self) -> VD_R { 9 | VD_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/can0/nwda1.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register NWDA1"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `NEWDAT`"] 4 | pub type NEWDAT_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:15 - New Data Bits"] 7 | #[inline(always)] 8 | pub fn newdat(&self) -> NEWDAT_R { 9 | NEWDAT_R::new((self.bits & 0xffff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/can0/nwda2.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register NWDA2"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `NEWDAT`"] 4 | pub type NEWDAT_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:15 - New Data Bits"] 7 | #[inline(always)] 8 | pub fn newdat(&self) -> NEWDAT_R { 9 | NEWDAT_R::new((self.bits & 0xffff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/gpio_porta/mis.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register MIS"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `GPIO`"] 4 | pub type GPIO_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:7 - GPIO Masked Interrupt Status"] 7 | #[inline(always)] 8 | pub fn gpio(&self) -> GPIO_R { 9 | GPIO_R::new((self.bits & 0xff) as u8) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/gpio_porta/ris.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register RIS"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `GPIO`"] 4 | pub type GPIO_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:7 - GPIO Interrupt Raw Status"] 7 | #[inline(always)] 8 | pub fn gpio(&self) -> GPIO_R { 9 | GPIO_R::new((self.bits & 0xff) as u8) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/sysctl/ppacmp.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PPACMP"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `P0`"] 4 | pub type P0_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - Analog Comparator Module Present"] 7 | #[inline(always)] 8 | pub fn p0(&self) -> P0_R { 9 | P0_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/sysctl/prhib.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PRHIB"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `R0`"] 4 | pub type R0_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - Hibernation Module Peripheral Ready"] 7 | #[inline(always)] 8 | pub fn r0(&self) -> R0_R { 9 | R0_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/timer0/tapv.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register TAPV"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `PSV`"] 4 | pub type PSV_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:15 - GPTM Timer A Prescaler Value"] 7 | #[inline(always)] 8 | pub fn psv(&self) -> PSV_R { 9 | PSV_R::new((self.bits & 0xffff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/timer0/tbps.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register TBPS"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `PSS`"] 4 | pub type PSS_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:15 - GPTM Timer A Prescaler Value"] 7 | #[inline(always)] 8 | pub fn pss(&self) -> PSS_R { 9 | PSS_R::new((self.bits & 0xffff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/timer0/tbpv.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register TBPV"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `PSV`"] 4 | pub type PSV_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:15 - GPTM Timer B Prescaler Value"] 7 | #[inline(always)] 8 | pub fn psv(&self) -> PSV_R { 9 | PSV_R::new((self.bits & 0xffff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/usb0/epcris.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EPCRIS"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `PF`"] 4 | pub type PF_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - USB Power Fault Interrupt Status"] 7 | #[inline(always)] 8 | pub fn pf(&self) -> PF_R { 9 | PF_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/usb0/idvris.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register IDVRIS"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `ID`"] 4 | pub type ID_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - ID Valid Detect Raw Interrupt Status"] 7 | #[inline(always)] 8 | pub fn id(&self) -> ID_R { 9 | ID_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/wtimer0/tapv.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register TAPV"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `PSV`"] 4 | pub type PSV_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:15 - GPTM Timer A Prescaler Value"] 7 | #[inline(always)] 8 | pub fn psv(&self) -> PSV_R { 9 | PSV_R::new((self.bits & 0xffff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/wtimer0/tbps.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register TBPS"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `PSS`"] 4 | pub type PSS_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:15 - GPTM Timer A Prescaler Value"] 7 | #[inline(always)] 8 | pub fn pss(&self) -> PSS_R { 9 | PSS_R::new((self.bits & 0xffff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/wtimer0/tbpv.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register TBPV"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `PSV`"] 4 | pub type PSV_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:15 - GPTM Timer B Prescaler Value"] 7 | #[inline(always)] 8 | pub fn psv(&self) -> PSV_R { 9 | PSV_R::new((self.bits & 0xffff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/can0/nwda1.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register NWDA1"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `NEWDAT`"] 4 | pub type NEWDAT_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:15 - New Data Bits"] 7 | #[inline(always)] 8 | pub fn newdat(&self) -> NEWDAT_R { 9 | NEWDAT_R::new((self.bits & 0xffff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/can0/nwda2.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register NWDA2"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `NEWDAT`"] 4 | pub type NEWDAT_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:15 - New Data Bits"] 7 | #[inline(always)] 8 | pub fn newdat(&self) -> NEWDAT_R { 9 | NEWDAT_R::new((self.bits & 0xffff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/emac0/timsec.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register TIMSEC"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `TSS`"] 4 | pub type TSS_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:31 - Timestamp Second"] 7 | #[inline(always)] 8 | pub fn tss(&self) -> TSS_R { 9 | TSS_R::new((self.bits & 0xffff_ffff) as u32) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/sysctl/ppacmp.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PPACMP"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `P0`"] 4 | pub type P0_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - Analog Comparator Module Present"] 7 | #[inline(always)] 8 | pub fn p0(&self) -> P0_R { 9 | P0_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/sysctl/ppccm.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PPCCM"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `P0`"] 4 | pub type P0_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - CRC and Cryptographic Modules Present"] 7 | #[inline(always)] 8 | pub fn p0(&self) -> P0_R { 9 | P0_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/sysctl/ppemac.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PPEMAC"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `P0`"] 4 | pub type P0_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - Ethernet Controller Module Present"] 7 | #[inline(always)] 8 | pub fn p0(&self) -> P0_R { 9 | P0_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/sysctl/prhib.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PRHIB"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `R0`"] 4 | pub type R0_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - Hibernation Module Peripheral Ready"] 7 | #[inline(always)] 8 | pub fn r0(&self) -> R0_R { 9 | R0_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/timer0/tbps.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register TBPS"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `PSS`"] 4 | pub type PSS_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:15 - GPTM Timer A Prescaler Value"] 7 | #[inline(always)] 8 | pub fn pss(&self) -> PSS_R { 9 | PSS_R::new((self.bits & 0xffff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/usb0/epcris.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EPCRIS"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `PF`"] 4 | pub type PF_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - USB Power Fault Interrupt Status"] 7 | #[inline(always)] 8 | pub fn pf(&self) -> PF_R { 9 | PF_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/adc0/ssfifo0.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register SSFIFO0"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `DATA`"] 4 | pub type DATA_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:11 - Conversion Result Data"] 7 | #[inline(always)] 8 | pub fn data(&self) -> DATA_R { 9 | DATA_R::new((self.bits & 0x0fff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/adc0/ssfifo1.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register SSFIFO1"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `DATA`"] 4 | pub type DATA_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:11 - Conversion Result Data"] 7 | #[inline(always)] 8 | pub fn data(&self) -> DATA_R { 9 | DATA_R::new((self.bits & 0x0fff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/adc0/ssfifo2.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register SSFIFO2"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `DATA`"] 4 | pub type DATA_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:11 - Conversion Result Data"] 7 | #[inline(always)] 8 | pub fn data(&self) -> DATA_R { 9 | DATA_R::new((self.bits & 0x0fff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/adc0/ssfifo3.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register SSFIFO3"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `DATA`"] 4 | pub type DATA_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:11 - Conversion Result Data"] 7 | #[inline(always)] 8 | pub fn data(&self) -> DATA_R { 9 | DATA_R::new((self.bits & 0x0fff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/pwm0/_0_count.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register _0_COUNT"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `COUNT`"] 4 | pub type COUNT_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:15 - Counter Value"] 7 | #[inline(always)] 8 | pub fn count(&self) -> COUNT_R { 9 | COUNT_R::new((self.bits & 0xffff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/pwm0/_1_count.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register _1_COUNT"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `COUNT`"] 4 | pub type COUNT_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:15 - Counter Value"] 7 | #[inline(always)] 8 | pub fn count(&self) -> COUNT_R { 9 | COUNT_R::new((self.bits & 0xffff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/pwm0/_2_count.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register _2_COUNT"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `COUNT`"] 4 | pub type COUNT_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:15 - Counter Value"] 7 | #[inline(always)] 8 | pub fn count(&self) -> COUNT_R { 9 | COUNT_R::new((self.bits & 0xffff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/pwm0/_3_count.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register _3_COUNT"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `COUNT`"] 4 | pub type COUNT_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:15 - Counter Value"] 7 | #[inline(always)] 8 | pub fn count(&self) -> COUNT_R { 9 | COUNT_R::new((self.bits & 0xffff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/sysctl/preeprom.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PREEPROM"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `R0`"] 4 | pub type R0_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - EEPROM Module Peripheral Ready"] 7 | #[inline(always)] 8 | pub fn r0(&self) -> R0_R { 9 | R0_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/timer0/taps.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register TAPS"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `PSS`"] 4 | pub type PSS_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:15 - GPTM Timer A Prescaler Snapshot"] 7 | #[inline(always)] 8 | pub fn pss(&self) -> PSS_R { 9 | PSS_R::new((self.bits & 0xffff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/usb0/drris.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register DRRIS"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `RESUME`"] 4 | pub type RESUME_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - RESUME Interrupt Status"] 7 | #[inline(always)] 8 | pub fn resume(&self) -> RESUME_R { 9 | RESUME_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/wtimer0/taps.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register TAPS"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `PSS`"] 4 | pub type PSS_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:15 - GPTM Timer A Prescaler Snapshot"] 7 | #[inline(always)] 8 | pub fn pss(&self) -> PSS_R { 9 | PSS_R::new((self.bits & 0xffff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/adc0/ssfifo0.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register SSFIFO0"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `DATA`"] 4 | pub type DATA_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:11 - Conversion Result Data"] 7 | #[inline(always)] 8 | pub fn data(&self) -> DATA_R { 9 | DATA_R::new((self.bits & 0x0fff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/adc0/ssfifo1.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register SSFIFO1"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `DATA`"] 4 | pub type DATA_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:11 - Conversion Result Data"] 7 | #[inline(always)] 8 | pub fn data(&self) -> DATA_R { 9 | DATA_R::new((self.bits & 0x0fff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/adc0/ssfifo2.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register SSFIFO2"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `DATA`"] 4 | pub type DATA_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:11 - Conversion Result Data"] 7 | #[inline(always)] 8 | pub fn data(&self) -> DATA_R { 9 | DATA_R::new((self.bits & 0x0fff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/adc0/ssfifo3.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register SSFIFO3"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `DATA`"] 4 | pub type DATA_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:11 - Conversion Result Data"] 7 | #[inline(always)] 8 | pub fn data(&self) -> DATA_R { 9 | DATA_R::new((self.bits & 0x0fff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/epi0/readfifo0.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register READFIFO0"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `DATA`"] 4 | pub type DATA_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:31 - Reads Data"] 7 | #[inline(always)] 8 | pub fn data(&self) -> DATA_R { 9 | DATA_R::new((self.bits & 0xffff_ffff) as u32) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/epi0/readfifo1.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register READFIFO1"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `DATA`"] 4 | pub type DATA_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:31 - Reads Data"] 7 | #[inline(always)] 8 | pub fn data(&self) -> DATA_R { 9 | DATA_R::new((self.bits & 0xffff_ffff) as u32) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/epi0/readfifo2.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register READFIFO2"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `DATA`"] 4 | pub type DATA_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:31 - Reads Data"] 7 | #[inline(always)] 8 | pub fn data(&self) -> DATA_R { 9 | DATA_R::new((self.bits & 0xffff_ffff) as u32) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/epi0/readfifo3.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register READFIFO3"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `DATA`"] 4 | pub type DATA_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:31 - Reads Data"] 7 | #[inline(always)] 8 | pub fn data(&self) -> DATA_R { 9 | DATA_R::new((self.bits & 0xffff_ffff) as u32) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/epi0/readfifo4.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register READFIFO4"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `DATA`"] 4 | pub type DATA_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:31 - Reads Data"] 7 | #[inline(always)] 8 | pub fn data(&self) -> DATA_R { 9 | DATA_R::new((self.bits & 0xffff_ffff) as u32) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/epi0/readfifo5.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register READFIFO5"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `DATA`"] 4 | pub type DATA_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:31 - Reads Data"] 7 | #[inline(always)] 8 | pub fn data(&self) -> DATA_R { 9 | DATA_R::new((self.bits & 0xffff_ffff) as u32) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/epi0/readfifo6.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register READFIFO6"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `DATA`"] 4 | pub type DATA_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:31 - Reads Data"] 7 | #[inline(always)] 8 | pub fn data(&self) -> DATA_R { 9 | DATA_R::new((self.bits & 0xffff_ffff) as u32) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/epi0/readfifo7.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register READFIFO7"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `DATA`"] 4 | pub type DATA_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:31 - Reads Data"] 7 | #[inline(always)] 8 | pub fn data(&self) -> DATA_R { 9 | DATA_R::new((self.bits & 0xffff_ffff) as u32) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/pwm0/_0_count.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register _0_COUNT"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `COUNT`"] 4 | pub type COUNT_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:15 - Counter Value"] 7 | #[inline(always)] 8 | pub fn count(&self) -> COUNT_R { 9 | COUNT_R::new((self.bits & 0xffff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/pwm0/_1_count.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register _1_COUNT"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `COUNT`"] 4 | pub type COUNT_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:15 - Counter Value"] 7 | #[inline(always)] 8 | pub fn count(&self) -> COUNT_R { 9 | COUNT_R::new((self.bits & 0xffff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/pwm0/_2_count.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register _2_COUNT"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `COUNT`"] 4 | pub type COUNT_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:15 - Counter Value"] 7 | #[inline(always)] 8 | pub fn count(&self) -> COUNT_R { 9 | COUNT_R::new((self.bits & 0xffff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/pwm0/_3_count.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register _3_COUNT"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `COUNT`"] 4 | pub type COUNT_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:15 - Counter Value"] 7 | #[inline(always)] 8 | pub fn count(&self) -> COUNT_R { 9 | COUNT_R::new((self.bits & 0xffff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/sysctl/preeprom.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PREEPROM"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `R0`"] 4 | pub type R0_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - EEPROM Module Peripheral Ready"] 7 | #[inline(always)] 8 | pub fn r0(&self) -> R0_R { 9 | R0_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/sysctl/premac.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PREMAC"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `R0`"] 4 | pub type R0_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - Ethernet MAC Module 0 Peripheral Ready"] 7 | #[inline(always)] 8 | pub fn r0(&self) -> R0_R { 9 | R0_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/sysctl/prephy.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PREPHY"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `R0`"] 4 | pub type R0_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - Ethernet PHY Module Peripheral Ready"] 7 | #[inline(always)] 8 | pub fn r0(&self) -> R0_R { 9 | R0_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/timer0/taps.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register TAPS"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `PSS`"] 4 | pub type PSS_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:15 - GPTM Timer A Prescaler Snapshot"] 7 | #[inline(always)] 8 | pub fn pss(&self) -> PSS_R { 9 | PSS_R::new((self.bits & 0xffff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/usb0/drris.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register DRRIS"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `RESUME`"] 4 | pub type RESUME_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - RESUME Interrupt Status"] 7 | #[inline(always)] 8 | pub fn resume(&self) -> RESUME_R { 9 | RESUME_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/comp/acstat0.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register ACSTAT0"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `OVAL`"] 4 | pub type OVAL_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 1 - Comparator Output Value"] 7 | #[inline(always)] 8 | pub fn oval(&self) -> OVAL_R { 9 | OVAL_R::new(((self.bits >> 1) & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/comp/acstat1.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register ACSTAT1"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `OVAL`"] 4 | pub type OVAL_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 1 - Comparator Output Value"] 7 | #[inline(always)] 8 | pub fn oval(&self) -> OVAL_R { 9 | OVAL_R::new(((self.bits >> 1) & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/sysctl/nvmstat.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register NVMSTAT"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `FWB`"] 4 | pub type FWB_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - 32 Word Flash Write Buffer Available"] 7 | #[inline(always)] 8 | pub fn fwb(&self) -> FWB_R { 9 | FWB_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/sysctl/pracmp.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PRACMP"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `R0`"] 4 | pub type R0_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - Analog Comparator Module 0 Peripheral Ready"] 7 | #[inline(always)] 8 | pub fn r0(&self) -> R0_R { 9 | R0_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/watchdog0/ris.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register RIS"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `WDTRIS`"] 4 | pub type WDTRIS_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - Watchdog Raw Interrupt Status"] 7 | #[inline(always)] 8 | pub fn wdtris(&self) -> WDTRIS_R { 9 | WDTRIS_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/comp/acstat0.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register ACSTAT0"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `OVAL`"] 4 | pub type OVAL_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 1 - Comparator Output Value"] 7 | #[inline(always)] 8 | pub fn oval(&self) -> OVAL_R { 9 | OVAL_R::new(((self.bits >> 1) & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/comp/acstat1.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register ACSTAT1"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `OVAL`"] 4 | pub type OVAL_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 1 - Comparator Output Value"] 7 | #[inline(always)] 8 | pub fn oval(&self) -> OVAL_R { 9 | OVAL_R::new(((self.bits >> 1) & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/comp/acstat2.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register ACSTAT2"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `OVAL`"] 4 | pub type OVAL_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 1 - Comparator Output Value"] 7 | #[inline(always)] 8 | pub fn oval(&self) -> OVAL_R { 9 | OVAL_R::new(((self.bits >> 1) & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/emac0/ephyris.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EPHYRIS"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `INT`"] 4 | pub type INT_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - Ethernet PHY Raw Interrupt Status"] 7 | #[inline(always)] 8 | pub fn int(&self) -> INT_R { 9 | INT_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/emac0/timnano.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register TIMNANO"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `TSSS`"] 4 | pub type TSSS_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:30 - Timestamp Sub-Seconds"] 7 | #[inline(always)] 8 | pub fn tsss(&self) -> TSSS_R { 9 | TSSS_R::new((self.bits & 0x7fff_ffff) as u32) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/epi0/wfifocnt.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register WFIFOCNT"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `WTAV`"] 4 | pub type WTAV_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:2 - Available Write Transactions"] 7 | #[inline(always)] 8 | pub fn wtav(&self) -> WTAV_R { 9 | WTAV_R::new((self.bits & 0x07) as u8) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/sysctl/nvmstat.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register NVMSTAT"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `FWB`"] 4 | pub type FWB_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - 32 Word Flash Write Buffer Available"] 7 | #[inline(always)] 8 | pub fn fwb(&self) -> FWB_R { 9 | FWB_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/sysctl/pracmp.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PRACMP"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `R0`"] 4 | pub type R0_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - Analog Comparator Module 0 Peripheral Ready"] 7 | #[inline(always)] 8 | pub fn r0(&self) -> R0_R { 9 | R0_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/sysctl/prccm.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PRCCM"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `R0`"] 4 | pub type R0_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - CRC and Cryptographic Modules Peripheral Ready"] 7 | #[inline(always)] 8 | pub fn r0(&self) -> R0_R { 9 | R0_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/watchdog0/ris.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register RIS"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `WDTRIS`"] 4 | pub type WDTRIS_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - Watchdog Raw Interrupt Status"] 7 | #[inline(always)] 8 | pub fn wdtris(&self) -> WDTRIS_R { 9 | WDTRIS_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/can0/msg1int.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register MSG1INT"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `INTPND`"] 4 | pub type INTPND_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:15 - Interrupt Pending Bits"] 7 | #[inline(always)] 8 | pub fn intpnd(&self) -> INTPND_R { 9 | INTPND_R::new((self.bits & 0xffff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/can0/msg1val.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register MSG1VAL"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `MSGVAL`"] 4 | pub type MSGVAL_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:15 - Message Valid Bits"] 7 | #[inline(always)] 8 | pub fn msgval(&self) -> MSGVAL_R { 9 | MSGVAL_R::new((self.bits & 0xffff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/can0/msg2int.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register MSG2INT"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `INTPND`"] 4 | pub type INTPND_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:15 - Interrupt Pending Bits"] 7 | #[inline(always)] 8 | pub fn intpnd(&self) -> INTPND_R { 9 | INTPND_R::new((self.bits & 0xffff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/can0/msg2val.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register MSG2VAL"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `MSGVAL`"] 4 | pub type MSGVAL_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:15 - Message Valid Bits"] 7 | #[inline(always)] 8 | pub fn msgval(&self) -> MSGVAL_R { 9 | MSGVAL_R::new((self.bits & 0xffff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/can0/txrq1.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register TXRQ1"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `TXRQST`"] 4 | pub type TXRQST_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:15 - Transmission Request Bits"] 7 | #[inline(always)] 8 | pub fn txrqst(&self) -> TXRQST_R { 9 | TXRQST_R::new((self.bits & 0xffff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/can0/txrq2.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register TXRQ2"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `TXRQST`"] 4 | pub type TXRQST_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:15 - Transmission Request Bits"] 7 | #[inline(always)] 8 | pub fn txrqst(&self) -> TXRQST_R { 9 | TXRQST_R::new((self.bits & 0xffff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/timer0/rtcpd.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register RTCPD"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `RTCPD`"] 4 | pub type RTCPD_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:15 - RTC Predivide Counter Value"] 7 | #[inline(always)] 8 | pub fn rtcpd(&self) -> RTCPD_R { 9 | RTCPD_R::new((self.bits & 0xffff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/usb0/rxcount1.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register RXCOUNT1"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `COUNT`"] 4 | pub type COUNT_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:12 - Receive Packet Count"] 7 | #[inline(always)] 8 | pub fn count(&self) -> COUNT_R { 9 | COUNT_R::new((self.bits & 0x1fff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/usb0/rxcount2.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register RXCOUNT2"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `COUNT`"] 4 | pub type COUNT_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:12 - Receive Packet Count"] 7 | #[inline(always)] 8 | pub fn count(&self) -> COUNT_R { 9 | COUNT_R::new((self.bits & 0x1fff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/usb0/rxcount3.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register RXCOUNT3"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `COUNT`"] 4 | pub type COUNT_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:12 - Receive Packet Count"] 7 | #[inline(always)] 8 | pub fn count(&self) -> COUNT_R { 9 | COUNT_R::new((self.bits & 0x1fff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/usb0/rxcount4.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register RXCOUNT4"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `COUNT`"] 4 | pub type COUNT_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:12 - Receive Packet Count"] 7 | #[inline(always)] 8 | pub fn count(&self) -> COUNT_R { 9 | COUNT_R::new((self.bits & 0x1fff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/usb0/rxcount5.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register RXCOUNT5"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `COUNT`"] 4 | pub type COUNT_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:12 - Receive Packet Count"] 7 | #[inline(always)] 8 | pub fn count(&self) -> COUNT_R { 9 | COUNT_R::new((self.bits & 0x1fff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/usb0/rxcount6.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register RXCOUNT6"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `COUNT`"] 4 | pub type COUNT_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:12 - Receive Packet Count"] 7 | #[inline(always)] 8 | pub fn count(&self) -> COUNT_R { 9 | COUNT_R::new((self.bits & 0x1fff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/usb0/rxcount7.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register RXCOUNT7"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `COUNT`"] 4 | pub type COUNT_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:12 - Receive Packet Count"] 7 | #[inline(always)] 8 | pub fn count(&self) -> COUNT_R { 9 | COUNT_R::new((self.bits & 0x1fff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/watchdog0/mis.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register MIS"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `WDTMIS`"] 4 | pub type WDTMIS_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - Watchdog Masked Interrupt Status"] 7 | #[inline(always)] 8 | pub fn wdtmis(&self) -> WDTMIS_R { 9 | WDTMIS_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/wtimer0/rtcpd.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register RTCPD"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `RTCPD`"] 4 | pub type RTCPD_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:15 - RTC Predivide Counter Value"] 7 | #[inline(always)] 8 | pub fn rtcpd(&self) -> RTCPD_R { 9 | RTCPD_R::new((self.bits & 0xffff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/can0/msg1int.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register MSG1INT"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `INTPND`"] 4 | pub type INTPND_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:15 - Interrupt Pending Bits"] 7 | #[inline(always)] 8 | pub fn intpnd(&self) -> INTPND_R { 9 | INTPND_R::new((self.bits & 0xffff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/can0/msg1val.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register MSG1VAL"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `MSGVAL`"] 4 | pub type MSGVAL_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:15 - Message Valid Bits"] 7 | #[inline(always)] 8 | pub fn msgval(&self) -> MSGVAL_R { 9 | MSGVAL_R::new((self.bits & 0xffff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/can0/msg2int.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register MSG2INT"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `INTPND`"] 4 | pub type INTPND_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:15 - Interrupt Pending Bits"] 7 | #[inline(always)] 8 | pub fn intpnd(&self) -> INTPND_R { 9 | INTPND_R::new((self.bits & 0xffff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/can0/msg2val.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register MSG2VAL"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `MSGVAL`"] 4 | pub type MSGVAL_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:15 - Message Valid Bits"] 7 | #[inline(always)] 8 | pub fn msgval(&self) -> MSGVAL_R { 9 | MSGVAL_R::new((self.bits & 0xffff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/can0/txrq1.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register TXRQ1"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `TXRQST`"] 4 | pub type TXRQST_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:15 - Transmission Request Bits"] 7 | #[inline(always)] 8 | pub fn txrqst(&self) -> TXRQST_R { 9 | TXRQST_R::new((self.bits & 0xffff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/can0/txrq2.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register TXRQ2"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `TXRQST`"] 4 | pub type TXRQST_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:15 - Transmission Request Bits"] 7 | #[inline(always)] 8 | pub fn txrqst(&self) -> TXRQST_R { 9 | TXRQST_R::new((self.bits & 0xffff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/hib/tplog0.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register TPLOG0"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `TIME`"] 4 | pub type TIME_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:31 - Tamper Log Calendar Information"] 7 | #[inline(always)] 8 | pub fn time(&self) -> TIME_R { 9 | TIME_R::new((self.bits & 0xffff_ffff) as u32) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/hib/tplog2.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register TPLOG2"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `TIME`"] 4 | pub type TIME_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:31 - Tamper Log Calendar Information"] 7 | #[inline(always)] 8 | pub fn time(&self) -> TIME_R { 9 | TIME_R::new((self.bits & 0xffff_ffff) as u32) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/hib/tplog4.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register TPLOG4"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `TIME`"] 4 | pub type TIME_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:31 - Tamper Log Calendar Information"] 7 | #[inline(always)] 8 | pub fn time(&self) -> TIME_R { 9 | TIME_R::new((self.bits & 0xffff_ffff) as u32) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/hib/tplog6.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register TPLOG6"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `TIME`"] 4 | pub type TIME_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:31 - Tamper Log Calendar Information"] 7 | #[inline(always)] 8 | pub fn time(&self) -> TIME_R { 9 | TIME_R::new((self.bits & 0xffff_ffff) as u32) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/timer0/rtcpd.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register RTCPD"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `RTCPD`"] 4 | pub type RTCPD_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:15 - RTC Predivide Counter Value"] 7 | #[inline(always)] 8 | pub fn rtcpd(&self) -> RTCPD_R { 9 | RTCPD_R::new((self.bits & 0xffff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/usb0/rxcount1.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register RXCOUNT1"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `COUNT`"] 4 | pub type COUNT_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:12 - Receive Packet Count"] 7 | #[inline(always)] 8 | pub fn count(&self) -> COUNT_R { 9 | COUNT_R::new((self.bits & 0x1fff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/usb0/rxcount2.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register RXCOUNT2"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `COUNT`"] 4 | pub type COUNT_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:12 - Receive Packet Count"] 7 | #[inline(always)] 8 | pub fn count(&self) -> COUNT_R { 9 | COUNT_R::new((self.bits & 0x1fff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/usb0/rxcount3.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register RXCOUNT3"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `COUNT`"] 4 | pub type COUNT_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:12 - Receive Packet Count"] 7 | #[inline(always)] 8 | pub fn count(&self) -> COUNT_R { 9 | COUNT_R::new((self.bits & 0x1fff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/usb0/rxcount4.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register RXCOUNT4"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `COUNT`"] 4 | pub type COUNT_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:12 - Receive Packet Count"] 7 | #[inline(always)] 8 | pub fn count(&self) -> COUNT_R { 9 | COUNT_R::new((self.bits & 0x1fff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/usb0/rxcount5.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register RXCOUNT5"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `COUNT`"] 4 | pub type COUNT_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:12 - Receive Packet Count"] 7 | #[inline(always)] 8 | pub fn count(&self) -> COUNT_R { 9 | COUNT_R::new((self.bits & 0x1fff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/usb0/rxcount6.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register RXCOUNT6"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `COUNT`"] 4 | pub type COUNT_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:12 - Receive Packet Count"] 7 | #[inline(always)] 8 | pub fn count(&self) -> COUNT_R { 9 | COUNT_R::new((self.bits & 0x1fff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/usb0/rxcount7.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register RXCOUNT7"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `COUNT`"] 4 | pub type COUNT_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:12 - Receive Packet Count"] 7 | #[inline(always)] 8 | pub fn count(&self) -> COUNT_R { 9 | COUNT_R::new((self.bits & 0x1fff) as u16) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/watchdog0/mis.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register MIS"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `WDTMIS`"] 4 | pub type WDTMIS_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - Watchdog Masked Interrupt Status"] 7 | #[inline(always)] 8 | pub fn wdtmis(&self) -> WDTMIS_R { 9 | WDTMIS_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/sysctl/ppwtimer.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PPWTIMER"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `P0`"] 4 | pub type P0_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - 32/64-Bit Wide General-Purpose Timer 0 Present"] 7 | #[inline(always)] 8 | pub fn p0(&self) -> P0_R { 9 | P0_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/flash_ctrl/romswmap.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register ROMSWMAP"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `SAFERTOS`"] 4 | pub type SAFERTOS_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 0 - SafeRTOS Present"] 7 | #[inline(always)] 8 | pub fn safertos(&self) -> SAFERTOS_R { 9 | SAFERTOS_R::new((self.bits & 0x01) != 0) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/udma/altbase.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register ALTBASE"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `ADDR`"] 4 | pub type ADDR_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:31 - Alternate Channel Address Pointer"] 7 | #[inline(always)] 8 | pub fn addr(&self) -> ADDR_R { 9 | ADDR_R::new((self.bits & 0xffff_ffff) as u32) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/udma/altbase.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register ALTBASE"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `ADDR`"] 4 | pub type ADDR_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:31 - Alternate Channel Address Pointer"] 7 | #[inline(always)] 8 | pub fn addr(&self) -> ADDR_R { 9 | ADDR_R::new((self.bits & 0xffff_ffff) as u32) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/ccm0/crcrsltpp.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register CRCRSLTPP"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `RSLTPP`"] 4 | pub type RSLTPP_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:31 - Post Processing Result"] 7 | #[inline(always)] 8 | pub fn rsltpp(&self) -> RSLTPP_R { 9 | RSLTPP_R::new((self.bits & 0xffff_ffff) as u32) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/gpio_porta_ahb/wakestat.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register WAKESTAT"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `STAT4`"] 4 | pub type STAT4_R = crate::R; 5 | impl R { 6 | #[doc = "Bit 4 - P\\[4\\] 7 | Wake Status"] 8 | #[inline(always)] 9 | pub fn stat4(&self) -> STAT4_R { 10 | STAT4_R::new(((self.bits >> 4) & 0x01) != 0) 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/udma/waitstat.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register WAITSTAT"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `WAITREQ`"] 4 | pub type WAITREQ_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:31 - Channel \\[n\\] 7 | Wait Status"] 8 | #[inline(always)] 9 | pub fn waitreq(&self) -> WAITREQ_R { 10 | WAITREQ_R::new((self.bits & 0xffff_ffff) as u32) 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/udma/waitstat.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register WAITSTAT"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `WAITREQ`"] 4 | pub type WAITREQ_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:31 - Channel \\[n\\] 7 | Wait Status"] 8 | #[inline(always)] 9 | pub fn waitreq(&self) -> WAITREQ_R { 10 | WAITREQ_R::new((self.bits & 0xffff_ffff) as u32) 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/gpio_porta/cr.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register CR"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register CR"] 4 | pub type W = crate::W; 5 | #[doc = "Register CR `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::CR { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/gpio_porta/is.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register IS"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register IS"] 4 | pub type W = crate::W; 5 | #[doc = "Register IS `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::IS { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/qei0/pos.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register POS"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register POS"] 4 | pub type W = crate::W; 5 | #[doc = "Register POS `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::POS { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/qei0/pos.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register POS"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register POS"] 4 | pub type W = crate::W; 5 | #[doc = "Register POS `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::POS { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/timer0/tav.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register TAV"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register TAV"] 4 | pub type W = crate::W; 5 | #[doc = "Register TAV `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::TAV { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/timer0/tbv.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register TBV"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register TBV"] 4 | pub type W = crate::W; 5 | #[doc = "Register TBV `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::TBV { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/wtimer0/tav.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register TAV"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register TAV"] 4 | pub type W = crate::W; 5 | #[doc = "Register TAV `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::TAV { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/wtimer0/tbv.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register TBV"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register TBV"] 4 | pub type W = crate::W; 5 | #[doc = "Register TBV `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::TBV { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/emac0/hosrxba.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register HOSRXBA"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `CURRXBUFA`"] 4 | pub type CURRXBUFA_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:31 - Host Receive Buffer Address Pointer"] 7 | #[inline(always)] 8 | pub fn currxbufa(&self) -> CURRXBUFA_R { 9 | CURRXBUFA_R::new((self.bits & 0xffff_ffff) as u32) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/emac0/hostxba.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register HOSTXBA"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `CURTXBUFA`"] 4 | pub type CURTXBUFA_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:31 - Host Transmit Buffer Address Pointer"] 7 | #[inline(always)] 8 | pub fn curtxbufa(&self) -> CURTXBUFA_R { 9 | CURTXBUFA_R::new((self.bits & 0xffff_ffff) as u32) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/gpio_porta_ahb/cr.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register CR"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register CR"] 4 | pub type W = crate::W; 5 | #[doc = "Register CR `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::CR { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/gpio_porta_ahb/is.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register IS"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register IS"] 4 | pub type W = crate::W; 5 | #[doc = "Register IS `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::IS { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/timer0/tav.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register TAV"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register TAV"] 4 | pub type W = crate::W; 5 | #[doc = "Register TAV `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::TAV { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/timer0/tbv.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register TBV"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register TBV"] 4 | pub type W = crate::W; 5 | #[doc = "Register TBV `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::TBV { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/gpio_porta/den.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register DEN"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register DEN"] 4 | pub type W = crate::W; 5 | #[doc = "Register DEN `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::DEN { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/gpio_porta/dir.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register DIR"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register DIR"] 4 | pub type W = crate::W; 5 | #[doc = "Register DIR `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::DIR { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/gpio_porta/ibe.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register IBE"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register IBE"] 4 | pub type W = crate::W; 5 | #[doc = "Register IBE `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::IBE { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/gpio_porta/iev.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register IEV"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register IEV"] 4 | pub type W = crate::W; 5 | #[doc = "Register IEV `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::IEV { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/gpio_porta/odr.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register ODR"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register ODR"] 4 | pub type W = crate::W; 5 | #[doc = "Register ODR `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::ODR { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/gpio_porta/pdr.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PDR"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register PDR"] 4 | pub type W = crate::W; 5 | #[doc = "Register PDR `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::PDR { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/gpio_porta/pur.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PUR"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register PUR"] 4 | pub type W = crate::W; 5 | #[doc = "Register PUR `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::PUR { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/gpio_porta/slr.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register SLR"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register SLR"] 4 | pub type W = crate::W; 5 | #[doc = "Register SLR `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::SLR { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/qei0/load.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register LOAD"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register LOAD"] 4 | pub type W = crate::W; 5 | #[doc = "Register LOAD `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::LOAD { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/udma/chis.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register CHIS"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register CHIS"] 4 | pub type W = crate::W; 5 | #[doc = "Register CHIS `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::CHIS { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/gpio_porta_ahb/ibe.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register IBE"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register IBE"] 4 | pub type W = crate::W; 5 | #[doc = "Register IBE `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::IBE { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/gpio_porta_ahb/iev.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register IEV"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register IEV"] 4 | pub type W = crate::W; 5 | #[doc = "Register IEV `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::IEV { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/qei0/load.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register LOAD"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register LOAD"] 4 | pub type W = crate::W; 5 | #[doc = "Register LOAD `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::LOAD { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/gpio_porta/data.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register DATA"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register DATA"] 4 | pub type W = crate::W; 5 | #[doc = "Register DATA `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::DATA { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/gpio_porta/dr2r.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register DR2R"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register DR2R"] 4 | pub type W = crate::W; 5 | #[doc = "Register DR2R `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::DR2R { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/gpio_porta/dr4r.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register DR4R"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register DR4R"] 4 | pub type W = crate::W; 5 | #[doc = "Register DR4R `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::DR4R { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/gpio_porta/dr8r.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register DR8R"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register DR8R"] 4 | pub type W = crate::W; 5 | #[doc = "Register DR8R `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::DR8R { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/gpio_porta/pctl.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PCTL"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register PCTL"] 4 | pub type W = crate::W; 5 | #[doc = "Register PCTL `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::PCTL { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/hib/rtcld.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register RTCLD"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register RTCLD"] 4 | pub type W = crate::W; 5 | #[doc = "Register RTCLD `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::RTCLD { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/hib/rtcm0.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register RTCM0"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register RTCM0"] 4 | pub type W = crate::W; 5 | #[doc = "Register RTCM0 `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::RTCM0 { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/watchdog0/load.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register LOAD"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register LOAD"] 4 | pub type W = crate::W; 5 | #[doc = "Register LOAD `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::LOAD { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/emac0/hosrxdesc.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register HOSRXDESC"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `CURRXDESC`"] 4 | pub type CURRXDESC_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:31 - Host Receive Descriptor Address Pointer"] 7 | #[inline(always)] 8 | pub fn currxdesc(&self) -> CURRXDESC_R { 9 | CURRXDESC_R::new((self.bits & 0xffff_ffff) as u32) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/emac0/hostxdesc.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register HOSTXDESC"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `CURTXDESC`"] 4 | pub type CURTXDESC_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:31 - Host Transmit Descriptor Address Pointer"] 7 | #[inline(always)] 8 | pub fn curtxdesc(&self) -> CURTXDESC_R { 9 | CURTXDESC_R::new((self.bits & 0xffff_ffff) as u32) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/hib/rtcld.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register RTCLD"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register RTCLD"] 4 | pub type W = crate::W; 5 | #[doc = "Register RTCLD `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::RTCLD { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/hib/rtcm0.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register RTCM0"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register RTCM0"] 4 | pub type W = crate::W; 5 | #[doc = "Register RTCM0 `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::RTCM0 { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/watchdog0/load.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register LOAD"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register LOAD"] 4 | pub type W = crate::W; 5 | #[doc = "Register LOAD `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::LOAD { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/gpio_porta/afsel.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register AFSEL"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register AFSEL"] 4 | pub type W = crate::W; 5 | #[doc = "Register AFSEL `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::AFSEL { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/gpio_porta/amsel.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register AMSEL"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register AMSEL"] 4 | pub type W = crate::W; 5 | #[doc = "Register AMSEL `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::AMSEL { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/timer0/tailr.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register TAILR"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register TAILR"] 4 | pub type W = crate::W; 5 | #[doc = "Register TAILR `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::TAILR { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/timer0/tbilr.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register TBILR"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register TBILR"] 4 | pub type W = crate::W; 5 | #[doc = "Register TBILR `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::TBILR { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/wtimer0/tailr.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register TAILR"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register TAILR"] 4 | pub type W = crate::W; 5 | #[doc = "Register TAILR `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::TAILR { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/wtimer0/tbilr.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register TBILR"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register TBILR"] 4 | pub type W = crate::W; 5 | #[doc = "Register TBILR `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::TBILR { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/timer0/tailr.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register TAILR"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register TAILR"] 4 | pub type W = crate::W; 5 | #[doc = "Register TAILR `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::TAILR { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/timer0/tbilr.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register TBILR"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register TBILR"] 4 | pub type W = crate::W; 5 | #[doc = "Register TBILR `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::TBILR { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/qei0/maxpos.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register MAXPOS"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register MAXPOS"] 4 | pub type W = crate::W; 5 | #[doc = "Register MAXPOS `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::MAXPOS { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/emac0/rxcntgb.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register RXCNTGB"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `RXFRMGB`"] 4 | pub type RXFRMGB_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:31 - This field indicates the number of received good and bad frames"] 7 | #[inline(always)] 8 | pub fn rxfrmgb(&self) -> RXFRMGB_R { 9 | RXFRMGB_R::new((self.bits & 0xffff_ffff) as u32) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/qei0/maxpos.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register MAXPOS"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register MAXPOS"] 4 | pub type W = crate::W; 5 | #[doc = "Register MAXPOS `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::MAXPOS { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/flash_ctrl/fmppe0.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register FMPPE0"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register FMPPE0"] 4 | pub type W = crate::W; 5 | #[doc = "Register FMPPE0 `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::FMPPE0 { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/flash_ctrl/fmppe1.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register FMPPE1"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register FMPPE1"] 4 | pub type W = crate::W; 5 | #[doc = "Register FMPPE1 `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::FMPPE1 { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/flash_ctrl/fmppe2.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register FMPPE2"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register FMPPE2"] 4 | pub type W = crate::W; 5 | #[doc = "Register FMPPE2 `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::FMPPE2 { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/flash_ctrl/fmppe3.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register FMPPE3"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register FMPPE3"] 4 | pub type W = crate::W; 5 | #[doc = "Register FMPPE3 `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::FMPPE3 { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/flash_ctrl/fmpre0.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register FMPRE0"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register FMPRE0"] 4 | pub type W = crate::W; 5 | #[doc = "Register FMPRE0 `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::FMPRE0 { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/flash_ctrl/fmpre1.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register FMPRE1"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register FMPRE1"] 4 | pub type W = crate::W; 5 | #[doc = "Register FMPRE1 `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::FMPRE1 { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/flash_ctrl/fmpre2.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register FMPRE2"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register FMPRE2"] 4 | pub type W = crate::W; 5 | #[doc = "Register FMPRE2 `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::FMPRE2 { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/flash_ctrl/fmpre3.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register FMPRE3"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register FMPRE3"] 4 | pub type W = crate::W; 5 | #[doc = "Register FMPRE3 `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::FMPRE3 { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/gpio_porta/adcctl.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register ADCCTL"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register ADCCTL"] 4 | pub type W = crate::W; 5 | #[doc = "Register ADCCTL `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::ADCCTL { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/gpio_porta/dmactl.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register DMACTL"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register DMACTL"] 4 | pub type W = crate::W; 5 | #[doc = "Register DMACTL `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::DMACTL { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/flash_ctrl/fmppe0.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register FMPPE0"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register FMPPE0"] 4 | pub type W = crate::W; 5 | #[doc = "Register FMPPE0 `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::FMPPE0 { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/flash_ctrl/fmppe1.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register FMPPE1"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register FMPPE1"] 4 | pub type W = crate::W; 5 | #[doc = "Register FMPPE1 `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::FMPPE1 { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/flash_ctrl/fmppe2.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register FMPPE2"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register FMPPE2"] 4 | pub type W = crate::W; 5 | #[doc = "Register FMPPE2 `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::FMPPE2 { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/flash_ctrl/fmppe3.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register FMPPE3"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register FMPPE3"] 4 | pub type W = crate::W; 5 | #[doc = "Register FMPPE3 `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::FMPPE3 { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/flash_ctrl/fmppe4.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register FMPPE4"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register FMPPE4"] 4 | pub type W = crate::W; 5 | #[doc = "Register FMPPE4 `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::FMPPE4 { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/flash_ctrl/fmppe5.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register FMPPE5"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register FMPPE5"] 4 | pub type W = crate::W; 5 | #[doc = "Register FMPPE5 `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::FMPPE5 { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/flash_ctrl/fmppe6.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register FMPPE6"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register FMPPE6"] 4 | pub type W = crate::W; 5 | #[doc = "Register FMPPE6 `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::FMPPE6 { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/flash_ctrl/fmppe7.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register FMPPE7"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register FMPPE7"] 4 | pub type W = crate::W; 5 | #[doc = "Register FMPPE7 `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::FMPPE7 { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/flash_ctrl/fmpre0.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register FMPRE0"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register FMPRE0"] 4 | pub type W = crate::W; 5 | #[doc = "Register FMPRE0 `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::FMPRE0 { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/flash_ctrl/fmpre1.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register FMPRE1"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register FMPRE1"] 4 | pub type W = crate::W; 5 | #[doc = "Register FMPRE1 `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::FMPRE1 { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/flash_ctrl/fmpre2.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register FMPRE2"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register FMPRE2"] 4 | pub type W = crate::W; 5 | #[doc = "Register FMPRE2 `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::FMPRE2 { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/flash_ctrl/fmpre3.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register FMPRE3"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register FMPRE3"] 4 | pub type W = crate::W; 5 | #[doc = "Register FMPRE3 `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::FMPRE3 { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/flash_ctrl/fmpre4.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register FMPRE4"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register FMPRE4"] 4 | pub type W = crate::W; 5 | #[doc = "Register FMPRE4 `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::FMPRE4 { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/flash_ctrl/fmpre5.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register FMPRE5"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register FMPRE5"] 4 | pub type W = crate::W; 5 | #[doc = "Register FMPRE5 `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::FMPRE5 { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/flash_ctrl/fmpre6.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register FMPRE6"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register FMPRE6"] 4 | pub type W = crate::W; 5 | #[doc = "Register FMPRE6 `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::FMPRE6 { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/flash_ctrl/fmpre7.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register FMPRE7"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register FMPRE7"] 4 | pub type W = crate::W; 5 | #[doc = "Register FMPRE7 `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::FMPRE7 { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/emac0/rxcntguni.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register RXCNTGUNI"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `RXUCASTG`"] 4 | pub type RXUCASTG_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:31 - This field indicates the number of received good unicast frames"] 7 | #[inline(always)] 8 | pub fn rxucastg(&self) -> RXUCASTG_R { 9 | RXUCASTG_R::new((self.bits & 0xffff_ffff) as u32) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/emac0/pps0width.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PPS0WIDTH"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register PPS0WIDTH"] 4 | pub type W = crate::W; 5 | #[doc = "Register PPS0WIDTH `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::PPS0WIDTH { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/emac0/rxcntcrcerr.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register RXCNTCRCERR"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `RXCRCERR`"] 4 | pub type RXCRCERR_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:31 - This field indicates the number of frames received with CRC error"] 7 | #[inline(always)] 8 | pub fn rxcrcerr(&self) -> RXCRCERR_R { 9 | RXCRCERR_R::new((self.bits & 0xffff_ffff) as u32) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/emac0/txcntgb.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register TXCNTGB"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `TXFRMGB`"] 4 | pub type TXFRMGB_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:31 - This field indicates the number of good and bad frames transmitted, exclusive of retried frames"] 7 | #[inline(always)] 8 | pub fn txfrmgb(&self) -> TXFRMGB_R { 9 | TXFRMGB_R::new((self.bits & 0xffff_ffff) as u32) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/emac0/txoctcntg.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register TXOCTCNTG"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `TXOCTG`"] 4 | pub type TXOCTG_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:31 - This field indicates the number of bytes transmitted, exclusive of preamble, in good frames"] 7 | #[inline(always)] 8 | pub fn txoctg(&self) -> TXOCTG_R { 9 | TXOCTG_R::new((self.bits & 0xffff_ffff) as u32) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/usb0/rqpktcount1.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register RQPKTCOUNT1"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register RQPKTCOUNT1"] 4 | pub type W = crate::W; 5 | #[doc = "Register RQPKTCOUNT1 `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::RQPKTCOUNT1 { 7 | type Type = u16; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/usb0/rqpktcount2.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register RQPKTCOUNT2"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register RQPKTCOUNT2"] 4 | pub type W = crate::W; 5 | #[doc = "Register RQPKTCOUNT2 `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::RQPKTCOUNT2 { 7 | type Type = u16; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/usb0/rqpktcount3.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register RQPKTCOUNT3"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register RQPKTCOUNT3"] 4 | pub type W = crate::W; 5 | #[doc = "Register RQPKTCOUNT3 `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::RQPKTCOUNT3 { 7 | type Type = u16; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/usb0/rqpktcount1.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register RQPKTCOUNT1"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register RQPKTCOUNT1"] 4 | pub type W = crate::W; 5 | #[doc = "Register RQPKTCOUNT1 `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::RQPKTCOUNT1 { 7 | type Type = u16; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/usb0/rqpktcount2.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register RQPKTCOUNT2"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register RQPKTCOUNT2"] 4 | pub type W = crate::W; 5 | #[doc = "Register RQPKTCOUNT2 `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::RQPKTCOUNT2 { 7 | type Type = u16; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/usb0/rqpktcount3.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register RQPKTCOUNT3"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register RQPKTCOUNT3"] 4 | pub type W = crate::W; 5 | #[doc = "Register RQPKTCOUNT3 `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::RQPKTCOUNT3 { 7 | type Type = u16; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | impl R {} 14 | impl W {} 15 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/emac0/rxcntalgnerr.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register RXCNTALGNERR"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `RXALGNERR`"] 4 | pub type RXALGNERR_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:31 - This field indicates the number of frames received with alignment (dribble) error"] 7 | #[inline(always)] 8 | pub fn rxalgnerr(&self) -> RXALGNERR_R { 9 | RXALGNERR_R::new((self.bits & 0xffff_ffff) as u32) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/emac0/txcntscol.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register TXCNTSCOL"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `TXSNGLCOLG`"] 4 | pub type TXSNGLCOLG_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:31 - This field indicates the number of successfully transmitted frames after a single collision in the half-duplex mode"] 7 | #[inline(always)] 8 | pub fn txsnglcolg(&self) -> TXSNGLCOLG_R { 9 | TXSNGLCOLG_R::new((self.bits & 0xffff_ffff) as u32) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/emac0/txcntmcol.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register TXCNTMCOL"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `TXMULTCOLG`"] 4 | pub type TXMULTCOLG_R = crate::R; 5 | impl R { 6 | #[doc = "Bits 0:31 - This field indicates the number of successfully transmitted frames after multiple collisions in the half-duplex mode"] 7 | #[inline(always)] 8 | pub fn txmultcolg(&self) -> TXMULTCOLG_R { 9 | TXMULTCOLG_R::new((self.bits & 0xffff_ffff) as u32) 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /crates/tm4c123x/build.rs: -------------------------------------------------------------------------------- 1 | use std::env; 2 | use std::fs::File; 3 | use std::io::Write; 4 | use std::path::PathBuf; 5 | fn main() { 6 | if env::var_os("CARGO_FEATURE_RT").is_some() { 7 | let out = &PathBuf::from(env::var_os("OUT_DIR").unwrap()); 8 | File::create(out.join("device.x")).unwrap().write_all(include_bytes!("device.x")).unwrap(); 9 | println!("cargo:rustc-link-search={}", out.display()); 10 | println!("cargo:rerun-if-changed=device.x"); 11 | } 12 | println!("cargo:rerun-if-changed=build.rs"); 13 | } 14 | -------------------------------------------------------------------------------- /crates/tm4c129x/build.rs: -------------------------------------------------------------------------------- 1 | use std::env; 2 | use std::fs::File; 3 | use std::io::Write; 4 | use std::path::PathBuf; 5 | fn main() { 6 | if env::var_os("CARGO_FEATURE_RT").is_some() { 7 | let out = &PathBuf::from(env::var_os("OUT_DIR").unwrap()); 8 | File::create(out.join("device.x")).unwrap().write_all(include_bytes!("device.x")).unwrap(); 9 | println!("cargo:rustc-link-search={}", out.display()); 10 | println!("cargo:rerun-if-changed=device.x"); 11 | } 12 | println!("cargo:rerun-if-changed=build.rs"); 13 | } 14 | -------------------------------------------------------------------------------- /crates/tm4c123x/README.md: -------------------------------------------------------------------------------- 1 | tm4c123x 2 | ======== 3 | 4 | [Documentation](https://docs.rs/tm4c123x) 5 | 6 | _tm4c123x_ provides peripheral access API for Texas Instruments TM4C123x 7 | microcontroller series. 8 | 9 | The register definitions are extracted from the DSLite supplied with the TM4C 10 | module of the Energia IDE, converted to SVD using [ti2svd][], generated 11 | as Rust code using [svd2rust][]. 12 | 13 | [ti2svd]: https://github.com/m-labs/ti2svd 14 | [svd2rust]: https://github.com/whitequark/svd2rust 15 | 16 | License 17 | ------- 18 | 19 | [0-clause BSD license](LICENSE-0BSD.txt). 20 | -------------------------------------------------------------------------------- /crates/tm4c129x/README.md: -------------------------------------------------------------------------------- 1 | tm4c129x 2 | ======== 3 | 4 | [Documentation](https://docs.rs/tm4c129x) 5 | 6 | _tm4c129x_ provides peripheral access API for Texas Instruments TM4C129x 7 | microcontroller series. 8 | 9 | The register definitions are extracted from the DSLite supplied with the TM4C 10 | module of the Energia IDE, converted to SVD using [ti2svd][], and generated 11 | as Rust code using [svd2rust][]. 12 | 13 | [ti2svd]: https://github.com/m-labs/ti2svd 14 | [svd2rust]: https://github.com/whitequark/svd2rust 15 | 16 | License 17 | ------- 18 | 19 | [0-clause BSD license](LICENSE-0BSD.txt). 20 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/uart0/pp.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PP"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `SC`"] 4 | pub type SC_R = crate::R; 5 | #[doc = "Reader of field `NB`"] 6 | pub type NB_R = crate::R; 7 | impl R { 8 | #[doc = "Bit 0 - Smart Card Support"] 9 | #[inline(always)] 10 | pub fn sc(&self) -> SC_R { 11 | SC_R::new((self.bits & 0x01) != 0) 12 | } 13 | #[doc = "Bit 1 - 9-Bit Support"] 14 | #[inline(always)] 15 | pub fn nb(&self) -> NB_R { 16 | NB_R::new(((self.bits >> 1) & 0x01) != 0) 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /crates/tm4c123x/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "tm4c123x" 3 | version = "0.9.1" 4 | authors = ["whitequark "] 5 | description = "Peripheral access API for TI TM4C123x microcontrollers" 6 | documentation = "https://docs.rs/tm4c123x" 7 | repository = "https://github.com/m-labs/dslite2svd" 8 | keywords = ["arm", "cortex-m", "tm4c", "tiva-c"] 9 | categories = ["embedded"] 10 | license = "0BSD" 11 | 12 | [dependencies] 13 | cortex-m = "0.7.6" 14 | vcell = "0.1.0" 15 | 16 | [dependencies.cortex-m-rt] 17 | optional = true 18 | version = "0.7.2" 19 | 20 | [features] 21 | rt = ["cortex-m-rt/device"] 22 | -------------------------------------------------------------------------------- /crates/tm4c129x/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "tm4c129x" 3 | version = "0.9.1" 4 | authors = ["whitequark "] 5 | description = "Peripheral access API for TI TM4C129x microcontrollers" 6 | documentation = "https://docs.rs/tm4c129x" 7 | repository = "https://github.com/m-labs/dslite2svd" 8 | keywords = ["arm", "cortex-m", "tm4c", "tiva-c"] 9 | categories = ["embedded"] 10 | license = "0BSD" 11 | 12 | [dependencies] 13 | cortex-m = "0.7.6" 14 | vcell = "0.1.0" 15 | 16 | [dependencies.cortex-m-rt] 17 | optional = true 18 | version = "0.7.2" 19 | 20 | [features] 21 | rt = ["cortex-m-rt/device"] 22 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/i2c0/mbmon.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register MBMON"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `SCL`"] 4 | pub type SCL_R = crate::R; 5 | #[doc = "Reader of field `SDA`"] 6 | pub type SDA_R = crate::R; 7 | impl R { 8 | #[doc = "Bit 0 - I2C SCL Status"] 9 | #[inline(always)] 10 | pub fn scl(&self) -> SCL_R { 11 | SCL_R::new((self.bits & 0x01) != 0) 12 | } 13 | #[doc = "Bit 1 - I2C SDA Status"] 14 | #[inline(always)] 15 | pub fn sda(&self) -> SDA_R { 16 | SDA_R::new(((self.bits >> 1) & 0x01) != 0) 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/i2c0/mbmon.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register MBMON"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `SCL`"] 4 | pub type SCL_R = crate::R; 5 | #[doc = "Reader of field `SDA`"] 6 | pub type SDA_R = crate::R; 7 | impl R { 8 | #[doc = "Bit 0 - I2C SCL Status"] 9 | #[inline(always)] 10 | pub fn scl(&self) -> SCL_R { 11 | SCL_R::new((self.bits & 0x01) != 0) 12 | } 13 | #[doc = "Bit 1 - I2C SDA Status"] 14 | #[inline(always)] 15 | pub fn sda(&self) -> SDA_R { 16 | SDA_R::new(((self.bits >> 1) & 0x01) != 0) 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/sysctl/ppadc.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PPADC"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `P0`"] 4 | pub type P0_R = crate::R; 5 | #[doc = "Reader of field `P1`"] 6 | pub type P1_R = crate::R; 7 | impl R { 8 | #[doc = "Bit 0 - ADC Module 0 Present"] 9 | #[inline(always)] 10 | pub fn p0(&self) -> P0_R { 11 | P0_R::new((self.bits & 0x01) != 0) 12 | } 13 | #[doc = "Bit 1 - ADC Module 1 Present"] 14 | #[inline(always)] 15 | pub fn p1(&self) -> P1_R { 16 | P1_R::new(((self.bits >> 1) & 0x01) != 0) 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/sysctl/ppcan.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PPCAN"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `P0`"] 4 | pub type P0_R = crate::R; 5 | #[doc = "Reader of field `P1`"] 6 | pub type P1_R = crate::R; 7 | impl R { 8 | #[doc = "Bit 0 - CAN Module 0 Present"] 9 | #[inline(always)] 10 | pub fn p0(&self) -> P0_R { 11 | P0_R::new((self.bits & 0x01) != 0) 12 | } 13 | #[doc = "Bit 1 - CAN Module 1 Present"] 14 | #[inline(always)] 15 | pub fn p1(&self) -> P1_R { 16 | P1_R::new(((self.bits >> 1) & 0x01) != 0) 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/sysctl/pppwm.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PPPWM"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `P0`"] 4 | pub type P0_R = crate::R; 5 | #[doc = "Reader of field `P1`"] 6 | pub type P1_R = crate::R; 7 | impl R { 8 | #[doc = "Bit 0 - PWM Module 0 Present"] 9 | #[inline(always)] 10 | pub fn p0(&self) -> P0_R { 11 | P0_R::new((self.bits & 0x01) != 0) 12 | } 13 | #[doc = "Bit 1 - PWM Module 1 Present"] 14 | #[inline(always)] 15 | pub fn p1(&self) -> P1_R { 16 | P1_R::new(((self.bits >> 1) & 0x01) != 0) 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/sysctl/ppqei.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PPQEI"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `P0`"] 4 | pub type P0_R = crate::R; 5 | #[doc = "Reader of field `P1`"] 6 | pub type P1_R = crate::R; 7 | impl R { 8 | #[doc = "Bit 0 - QEI Module 0 Present"] 9 | #[inline(always)] 10 | pub fn p0(&self) -> P0_R { 11 | P0_R::new((self.bits & 0x01) != 0) 12 | } 13 | #[doc = "Bit 1 - QEI Module 1 Present"] 14 | #[inline(always)] 15 | pub fn p1(&self) -> P1_R { 16 | P1_R::new(((self.bits >> 1) & 0x01) != 0) 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/sysctl/ppadc.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PPADC"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `P0`"] 4 | pub type P0_R = crate::R; 5 | #[doc = "Reader of field `P1`"] 6 | pub type P1_R = crate::R; 7 | impl R { 8 | #[doc = "Bit 0 - ADC Module 0 Present"] 9 | #[inline(always)] 10 | pub fn p0(&self) -> P0_R { 11 | P0_R::new((self.bits & 0x01) != 0) 12 | } 13 | #[doc = "Bit 1 - ADC Module 1 Present"] 14 | #[inline(always)] 15 | pub fn p1(&self) -> P1_R { 16 | P1_R::new(((self.bits >> 1) & 0x01) != 0) 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/sysctl/ppcan.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PPCAN"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `P0`"] 4 | pub type P0_R = crate::R; 5 | #[doc = "Reader of field `P1`"] 6 | pub type P1_R = crate::R; 7 | impl R { 8 | #[doc = "Bit 0 - CAN Module 0 Present"] 9 | #[inline(always)] 10 | pub fn p0(&self) -> P0_R { 11 | P0_R::new((self.bits & 0x01) != 0) 12 | } 13 | #[doc = "Bit 1 - CAN Module 1 Present"] 14 | #[inline(always)] 15 | pub fn p1(&self) -> P1_R { 16 | P1_R::new(((self.bits >> 1) & 0x01) != 0) 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/usb0/epinfo.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EPINFO"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `TXEP`"] 4 | pub type TXEP_R = crate::R; 5 | #[doc = "Reader of field `RXEP`"] 6 | pub type RXEP_R = crate::R; 7 | impl R { 8 | #[doc = "Bits 0:3 - TX Endpoints"] 9 | #[inline(always)] 10 | pub fn txep(&self) -> TXEP_R { 11 | TXEP_R::new((self.bits & 0x0f) as u8) 12 | } 13 | #[doc = "Bits 4:7 - RX Endpoints"] 14 | #[inline(always)] 15 | pub fn rxep(&self) -> RXEP_R { 16 | RXEP_R::new(((self.bits >> 4) & 0x0f) as u8) 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/sysctl/ppwd.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PPWD"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `P0`"] 4 | pub type P0_R = crate::R; 5 | #[doc = "Reader of field `P1`"] 6 | pub type P1_R = crate::R; 7 | impl R { 8 | #[doc = "Bit 0 - Watchdog Timer 0 Present"] 9 | #[inline(always)] 10 | pub fn p0(&self) -> P0_R { 11 | P0_R::new((self.bits & 0x01) != 0) 12 | } 13 | #[doc = "Bit 1 - Watchdog Timer 1 Present"] 14 | #[inline(always)] 15 | pub fn p1(&self) -> P1_R { 16 | P1_R::new(((self.bits >> 1) & 0x01) != 0) 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/sysctl/ppwd.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PPWD"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `P0`"] 4 | pub type P0_R = crate::R; 5 | #[doc = "Reader of field `P1`"] 6 | pub type P1_R = crate::R; 7 | impl R { 8 | #[doc = "Bit 0 - Watchdog Timer 0 Present"] 9 | #[inline(always)] 10 | pub fn p0(&self) -> P0_R { 11 | P0_R::new((self.bits & 0x01) != 0) 12 | } 13 | #[doc = "Bit 1 - Watchdog Timer 1 Present"] 14 | #[inline(always)] 15 | pub fn p1(&self) -> P1_R { 16 | P1_R::new(((self.bits >> 1) & 0x01) != 0) 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/sysctl/pradc.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PRADC"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `R0`"] 4 | pub type R0_R = crate::R; 5 | #[doc = "Reader of field `R1`"] 6 | pub type R1_R = crate::R; 7 | impl R { 8 | #[doc = "Bit 0 - ADC Module 0 Peripheral Ready"] 9 | #[inline(always)] 10 | pub fn r0(&self) -> R0_R { 11 | R0_R::new((self.bits & 0x01) != 0) 12 | } 13 | #[doc = "Bit 1 - ADC Module 1 Peripheral Ready"] 14 | #[inline(always)] 15 | pub fn r1(&self) -> R1_R { 16 | R1_R::new(((self.bits >> 1) & 0x01) != 0) 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/sysctl/prcan.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PRCAN"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `R0`"] 4 | pub type R0_R = crate::R; 5 | #[doc = "Reader of field `R1`"] 6 | pub type R1_R = crate::R; 7 | impl R { 8 | #[doc = "Bit 0 - CAN Module 0 Peripheral Ready"] 9 | #[inline(always)] 10 | pub fn r0(&self) -> R0_R { 11 | R0_R::new((self.bits & 0x01) != 0) 12 | } 13 | #[doc = "Bit 1 - CAN Module 1 Peripheral Ready"] 14 | #[inline(always)] 15 | pub fn r1(&self) -> R1_R { 16 | R1_R::new(((self.bits >> 1) & 0x01) != 0) 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/sysctl/prpwm.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PRPWM"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `R0`"] 4 | pub type R0_R = crate::R; 5 | #[doc = "Reader of field `R1`"] 6 | pub type R1_R = crate::R; 7 | impl R { 8 | #[doc = "Bit 0 - PWM Module 0 Peripheral Ready"] 9 | #[inline(always)] 10 | pub fn r0(&self) -> R0_R { 11 | R0_R::new((self.bits & 0x01) != 0) 12 | } 13 | #[doc = "Bit 1 - PWM Module 1 Peripheral Ready"] 14 | #[inline(always)] 15 | pub fn r1(&self) -> R1_R { 16 | R1_R::new(((self.bits >> 1) & 0x01) != 0) 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/sysctl/prqei.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PRQEI"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `R0`"] 4 | pub type R0_R = crate::R; 5 | #[doc = "Reader of field `R1`"] 6 | pub type R1_R = crate::R; 7 | impl R { 8 | #[doc = "Bit 0 - QEI Module 0 Peripheral Ready"] 9 | #[inline(always)] 10 | pub fn r0(&self) -> R0_R { 11 | R0_R::new((self.bits & 0x01) != 0) 12 | } 13 | #[doc = "Bit 1 - QEI Module 1 Peripheral Ready"] 14 | #[inline(always)] 15 | pub fn r1(&self) -> R1_R { 16 | R1_R::new(((self.bits >> 1) & 0x01) != 0) 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/sysctl/pradc.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PRADC"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `R0`"] 4 | pub type R0_R = crate::R; 5 | #[doc = "Reader of field `R1`"] 6 | pub type R1_R = crate::R; 7 | impl R { 8 | #[doc = "Bit 0 - ADC Module 0 Peripheral Ready"] 9 | #[inline(always)] 10 | pub fn r0(&self) -> R0_R { 11 | R0_R::new((self.bits & 0x01) != 0) 12 | } 13 | #[doc = "Bit 1 - ADC Module 1 Peripheral Ready"] 14 | #[inline(always)] 15 | pub fn r1(&self) -> R1_R { 16 | R1_R::new(((self.bits >> 1) & 0x01) != 0) 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/sysctl/prcan.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PRCAN"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `R0`"] 4 | pub type R0_R = crate::R; 5 | #[doc = "Reader of field `R1`"] 6 | pub type R1_R = crate::R; 7 | impl R { 8 | #[doc = "Bit 0 - CAN Module 0 Peripheral Ready"] 9 | #[inline(always)] 10 | pub fn r0(&self) -> R0_R { 11 | R0_R::new((self.bits & 0x01) != 0) 12 | } 13 | #[doc = "Bit 1 - CAN Module 1 Peripheral Ready"] 14 | #[inline(always)] 15 | pub fn r1(&self) -> R1_R { 16 | R1_R::new(((self.bits >> 1) & 0x01) != 0) 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/sysctl/prwd.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PRWD"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `R0`"] 4 | pub type R0_R = crate::R; 5 | #[doc = "Reader of field `R1`"] 6 | pub type R1_R = crate::R; 7 | impl R { 8 | #[doc = "Bit 0 - Watchdog Timer 0 Peripheral Ready"] 9 | #[inline(always)] 10 | pub fn r0(&self) -> R0_R { 11 | R0_R::new((self.bits & 0x01) != 0) 12 | } 13 | #[doc = "Bit 1 - Watchdog Timer 1 Peripheral Ready"] 14 | #[inline(always)] 15 | pub fn r1(&self) -> R1_R { 16 | R1_R::new(((self.bits >> 1) & 0x01) != 0) 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/hib/pp.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PP"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `WAKENC`"] 4 | pub type WAKENC_R = crate::R; 5 | #[doc = "Reader of field `TAMPER`"] 6 | pub type TAMPER_R = crate::R; 7 | impl R { 8 | #[doc = "Bit 0 - Wake Pin Presence"] 9 | #[inline(always)] 10 | pub fn wakenc(&self) -> WAKENC_R { 11 | WAKENC_R::new((self.bits & 0x01) != 0) 12 | } 13 | #[doc = "Bit 1 - Tamper Pin Presence"] 14 | #[inline(always)] 15 | pub fn tamper(&self) -> TAMPER_R { 16 | TAMPER_R::new(((self.bits >> 1) & 0x01) != 0) 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/sysctl/prwd.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PRWD"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `R0`"] 4 | pub type R0_R = crate::R; 5 | #[doc = "Reader of field `R1`"] 6 | pub type R1_R = crate::R; 7 | impl R { 8 | #[doc = "Bit 0 - Watchdog Timer 0 Peripheral Ready"] 9 | #[inline(always)] 10 | pub fn r0(&self) -> R0_R { 11 | R0_R::new((self.bits & 0x01) != 0) 12 | } 13 | #[doc = "Bit 1 - Watchdog Timer 1 Peripheral Ready"] 14 | #[inline(always)] 15 | pub fn r1(&self) -> R1_R { 16 | R1_R::new(((self.bits >> 1) & 0x01) != 0) 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/comp/acris.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register ACRIS"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `IN0`"] 4 | pub type IN0_R = crate::R; 5 | #[doc = "Reader of field `IN1`"] 6 | pub type IN1_R = crate::R; 7 | impl R { 8 | #[doc = "Bit 0 - Comparator 0 Interrupt Status"] 9 | #[inline(always)] 10 | pub fn in0(&self) -> IN0_R { 11 | IN0_R::new((self.bits & 0x01) != 0) 12 | } 13 | #[doc = "Bit 1 - Comparator 1 Interrupt Status"] 14 | #[inline(always)] 15 | pub fn in1(&self) -> IN1_R { 16 | IN1_R::new(((self.bits >> 1) & 0x01) != 0) 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/emac0/cc.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register CC"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `POL`"] 4 | pub type POL_R = crate::R; 5 | #[doc = "Reader of field `PTPCEN`"] 6 | pub type PTPCEN_R = crate::R; 7 | impl R { 8 | #[doc = "Bit 17 - LED Polarity Control"] 9 | #[inline(always)] 10 | pub fn pol(&self) -> POL_R { 11 | POL_R::new(((self.bits >> 17) & 0x01) != 0) 12 | } 13 | #[doc = "Bit 18 - PTP Clock Reference Enable"] 14 | #[inline(always)] 15 | pub fn ptpcen(&self) -> PTPCEN_R { 16 | PTPCEN_R::new(((self.bits >> 18) & 0x01) != 0) 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/i2c0/mmis.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register MMIS"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `MIS`"] 4 | pub type MIS_R = crate::R; 5 | #[doc = "Reader of field `CLKMIS`"] 6 | pub type CLKMIS_R = crate::R; 7 | impl R { 8 | #[doc = "Bit 0 - Masked Interrupt Status"] 9 | #[inline(always)] 10 | pub fn mis(&self) -> MIS_R { 11 | MIS_R::new((self.bits & 0x01) != 0) 12 | } 13 | #[doc = "Bit 1 - Clock Timeout Masked Interrupt Status"] 14 | #[inline(always)] 15 | pub fn clkmis(&self) -> CLKMIS_R { 16 | CLKMIS_R::new(((self.bits >> 1) & 0x01) != 0) 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/i2c0/mris.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register MRIS"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `RIS`"] 4 | pub type RIS_R = crate::R; 5 | #[doc = "Reader of field `CLKRIS`"] 6 | pub type CLKRIS_R = crate::R; 7 | impl R { 8 | #[doc = "Bit 0 - Master Raw Interrupt Status"] 9 | #[inline(always)] 10 | pub fn ris(&self) -> RIS_R { 11 | RIS_R::new((self.bits & 0x01) != 0) 12 | } 13 | #[doc = "Bit 1 - Clock Timeout Raw Interrupt Status"] 14 | #[inline(always)] 15 | pub fn clkris(&self) -> CLKRIS_R { 16 | CLKRIS_R::new(((self.bits >> 1) & 0x01) != 0) 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/qei0/stat.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register STAT"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `ERROR`"] 4 | pub type ERROR_R = crate::R; 5 | #[doc = "Reader of field `DIRECTION`"] 6 | pub type DIRECTION_R = crate::R; 7 | impl R { 8 | #[doc = "Bit 0 - Error Detected"] 9 | #[inline(always)] 10 | pub fn error(&self) -> ERROR_R { 11 | ERROR_R::new((self.bits & 0x01) != 0) 12 | } 13 | #[doc = "Bit 1 - Direction of Rotation"] 14 | #[inline(always)] 15 | pub fn direction(&self) -> DIRECTION_R { 16 | DIRECTION_R::new(((self.bits >> 1) & 0x01) != 0) 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/qei0/stat.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register STAT"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `ERROR`"] 4 | pub type ERROR_R = crate::R; 5 | #[doc = "Reader of field `DIRECTION`"] 6 | pub type DIRECTION_R = crate::R; 7 | impl R { 8 | #[doc = "Bit 0 - Error Detected"] 9 | #[inline(always)] 10 | pub fn error(&self) -> ERROR_R { 11 | ERROR_R::new((self.bits & 0x01) != 0) 12 | } 13 | #[doc = "Bit 1 - Direction of Rotation"] 14 | #[inline(always)] 15 | pub fn direction(&self) -> DIRECTION_R { 16 | DIRECTION_R::new(((self.bits >> 1) & 0x01) != 0) 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/pwm0/status.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register STATUS"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `FAULT0`"] 4 | pub type FAULT0_R = crate::R; 5 | #[doc = "Reader of field `FAULT1`"] 6 | pub type FAULT1_R = crate::R; 7 | impl R { 8 | #[doc = "Bit 0 - Generator 0 Fault Status"] 9 | #[inline(always)] 10 | pub fn fault0(&self) -> FAULT0_R { 11 | FAULT0_R::new((self.bits & 0x01) != 0) 12 | } 13 | #[doc = "Bit 1 - Generator 1 Fault Status"] 14 | #[inline(always)] 15 | pub fn fault1(&self) -> FAULT1_R { 16 | FAULT1_R::new(((self.bits >> 1) & 0x01) != 0) 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/usb0/raminfo.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register RAMINFO"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `RAMBITS`"] 4 | pub type RAMBITS_R = crate::R; 5 | #[doc = "Reader of field `DMACHAN`"] 6 | pub type DMACHAN_R = crate::R; 7 | impl R { 8 | #[doc = "Bits 0:3 - RAM Address Bus Width"] 9 | #[inline(always)] 10 | pub fn rambits(&self) -> RAMBITS_R { 11 | RAMBITS_R::new((self.bits & 0x0f) as u8) 12 | } 13 | #[doc = "Bits 4:7 - DMA Channels"] 14 | #[inline(always)] 15 | pub fn dmachan(&self) -> DMACHAN_R { 16 | DMACHAN_R::new(((self.bits >> 4) & 0x0f) as u8) 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/gpio_porta_ahb/ris.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register RIS"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `GPIO`"] 4 | pub type GPIO_R = crate::R; 5 | #[doc = "Reader of field `DMARIS`"] 6 | pub type DMARIS_R = crate::R; 7 | impl R { 8 | #[doc = "Bits 0:7 - GPIO Interrupt Raw Status"] 9 | #[inline(always)] 10 | pub fn gpio(&self) -> GPIO_R { 11 | GPIO_R::new((self.bits & 0xff) as u8) 12 | } 13 | #[doc = "Bit 8 - GPIO uDMA Done Interrupt Raw Status"] 14 | #[inline(always)] 15 | pub fn dmaris(&self) -> DMARIS_R { 16 | DMARIS_R::new(((self.bits >> 8) & 0x01) != 0) 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/gpio_porta_ahb/mis.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register MIS"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `GPIO`"] 4 | pub type GPIO_R = crate::R; 5 | #[doc = "Reader of field `DMAMIS`"] 6 | pub type DMAMIS_R = crate::R; 7 | impl R { 8 | #[doc = "Bits 0:7 - GPIO Masked Interrupt Status"] 9 | #[inline(always)] 10 | pub fn gpio(&self) -> GPIO_R { 11 | GPIO_R::new((self.bits & 0xff) as u8) 12 | } 13 | #[doc = "Bit 8 - GPIO uDMA Done Masked Interrupt Status"] 14 | #[inline(always)] 15 | pub fn dmamis(&self) -> DMAMIS_R { 16 | DMAMIS_R::new(((self.bits >> 8) & 0x01) != 0) 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/eeprom/eesize.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EESIZE"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `WORDCNT`"] 4 | pub type WORDCNT_R = crate::R; 5 | #[doc = "Reader of field `BLKCNT`"] 6 | pub type BLKCNT_R = crate::R; 7 | impl R { 8 | #[doc = "Bits 0:15 - Number of 32-Bit Words"] 9 | #[inline(always)] 10 | pub fn wordcnt(&self) -> WORDCNT_R { 11 | WORDCNT_R::new((self.bits & 0xffff) as u16) 12 | } 13 | #[doc = "Bits 16:26 - Number of 16-Word Blocks"] 14 | #[inline(always)] 15 | pub fn blkcnt(&self) -> BLKCNT_R { 16 | BLKCNT_R::new(((self.bits >> 16) & 0x07ff) as u16) 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/eeprom/eesize.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register EESIZE"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `WORDCNT`"] 4 | pub type WORDCNT_R = crate::R; 5 | #[doc = "Reader of field `BLKCNT`"] 6 | pub type BLKCNT_R = crate::R; 7 | impl R { 8 | #[doc = "Bits 0:15 - Number of 32-Bit Words"] 9 | #[inline(always)] 10 | pub fn wordcnt(&self) -> WORDCNT_R { 11 | WORDCNT_R::new((self.bits & 0xffff) as u16) 12 | } 13 | #[doc = "Bits 16:26 - Number of 16-Word Blocks"] 14 | #[inline(always)] 15 | pub fn blkcnt(&self) -> BLKCNT_R { 16 | BLKCNT_R::new(((self.bits >> 16) & 0x07ff) as u16) 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/emac0/timstat.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register TIMSTAT"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `TSSOVF`"] 4 | pub type TSSOVF_R = crate::R; 5 | #[doc = "Reader of field `TSTARGT`"] 6 | pub type TSTARGT_R = crate::R; 7 | impl R { 8 | #[doc = "Bit 0 - Timestamp Seconds Overflow"] 9 | #[inline(always)] 10 | pub fn tssovf(&self) -> TSSOVF_R { 11 | TSSOVF_R::new((self.bits & 0x01) != 0) 12 | } 13 | #[doc = "Bit 1 - Timestamp Target Time Reached"] 14 | #[inline(always)] 15 | pub fn tstargt(&self) -> TSTARGT_R { 16 | TSTARGT_R::new(((self.bits >> 1) & 0x01) != 0) 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /LICENSE-0BSD.txt: -------------------------------------------------------------------------------- 1 | Copyright (C) 2016 whitequark@whitequark.org 2 | 3 | Permission to use, copy, modify, and/or distribute this software for 4 | any purpose with or without fee is hereby granted. 5 | 6 | THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 7 | WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 8 | MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 9 | ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 10 | WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN 11 | AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT 12 | OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 13 | 14 | -------------------------------------------------------------------------------- /crates/tm4c123x/LICENSE-0BSD.txt: -------------------------------------------------------------------------------- 1 | Copyright (C) 2017 whitequark@whitequark.org 2 | 3 | Permission to use, copy, modify, and/or distribute this software for 4 | any purpose with or without fee is hereby granted. 5 | 6 | THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 7 | WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 8 | MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 9 | ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 10 | WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN 11 | AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT 12 | OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 13 | 14 | -------------------------------------------------------------------------------- /crates/tm4c129x/LICENSE-0BSD.txt: -------------------------------------------------------------------------------- 1 | Copyright (C) 2017 whitequark@whitequark.org 2 | 3 | Permission to use, copy, modify, and/or distribute this software for 4 | any purpose with or without fee is hereby granted. 5 | 6 | THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 7 | WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 8 | MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 9 | ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 10 | WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN 11 | AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT 12 | OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 13 | 14 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/can0/err.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register ERR"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `TEC`"] 4 | pub type TEC_R = crate::R; 5 | #[doc = "Reader of field `REC`"] 6 | pub type REC_R = crate::R; 7 | #[doc = "Reader of field `RP`"] 8 | pub type RP_R = crate::R; 9 | impl R { 10 | #[doc = "Bits 0:7 - Transmit Error Counter"] 11 | #[inline(always)] 12 | pub fn tec(&self) -> TEC_R { 13 | TEC_R::new((self.bits & 0xff) as u8) 14 | } 15 | #[doc = "Bits 8:14 - Receive Error Counter"] 16 | #[inline(always)] 17 | pub fn rec(&self) -> REC_R { 18 | REC_R::new(((self.bits >> 8) & 0x7f) as u8) 19 | } 20 | #[doc = "Bit 15 - Received Error Passive"] 21 | #[inline(always)] 22 | pub fn rp(&self) -> RP_R { 23 | RP_R::new(((self.bits >> 15) & 0x01) != 0) 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/gpio_porta/icr.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register ICR"] 2 | pub type W = crate::W; 3 | #[doc = "Register ICR `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::ICR { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | #[doc = "Write proxy for field `GPIO`"] 12 | pub struct GPIO_W<'a> { 13 | w: &'a mut W, 14 | } 15 | impl<'a> GPIO_W<'a> { 16 | #[doc = r"Writes raw bits to the field"] 17 | #[inline(always)] 18 | pub unsafe fn bits(self, value: u8) -> &'a mut W { 19 | self.w.bits = (self.w.bits & !0xff) | ((value as u32) & 0xff); 20 | self.w 21 | } 22 | } 23 | impl W { 24 | #[doc = "Bits 0:7 - GPIO Interrupt Clear"] 25 | #[inline(always)] 26 | pub fn gpio(&mut self) -> GPIO_W { 27 | GPIO_W { w: self } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/can0/err.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register ERR"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `TEC`"] 4 | pub type TEC_R = crate::R; 5 | #[doc = "Reader of field `REC`"] 6 | pub type REC_R = crate::R; 7 | #[doc = "Reader of field `RP`"] 8 | pub type RP_R = crate::R; 9 | impl R { 10 | #[doc = "Bits 0:7 - Transmit Error Counter"] 11 | #[inline(always)] 12 | pub fn tec(&self) -> TEC_R { 13 | TEC_R::new((self.bits & 0xff) as u8) 14 | } 15 | #[doc = "Bits 8:14 - Receive Error Counter"] 16 | #[inline(always)] 17 | pub fn rec(&self) -> REC_R { 18 | REC_R::new(((self.bits >> 8) & 0x7f) as u8) 19 | } 20 | #[doc = "Bit 15 - Received Error Passive"] 21 | #[inline(always)] 22 | pub fn rp(&self) -> RP_R { 23 | RP_R::new(((self.bits >> 15) & 0x01) != 0) 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/usb0/cc.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register CC"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `CLKDIV`"] 4 | pub type CLKDIV_R = crate::R; 5 | #[doc = "Reader of field `CSD`"] 6 | pub type CSD_R = crate::R; 7 | #[doc = "Reader of field `CLKEN`"] 8 | pub type CLKEN_R = crate::R; 9 | impl R { 10 | #[doc = "Bits 0:3 - PLL Clock Divisor"] 11 | #[inline(always)] 12 | pub fn clkdiv(&self) -> CLKDIV_R { 13 | CLKDIV_R::new((self.bits & 0x0f) as u8) 14 | } 15 | #[doc = "Bit 8 - Clock Source/Direction"] 16 | #[inline(always)] 17 | pub fn csd(&self) -> CSD_R { 18 | CSD_R::new(((self.bits >> 8) & 0x01) != 0) 19 | } 20 | #[doc = "Bit 9 - USB Clock Enable"] 21 | #[inline(always)] 22 | pub fn clken(&self) -> CLKEN_R { 23 | CLKEN_R::new(((self.bits >> 9) & 0x01) != 0) 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/emac0/rxpolld.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register RXPOLLD"] 2 | pub type W = crate::W; 3 | #[doc = "Register RXPOLLD `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::RXPOLLD { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | #[doc = "Write proxy for field `RPD`"] 12 | pub struct RPD_W<'a> { 13 | w: &'a mut W, 14 | } 15 | impl<'a> RPD_W<'a> { 16 | #[doc = r"Writes raw bits to the field"] 17 | #[inline(always)] 18 | pub unsafe fn bits(self, value: u32) -> &'a mut W { 19 | self.w.bits = (self.w.bits & !0xffff_ffff) | ((value as u32) & 0xffff_ffff); 20 | self.w 21 | } 22 | } 23 | impl W { 24 | #[doc = "Bits 0:31 - Receive Poll Demand"] 25 | #[inline(always)] 26 | pub fn rpd(&mut self) -> RPD_W { 27 | RPD_W { w: self } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/emac0/txpolld.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register TXPOLLD"] 2 | pub type W = crate::W; 3 | #[doc = "Register TXPOLLD `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::TXPOLLD { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | #[doc = "Write proxy for field `TPD`"] 12 | pub struct TPD_W<'a> { 13 | w: &'a mut W, 14 | } 15 | impl<'a> TPD_W<'a> { 16 | #[doc = r"Writes raw bits to the field"] 17 | #[inline(always)] 18 | pub unsafe fn bits(self, value: u32) -> &'a mut W { 19 | self.w.bits = (self.w.bits & !0xffff_ffff) | ((value as u32) & 0xffff_ffff); 20 | self.w 21 | } 22 | } 23 | impl W { 24 | #[doc = "Bits 0:31 - Transmit Poll Demand"] 25 | #[inline(always)] 26 | pub fn tpd(&mut self) -> TPD_W { 27 | TPD_W { w: self } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/comp/acris.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register ACRIS"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `IN0`"] 4 | pub type IN0_R = crate::R; 5 | #[doc = "Reader of field `IN1`"] 6 | pub type IN1_R = crate::R; 7 | #[doc = "Reader of field `IN2`"] 8 | pub type IN2_R = crate::R; 9 | impl R { 10 | #[doc = "Bit 0 - Comparator 0 Interrupt Status"] 11 | #[inline(always)] 12 | pub fn in0(&self) -> IN0_R { 13 | IN0_R::new((self.bits & 0x01) != 0) 14 | } 15 | #[doc = "Bit 1 - Comparator 1 Interrupt Status"] 16 | #[inline(always)] 17 | pub fn in1(&self) -> IN1_R { 18 | IN1_R::new(((self.bits >> 1) & 0x01) != 0) 19 | } 20 | #[doc = "Bit 2 - Comparator 2 Interrupt Status"] 21 | #[inline(always)] 22 | pub fn in2(&self) -> IN2_R { 23 | IN2_R::new(((self.bits >> 2) & 0x01) != 0) 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/udma/altclr.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register ALTCLR"] 2 | pub type W = crate::W; 3 | #[doc = "Register ALTCLR `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::ALTCLR { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | #[doc = "Write proxy for field `CLR`"] 12 | pub struct CLR_W<'a> { 13 | w: &'a mut W, 14 | } 15 | impl<'a> CLR_W<'a> { 16 | #[doc = r"Writes raw bits to the field"] 17 | #[inline(always)] 18 | pub unsafe fn bits(self, value: u32) -> &'a mut W { 19 | self.w.bits = (self.w.bits & !0xffff_ffff) | ((value as u32) & 0xffff_ffff); 20 | self.w 21 | } 22 | } 23 | impl W { 24 | #[doc = "Bits 0:31 - Channel \\[n\\] 25 | Alternate Clear"] 26 | #[inline(always)] 27 | pub fn clr(&mut self) -> CLR_W { 28 | CLR_W { w: self } 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/udma/enaclr.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register ENACLR"] 2 | pub type W = crate::W; 3 | #[doc = "Register ENACLR `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::ENACLR { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | #[doc = "Write proxy for field `CLR`"] 12 | pub struct CLR_W<'a> { 13 | w: &'a mut W, 14 | } 15 | impl<'a> CLR_W<'a> { 16 | #[doc = r"Writes raw bits to the field"] 17 | #[inline(always)] 18 | pub unsafe fn bits(self, value: u32) -> &'a mut W { 19 | self.w.bits = (self.w.bits & !0xffff_ffff) | ((value as u32) & 0xffff_ffff); 20 | self.w 21 | } 22 | } 23 | impl W { 24 | #[doc = "Bits 0:31 - Clear Channel \\[n\\] 25 | Enable Clear"] 26 | #[inline(always)] 27 | pub fn clr(&mut self) -> CLR_W { 28 | CLR_W { w: self } 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/udma/prioclr.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register PRIOCLR"] 2 | pub type W = crate::W; 3 | #[doc = "Register PRIOCLR `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::PRIOCLR { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | #[doc = "Write proxy for field `CLR`"] 12 | pub struct CLR_W<'a> { 13 | w: &'a mut W, 14 | } 15 | impl<'a> CLR_W<'a> { 16 | #[doc = r"Writes raw bits to the field"] 17 | #[inline(always)] 18 | pub unsafe fn bits(self, value: u32) -> &'a mut W { 19 | self.w.bits = (self.w.bits & !0xffff_ffff) | ((value as u32) & 0xffff_ffff); 20 | self.w 21 | } 22 | } 23 | impl W { 24 | #[doc = "Bits 0:31 - Channel \\[n\\] 25 | Priority Clear"] 26 | #[inline(always)] 27 | pub fn clr(&mut self) -> CLR_W { 28 | CLR_W { w: self } 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/udma/altclr.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register ALTCLR"] 2 | pub type W = crate::W; 3 | #[doc = "Register ALTCLR `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::ALTCLR { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | #[doc = "Write proxy for field `CLR`"] 12 | pub struct CLR_W<'a> { 13 | w: &'a mut W, 14 | } 15 | impl<'a> CLR_W<'a> { 16 | #[doc = r"Writes raw bits to the field"] 17 | #[inline(always)] 18 | pub unsafe fn bits(self, value: u32) -> &'a mut W { 19 | self.w.bits = (self.w.bits & !0xffff_ffff) | ((value as u32) & 0xffff_ffff); 20 | self.w 21 | } 22 | } 23 | impl W { 24 | #[doc = "Bits 0:31 - Channel \\[n\\] 25 | Alternate Clear"] 26 | #[inline(always)] 27 | pub fn clr(&mut self) -> CLR_W { 28 | CLR_W { w: self } 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/udma/enaclr.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register ENACLR"] 2 | pub type W = crate::W; 3 | #[doc = "Register ENACLR `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::ENACLR { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | #[doc = "Write proxy for field `CLR`"] 12 | pub struct CLR_W<'a> { 13 | w: &'a mut W, 14 | } 15 | impl<'a> CLR_W<'a> { 16 | #[doc = r"Writes raw bits to the field"] 17 | #[inline(always)] 18 | pub unsafe fn bits(self, value: u32) -> &'a mut W { 19 | self.w.bits = (self.w.bits & !0xffff_ffff) | ((value as u32) & 0xffff_ffff); 20 | self.w 21 | } 22 | } 23 | impl W { 24 | #[doc = "Bits 0:31 - Clear Channel \\[n\\] 25 | Enable Clear"] 26 | #[inline(always)] 27 | pub fn clr(&mut self) -> CLR_W { 28 | CLR_W { w: self } 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/udma/prioclr.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register PRIOCLR"] 2 | pub type W = crate::W; 3 | #[doc = "Register PRIOCLR `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::PRIOCLR { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | #[doc = "Write proxy for field `CLR`"] 12 | pub struct CLR_W<'a> { 13 | w: &'a mut W, 14 | } 15 | impl<'a> CLR_W<'a> { 16 | #[doc = r"Writes raw bits to the field"] 17 | #[inline(always)] 18 | pub unsafe fn bits(self, value: u32) -> &'a mut W { 19 | self.w.bits = (self.w.bits & !0xffff_ffff) | ((value as u32) & 0xffff_ffff); 20 | self.w 21 | } 22 | } 23 | impl W { 24 | #[doc = "Bits 0:31 - Channel \\[n\\] 25 | Priority Clear"] 26 | #[inline(always)] 27 | pub fn clr(&mut self) -> CLR_W { 28 | CLR_W { w: self } 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/udma/reqmaskclr.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register REQMASKCLR"] 2 | pub type W = crate::W; 3 | #[doc = "Register REQMASKCLR `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::REQMASKCLR { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | #[doc = "Write proxy for field `CLR`"] 12 | pub struct CLR_W<'a> { 13 | w: &'a mut W, 14 | } 15 | impl<'a> CLR_W<'a> { 16 | #[doc = r"Writes raw bits to the field"] 17 | #[inline(always)] 18 | pub unsafe fn bits(self, value: u32) -> &'a mut W { 19 | self.w.bits = (self.w.bits & !0xffff_ffff) | ((value as u32) & 0xffff_ffff); 20 | self.w 21 | } 22 | } 23 | impl W { 24 | #[doc = "Bits 0:31 - Channel \\[n\\] 25 | Request Mask Clear"] 26 | #[inline(always)] 27 | pub fn clr(&mut self) -> CLR_W { 28 | CLR_W { w: self } 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/udma/useburstclr.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register USEBURSTCLR"] 2 | pub type W = crate::W; 3 | #[doc = "Register USEBURSTCLR `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::USEBURSTCLR { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | #[doc = "Write proxy for field `CLR`"] 12 | pub struct CLR_W<'a> { 13 | w: &'a mut W, 14 | } 15 | impl<'a> CLR_W<'a> { 16 | #[doc = r"Writes raw bits to the field"] 17 | #[inline(always)] 18 | pub unsafe fn bits(self, value: u32) -> &'a mut W { 19 | self.w.bits = (self.w.bits & !0xffff_ffff) | ((value as u32) & 0xffff_ffff); 20 | self.w 21 | } 22 | } 23 | impl W { 24 | #[doc = "Bits 0:31 - Channel \\[n\\] 25 | Useburst Clear"] 26 | #[inline(always)] 27 | pub fn clr(&mut self) -> CLR_W { 28 | CLR_W { w: self } 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/udma/reqmaskclr.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register REQMASKCLR"] 2 | pub type W = crate::W; 3 | #[doc = "Register REQMASKCLR `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::REQMASKCLR { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | #[doc = "Write proxy for field `CLR`"] 12 | pub struct CLR_W<'a> { 13 | w: &'a mut W, 14 | } 15 | impl<'a> CLR_W<'a> { 16 | #[doc = r"Writes raw bits to the field"] 17 | #[inline(always)] 18 | pub unsafe fn bits(self, value: u32) -> &'a mut W { 19 | self.w.bits = (self.w.bits & !0xffff_ffff) | ((value as u32) & 0xffff_ffff); 20 | self.w 21 | } 22 | } 23 | impl W { 24 | #[doc = "Bits 0:31 - Channel \\[n\\] 25 | Request Mask Clear"] 26 | #[inline(always)] 27 | pub fn clr(&mut self) -> CLR_W { 28 | CLR_W { w: self } 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/udma/useburstclr.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register USEBURSTCLR"] 2 | pub type W = crate::W; 3 | #[doc = "Register USEBURSTCLR `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::USEBURSTCLR { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | #[doc = "Write proxy for field `CLR`"] 12 | pub struct CLR_W<'a> { 13 | w: &'a mut W, 14 | } 15 | impl<'a> CLR_W<'a> { 16 | #[doc = r"Writes raw bits to the field"] 17 | #[inline(always)] 18 | pub unsafe fn bits(self, value: u32) -> &'a mut W { 19 | self.w.bits = (self.w.bits & !0xffff_ffff) | ((value as u32) & 0xffff_ffff); 20 | self.w 21 | } 22 | } 23 | impl W { 24 | #[doc = "Bits 0:31 - Channel \\[n\\] 25 | Useburst Clear"] 26 | #[inline(always)] 27 | pub fn clr(&mut self) -> CLR_W { 28 | CLR_W { w: self } 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/i2c0/sris.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register SRIS"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `DATARIS`"] 4 | pub type DATARIS_R = crate::R; 5 | #[doc = "Reader of field `STARTRIS`"] 6 | pub type STARTRIS_R = crate::R; 7 | #[doc = "Reader of field `STOPRIS`"] 8 | pub type STOPRIS_R = crate::R; 9 | impl R { 10 | #[doc = "Bit 0 - Data Raw Interrupt Status"] 11 | #[inline(always)] 12 | pub fn dataris(&self) -> DATARIS_R { 13 | DATARIS_R::new((self.bits & 0x01) != 0) 14 | } 15 | #[doc = "Bit 1 - Start Condition Raw Interrupt Status"] 16 | #[inline(always)] 17 | pub fn startris(&self) -> STARTRIS_R { 18 | STARTRIS_R::new(((self.bits >> 1) & 0x01) != 0) 19 | } 20 | #[doc = "Bit 2 - Stop Condition Raw Interrupt Status"] 21 | #[inline(always)] 22 | pub fn stopris(&self) -> STOPRIS_R { 23 | STOPRIS_R::new(((self.bits >> 2) & 0x01) != 0) 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/i2c0/smis.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register SMIS"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `DATAMIS`"] 4 | pub type DATAMIS_R = crate::R; 5 | #[doc = "Reader of field `STARTMIS`"] 6 | pub type STARTMIS_R = crate::R; 7 | #[doc = "Reader of field `STOPMIS`"] 8 | pub type STOPMIS_R = crate::R; 9 | impl R { 10 | #[doc = "Bit 0 - Data Masked Interrupt Status"] 11 | #[inline(always)] 12 | pub fn datamis(&self) -> DATAMIS_R { 13 | DATAMIS_R::new((self.bits & 0x01) != 0) 14 | } 15 | #[doc = "Bit 1 - Start Condition Masked Interrupt Status"] 16 | #[inline(always)] 17 | pub fn startmis(&self) -> STARTMIS_R { 18 | STARTMIS_R::new(((self.bits >> 1) & 0x01) != 0) 19 | } 20 | #[doc = "Bit 2 - Stop Condition Masked Interrupt Status"] 21 | #[inline(always)] 22 | pub fn stopmis(&self) -> STOPMIS_R { 23 | STOPMIS_R::new(((self.bits >> 2) & 0x01) != 0) 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/uart0/pp.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PP"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `SC`"] 4 | pub type SC_R = crate::R; 5 | #[doc = "Reader of field `NB`"] 6 | pub type NB_R = crate::R; 7 | #[doc = "Reader of field `MS`"] 8 | pub type MS_R = crate::R; 9 | #[doc = "Reader of field `MSE`"] 10 | pub type MSE_R = crate::R; 11 | impl R { 12 | #[doc = "Bit 0 - Smart Card Support"] 13 | #[inline(always)] 14 | pub fn sc(&self) -> SC_R { 15 | SC_R::new((self.bits & 0x01) != 0) 16 | } 17 | #[doc = "Bit 1 - 9-Bit Support"] 18 | #[inline(always)] 19 | pub fn nb(&self) -> NB_R { 20 | NB_R::new(((self.bits >> 1) & 0x01) != 0) 21 | } 22 | #[doc = "Bit 2 - Modem Support"] 23 | #[inline(always)] 24 | pub fn ms(&self) -> MS_R { 25 | MS_R::new(((self.bits >> 2) & 0x01) != 0) 26 | } 27 | #[doc = "Bit 3 - Modem Support Extended"] 28 | #[inline(always)] 29 | pub fn mse(&self) -> MSE_R { 30 | MSE_R::new(((self.bits >> 3) & 0x01) != 0) 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/sysctl/ppssi.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PPSSI"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `P0`"] 4 | pub type P0_R = crate::R; 5 | #[doc = "Reader of field `P1`"] 6 | pub type P1_R = crate::R; 7 | #[doc = "Reader of field `P2`"] 8 | pub type P2_R = crate::R; 9 | #[doc = "Reader of field `P3`"] 10 | pub type P3_R = crate::R; 11 | impl R { 12 | #[doc = "Bit 0 - SSI Module 0 Present"] 13 | #[inline(always)] 14 | pub fn p0(&self) -> P0_R { 15 | P0_R::new((self.bits & 0x01) != 0) 16 | } 17 | #[doc = "Bit 1 - SSI Module 1 Present"] 18 | #[inline(always)] 19 | pub fn p1(&self) -> P1_R { 20 | P1_R::new(((self.bits >> 1) & 0x01) != 0) 21 | } 22 | #[doc = "Bit 2 - SSI Module 2 Present"] 23 | #[inline(always)] 24 | pub fn p2(&self) -> P2_R { 25 | P2_R::new(((self.bits >> 2) & 0x01) != 0) 26 | } 27 | #[doc = "Bit 3 - SSI Module 3 Present"] 28 | #[inline(always)] 29 | pub fn p3(&self) -> P3_R { 30 | P3_R::new(((self.bits >> 3) & 0x01) != 0) 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/sysctl/ppssi.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PPSSI"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `P0`"] 4 | pub type P0_R = crate::R; 5 | #[doc = "Reader of field `P1`"] 6 | pub type P1_R = crate::R; 7 | #[doc = "Reader of field `P2`"] 8 | pub type P2_R = crate::R; 9 | #[doc = "Reader of field `P3`"] 10 | pub type P3_R = crate::R; 11 | impl R { 12 | #[doc = "Bit 0 - SSI Module 0 Present"] 13 | #[inline(always)] 14 | pub fn p0(&self) -> P0_R { 15 | P0_R::new((self.bits & 0x01) != 0) 16 | } 17 | #[doc = "Bit 1 - SSI Module 1 Present"] 18 | #[inline(always)] 19 | pub fn p1(&self) -> P1_R { 20 | P1_R::new(((self.bits >> 1) & 0x01) != 0) 21 | } 22 | #[doc = "Bit 2 - SSI Module 2 Present"] 23 | #[inline(always)] 24 | pub fn p2(&self) -> P2_R { 25 | P2_R::new(((self.bits >> 2) & 0x01) != 0) 26 | } 27 | #[doc = "Bit 3 - SSI Module 3 Present"] 28 | #[inline(always)] 29 | pub fn p3(&self) -> P3_R { 30 | P3_R::new(((self.bits >> 3) & 0x01) != 0) 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/adc0/ssfstat0.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register SSFSTAT0"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `TPTR`"] 4 | pub type TPTR_R = crate::R; 5 | #[doc = "Reader of field `HPTR`"] 6 | pub type HPTR_R = crate::R; 7 | #[doc = "Reader of field `EMPTY`"] 8 | pub type EMPTY_R = crate::R; 9 | #[doc = "Reader of field `FULL`"] 10 | pub type FULL_R = crate::R; 11 | impl R { 12 | #[doc = "Bits 0:3 - FIFO Tail Pointer"] 13 | #[inline(always)] 14 | pub fn tptr(&self) -> TPTR_R { 15 | TPTR_R::new((self.bits & 0x0f) as u8) 16 | } 17 | #[doc = "Bits 4:7 - FIFO Head Pointer"] 18 | #[inline(always)] 19 | pub fn hptr(&self) -> HPTR_R { 20 | HPTR_R::new(((self.bits >> 4) & 0x0f) as u8) 21 | } 22 | #[doc = "Bit 8 - FIFO Empty"] 23 | #[inline(always)] 24 | pub fn empty(&self) -> EMPTY_R { 25 | EMPTY_R::new(((self.bits >> 8) & 0x01) != 0) 26 | } 27 | #[doc = "Bit 12 - FIFO Full"] 28 | #[inline(always)] 29 | pub fn full(&self) -> FULL_R { 30 | FULL_R::new(((self.bits >> 12) & 0x01) != 0) 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/adc0/ssfstat1.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register SSFSTAT1"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `TPTR`"] 4 | pub type TPTR_R = crate::R; 5 | #[doc = "Reader of field `HPTR`"] 6 | pub type HPTR_R = crate::R; 7 | #[doc = "Reader of field `EMPTY`"] 8 | pub type EMPTY_R = crate::R; 9 | #[doc = "Reader of field `FULL`"] 10 | pub type FULL_R = crate::R; 11 | impl R { 12 | #[doc = "Bits 0:3 - FIFO Tail Pointer"] 13 | #[inline(always)] 14 | pub fn tptr(&self) -> TPTR_R { 15 | TPTR_R::new((self.bits & 0x0f) as u8) 16 | } 17 | #[doc = "Bits 4:7 - FIFO Head Pointer"] 18 | #[inline(always)] 19 | pub fn hptr(&self) -> HPTR_R { 20 | HPTR_R::new(((self.bits >> 4) & 0x0f) as u8) 21 | } 22 | #[doc = "Bit 8 - FIFO Empty"] 23 | #[inline(always)] 24 | pub fn empty(&self) -> EMPTY_R { 25 | EMPTY_R::new(((self.bits >> 8) & 0x01) != 0) 26 | } 27 | #[doc = "Bit 12 - FIFO Full"] 28 | #[inline(always)] 29 | pub fn full(&self) -> FULL_R { 30 | FULL_R::new(((self.bits >> 12) & 0x01) != 0) 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/adc0/ssfstat2.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register SSFSTAT2"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `TPTR`"] 4 | pub type TPTR_R = crate::R; 5 | #[doc = "Reader of field `HPTR`"] 6 | pub type HPTR_R = crate::R; 7 | #[doc = "Reader of field `EMPTY`"] 8 | pub type EMPTY_R = crate::R; 9 | #[doc = "Reader of field `FULL`"] 10 | pub type FULL_R = crate::R; 11 | impl R { 12 | #[doc = "Bits 0:3 - FIFO Tail Pointer"] 13 | #[inline(always)] 14 | pub fn tptr(&self) -> TPTR_R { 15 | TPTR_R::new((self.bits & 0x0f) as u8) 16 | } 17 | #[doc = "Bits 4:7 - FIFO Head Pointer"] 18 | #[inline(always)] 19 | pub fn hptr(&self) -> HPTR_R { 20 | HPTR_R::new(((self.bits >> 4) & 0x0f) as u8) 21 | } 22 | #[doc = "Bit 8 - FIFO Empty"] 23 | #[inline(always)] 24 | pub fn empty(&self) -> EMPTY_R { 25 | EMPTY_R::new(((self.bits >> 8) & 0x01) != 0) 26 | } 27 | #[doc = "Bit 12 - FIFO Full"] 28 | #[inline(always)] 29 | pub fn full(&self) -> FULL_R { 30 | FULL_R::new(((self.bits >> 12) & 0x01) != 0) 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/adc0/ssfstat3.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register SSFSTAT3"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `TPTR`"] 4 | pub type TPTR_R = crate::R; 5 | #[doc = "Reader of field `HPTR`"] 6 | pub type HPTR_R = crate::R; 7 | #[doc = "Reader of field `EMPTY`"] 8 | pub type EMPTY_R = crate::R; 9 | #[doc = "Reader of field `FULL`"] 10 | pub type FULL_R = crate::R; 11 | impl R { 12 | #[doc = "Bits 0:3 - FIFO Tail Pointer"] 13 | #[inline(always)] 14 | pub fn tptr(&self) -> TPTR_R { 15 | TPTR_R::new((self.bits & 0x0f) as u8) 16 | } 17 | #[doc = "Bits 4:7 - FIFO Head Pointer"] 18 | #[inline(always)] 19 | pub fn hptr(&self) -> HPTR_R { 20 | HPTR_R::new(((self.bits >> 4) & 0x0f) as u8) 21 | } 22 | #[doc = "Bit 8 - FIFO Empty"] 23 | #[inline(always)] 24 | pub fn empty(&self) -> EMPTY_R { 25 | EMPTY_R::new(((self.bits >> 8) & 0x01) != 0) 26 | } 27 | #[doc = "Bit 12 - FIFO Full"] 28 | #[inline(always)] 29 | pub fn full(&self) -> FULL_R { 30 | FULL_R::new(((self.bits >> 12) & 0x01) != 0) 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/adc0/ssfstat0.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register SSFSTAT0"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `TPTR`"] 4 | pub type TPTR_R = crate::R; 5 | #[doc = "Reader of field `HPTR`"] 6 | pub type HPTR_R = crate::R; 7 | #[doc = "Reader of field `EMPTY`"] 8 | pub type EMPTY_R = crate::R; 9 | #[doc = "Reader of field `FULL`"] 10 | pub type FULL_R = crate::R; 11 | impl R { 12 | #[doc = "Bits 0:3 - FIFO Tail Pointer"] 13 | #[inline(always)] 14 | pub fn tptr(&self) -> TPTR_R { 15 | TPTR_R::new((self.bits & 0x0f) as u8) 16 | } 17 | #[doc = "Bits 4:7 - FIFO Head Pointer"] 18 | #[inline(always)] 19 | pub fn hptr(&self) -> HPTR_R { 20 | HPTR_R::new(((self.bits >> 4) & 0x0f) as u8) 21 | } 22 | #[doc = "Bit 8 - FIFO Empty"] 23 | #[inline(always)] 24 | pub fn empty(&self) -> EMPTY_R { 25 | EMPTY_R::new(((self.bits >> 8) & 0x01) != 0) 26 | } 27 | #[doc = "Bit 12 - FIFO Full"] 28 | #[inline(always)] 29 | pub fn full(&self) -> FULL_R { 30 | FULL_R::new(((self.bits >> 12) & 0x01) != 0) 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/adc0/ssfstat1.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register SSFSTAT1"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `TPTR`"] 4 | pub type TPTR_R = crate::R; 5 | #[doc = "Reader of field `HPTR`"] 6 | pub type HPTR_R = crate::R; 7 | #[doc = "Reader of field `EMPTY`"] 8 | pub type EMPTY_R = crate::R; 9 | #[doc = "Reader of field `FULL`"] 10 | pub type FULL_R = crate::R; 11 | impl R { 12 | #[doc = "Bits 0:3 - FIFO Tail Pointer"] 13 | #[inline(always)] 14 | pub fn tptr(&self) -> TPTR_R { 15 | TPTR_R::new((self.bits & 0x0f) as u8) 16 | } 17 | #[doc = "Bits 4:7 - FIFO Head Pointer"] 18 | #[inline(always)] 19 | pub fn hptr(&self) -> HPTR_R { 20 | HPTR_R::new(((self.bits >> 4) & 0x0f) as u8) 21 | } 22 | #[doc = "Bit 8 - FIFO Empty"] 23 | #[inline(always)] 24 | pub fn empty(&self) -> EMPTY_R { 25 | EMPTY_R::new(((self.bits >> 8) & 0x01) != 0) 26 | } 27 | #[doc = "Bit 12 - FIFO Full"] 28 | #[inline(always)] 29 | pub fn full(&self) -> FULL_R { 30 | FULL_R::new(((self.bits >> 12) & 0x01) != 0) 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/adc0/ssfstat2.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register SSFSTAT2"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `TPTR`"] 4 | pub type TPTR_R = crate::R; 5 | #[doc = "Reader of field `HPTR`"] 6 | pub type HPTR_R = crate::R; 7 | #[doc = "Reader of field `EMPTY`"] 8 | pub type EMPTY_R = crate::R; 9 | #[doc = "Reader of field `FULL`"] 10 | pub type FULL_R = crate::R; 11 | impl R { 12 | #[doc = "Bits 0:3 - FIFO Tail Pointer"] 13 | #[inline(always)] 14 | pub fn tptr(&self) -> TPTR_R { 15 | TPTR_R::new((self.bits & 0x0f) as u8) 16 | } 17 | #[doc = "Bits 4:7 - FIFO Head Pointer"] 18 | #[inline(always)] 19 | pub fn hptr(&self) -> HPTR_R { 20 | HPTR_R::new(((self.bits >> 4) & 0x0f) as u8) 21 | } 22 | #[doc = "Bit 8 - FIFO Empty"] 23 | #[inline(always)] 24 | pub fn empty(&self) -> EMPTY_R { 25 | EMPTY_R::new(((self.bits >> 8) & 0x01) != 0) 26 | } 27 | #[doc = "Bit 12 - FIFO Full"] 28 | #[inline(always)] 29 | pub fn full(&self) -> FULL_R { 30 | FULL_R::new(((self.bits >> 12) & 0x01) != 0) 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/adc0/ssfstat3.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register SSFSTAT3"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `TPTR`"] 4 | pub type TPTR_R = crate::R; 5 | #[doc = "Reader of field `HPTR`"] 6 | pub type HPTR_R = crate::R; 7 | #[doc = "Reader of field `EMPTY`"] 8 | pub type EMPTY_R = crate::R; 9 | #[doc = "Reader of field `FULL`"] 10 | pub type FULL_R = crate::R; 11 | impl R { 12 | #[doc = "Bits 0:3 - FIFO Tail Pointer"] 13 | #[inline(always)] 14 | pub fn tptr(&self) -> TPTR_R { 15 | TPTR_R::new((self.bits & 0x0f) as u8) 16 | } 17 | #[doc = "Bits 4:7 - FIFO Head Pointer"] 18 | #[inline(always)] 19 | pub fn hptr(&self) -> HPTR_R { 20 | HPTR_R::new(((self.bits >> 4) & 0x0f) as u8) 21 | } 22 | #[doc = "Bit 8 - FIFO Empty"] 23 | #[inline(always)] 24 | pub fn empty(&self) -> EMPTY_R { 25 | EMPTY_R::new(((self.bits >> 8) & 0x01) != 0) 26 | } 27 | #[doc = "Bit 12 - FIFO Full"] 28 | #[inline(always)] 29 | pub fn full(&self) -> FULL_R { 30 | FULL_R::new(((self.bits >> 12) & 0x01) != 0) 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/comp/pp.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PP"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `CMP0`"] 4 | pub type CMP0_R = crate::R; 5 | #[doc = "Reader of field `CMP1`"] 6 | pub type CMP1_R = crate::R; 7 | #[doc = "Reader of field `C0O`"] 8 | pub type C0O_R = crate::R; 9 | #[doc = "Reader of field `C1O`"] 10 | pub type C1O_R = crate::R; 11 | impl R { 12 | #[doc = "Bit 0 - Comparator 0 Present"] 13 | #[inline(always)] 14 | pub fn cmp0(&self) -> CMP0_R { 15 | CMP0_R::new((self.bits & 0x01) != 0) 16 | } 17 | #[doc = "Bit 1 - Comparator 1 Present"] 18 | #[inline(always)] 19 | pub fn cmp1(&self) -> CMP1_R { 20 | CMP1_R::new(((self.bits >> 1) & 0x01) != 0) 21 | } 22 | #[doc = "Bit 16 - Comparator Output 0 Present"] 23 | #[inline(always)] 24 | pub fn c0o(&self) -> C0O_R { 25 | C0O_R::new(((self.bits >> 16) & 0x01) != 0) 26 | } 27 | #[doc = "Bit 17 - Comparator Output 1 Present"] 28 | #[inline(always)] 29 | pub fn c1o(&self) -> C1O_R { 30 | C1O_R::new(((self.bits >> 17) & 0x01) != 0) 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/sysctl/pri2c.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PRI2C"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `R0`"] 4 | pub type R0_R = crate::R; 5 | #[doc = "Reader of field `R1`"] 6 | pub type R1_R = crate::R; 7 | #[doc = "Reader of field `R2`"] 8 | pub type R2_R = crate::R; 9 | #[doc = "Reader of field `R3`"] 10 | pub type R3_R = crate::R; 11 | impl R { 12 | #[doc = "Bit 0 - I2C Module 0 Peripheral Ready"] 13 | #[inline(always)] 14 | pub fn r0(&self) -> R0_R { 15 | R0_R::new((self.bits & 0x01) != 0) 16 | } 17 | #[doc = "Bit 1 - I2C Module 1 Peripheral Ready"] 18 | #[inline(always)] 19 | pub fn r1(&self) -> R1_R { 20 | R1_R::new(((self.bits >> 1) & 0x01) != 0) 21 | } 22 | #[doc = "Bit 2 - I2C Module 2 Peripheral Ready"] 23 | #[inline(always)] 24 | pub fn r2(&self) -> R2_R { 25 | R2_R::new(((self.bits >> 2) & 0x01) != 0) 26 | } 27 | #[doc = "Bit 3 - I2C Module 3 Peripheral Ready"] 28 | #[inline(always)] 29 | pub fn r3(&self) -> R3_R { 30 | R3_R::new(((self.bits >> 3) & 0x01) != 0) 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/sysctl/prssi.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PRSSI"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `R0`"] 4 | pub type R0_R = crate::R; 5 | #[doc = "Reader of field `R1`"] 6 | pub type R1_R = crate::R; 7 | #[doc = "Reader of field `R2`"] 8 | pub type R2_R = crate::R; 9 | #[doc = "Reader of field `R3`"] 10 | pub type R3_R = crate::R; 11 | impl R { 12 | #[doc = "Bit 0 - SSI Module 0 Peripheral Ready"] 13 | #[inline(always)] 14 | pub fn r0(&self) -> R0_R { 15 | R0_R::new((self.bits & 0x01) != 0) 16 | } 17 | #[doc = "Bit 1 - SSI Module 1 Peripheral Ready"] 18 | #[inline(always)] 19 | pub fn r1(&self) -> R1_R { 20 | R1_R::new(((self.bits >> 1) & 0x01) != 0) 21 | } 22 | #[doc = "Bit 2 - SSI Module 2 Peripheral Ready"] 23 | #[inline(always)] 24 | pub fn r2(&self) -> R2_R { 25 | R2_R::new(((self.bits >> 2) & 0x01) != 0) 26 | } 27 | #[doc = "Bit 3 - SSI Module 3 Peripheral Ready"] 28 | #[inline(always)] 29 | pub fn r3(&self) -> R3_R { 30 | R3_R::new(((self.bits >> 3) & 0x01) != 0) 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/sysctl/prssi.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register PRSSI"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `R0`"] 4 | pub type R0_R = crate::R; 5 | #[doc = "Reader of field `R1`"] 6 | pub type R1_R = crate::R; 7 | #[doc = "Reader of field `R2`"] 8 | pub type R2_R = crate::R; 9 | #[doc = "Reader of field `R3`"] 10 | pub type R3_R = crate::R; 11 | impl R { 12 | #[doc = "Bit 0 - SSI Module 0 Peripheral Ready"] 13 | #[inline(always)] 14 | pub fn r0(&self) -> R0_R { 15 | R0_R::new((self.bits & 0x01) != 0) 16 | } 17 | #[doc = "Bit 1 - SSI Module 1 Peripheral Ready"] 18 | #[inline(always)] 19 | pub fn r1(&self) -> R1_R { 20 | R1_R::new(((self.bits >> 1) & 0x01) != 0) 21 | } 22 | #[doc = "Bit 2 - SSI Module 2 Peripheral Ready"] 23 | #[inline(always)] 24 | pub fn r2(&self) -> R2_R { 25 | R2_R::new(((self.bits >> 2) & 0x01) != 0) 26 | } 27 | #[doc = "Bit 3 - SSI Module 3 Peripheral Ready"] 28 | #[inline(always)] 29 | pub fn r3(&self) -> R3_R { 30 | R3_R::new(((self.bits >> 3) & 0x01) != 0) 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/qei0/ris.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register RIS"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `INDEX`"] 4 | pub type INDEX_R = crate::R; 5 | #[doc = "Reader of field `TIMER`"] 6 | pub type TIMER_R = crate::R; 7 | #[doc = "Reader of field `DIR`"] 8 | pub type DIR_R = crate::R; 9 | #[doc = "Reader of field `ERROR`"] 10 | pub type ERROR_R = crate::R; 11 | impl R { 12 | #[doc = "Bit 0 - Index Pulse Asserted"] 13 | #[inline(always)] 14 | pub fn index(&self) -> INDEX_R { 15 | INDEX_R::new((self.bits & 0x01) != 0) 16 | } 17 | #[doc = "Bit 1 - Velocity Timer Expired"] 18 | #[inline(always)] 19 | pub fn timer(&self) -> TIMER_R { 20 | TIMER_R::new(((self.bits >> 1) & 0x01) != 0) 21 | } 22 | #[doc = "Bit 2 - Direction Change Detected"] 23 | #[inline(always)] 24 | pub fn dir(&self) -> DIR_R { 25 | DIR_R::new(((self.bits >> 2) & 0x01) != 0) 26 | } 27 | #[doc = "Bit 3 - Phase Error Detected"] 28 | #[inline(always)] 29 | pub fn error(&self) -> ERROR_R { 30 | ERROR_R::new(((self.bits >> 3) & 0x01) != 0) 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/qei0/ris.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register RIS"] 2 | pub type R = crate::R; 3 | #[doc = "Reader of field `INDEX`"] 4 | pub type INDEX_R = crate::R; 5 | #[doc = "Reader of field `TIMER`"] 6 | pub type TIMER_R = crate::R; 7 | #[doc = "Reader of field `DIR`"] 8 | pub type DIR_R = crate::R; 9 | #[doc = "Reader of field `ERROR`"] 10 | pub type ERROR_R = crate::R; 11 | impl R { 12 | #[doc = "Bit 0 - Index Pulse Asserted"] 13 | #[inline(always)] 14 | pub fn index(&self) -> INDEX_R { 15 | INDEX_R::new((self.bits & 0x01) != 0) 16 | } 17 | #[doc = "Bit 1 - Velocity Timer Expired"] 18 | #[inline(always)] 19 | pub fn timer(&self) -> TIMER_R { 20 | TIMER_R::new(((self.bits >> 1) & 0x01) != 0) 21 | } 22 | #[doc = "Bit 2 - Direction Change Detected"] 23 | #[inline(always)] 24 | pub fn dir(&self) -> DIR_R { 25 | DIR_R::new(((self.bits >> 2) & 0x01) != 0) 26 | } 27 | #[doc = "Bit 3 - Phase Error Detected"] 28 | #[inline(always)] 29 | pub fn error(&self) -> ERROR_R { 30 | ERROR_R::new(((self.bits >> 3) & 0x01) != 0) 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /crates/tm4c123x/src/udma/cfg.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Writer for register CFG"] 2 | pub type W = crate::W; 3 | #[doc = "Register CFG `reset()`'s with value 0"] 4 | impl crate::ResetValue for super::CFG { 5 | type Type = u32; 6 | #[inline(always)] 7 | fn reset_value() -> Self::Type { 8 | 0 9 | } 10 | } 11 | #[doc = "Write proxy for field `MASTEN`"] 12 | pub struct MASTEN_W<'a> { 13 | w: &'a mut W, 14 | } 15 | impl<'a> MASTEN_W<'a> { 16 | #[doc = r"Sets the field bit"] 17 | #[inline(always)] 18 | pub fn set_bit(self) -> &'a mut W { 19 | self.bit(true) 20 | } 21 | #[doc = r"Clears the field bit"] 22 | #[inline(always)] 23 | pub fn clear_bit(self) -> &'a mut W { 24 | self.bit(false) 25 | } 26 | #[doc = r"Writes raw bits to the field"] 27 | #[inline(always)] 28 | pub fn bit(self, value: bool) -> &'a mut W { 29 | self.w.bits = (self.w.bits & !0x01) | ((value as u32) & 0x01); 30 | self.w 31 | } 32 | } 33 | impl W { 34 | #[doc = "Bit 0 - Controller Master Enable"] 35 | #[inline(always)] 36 | pub fn masten(&mut self) -> MASTEN_W { 37 | MASTEN_W { w: self } 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/gpio_porta_ahb/den.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register DEN"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register DEN"] 4 | pub type W = crate::W; 5 | #[doc = "Register DEN `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::DEN { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | #[doc = "Reader of field `DEN`"] 14 | pub type DEN_R = crate::R; 15 | #[doc = "Write proxy for field `DEN`"] 16 | pub struct DEN_W<'a> { 17 | w: &'a mut W, 18 | } 19 | impl<'a> DEN_W<'a> { 20 | #[doc = r"Writes raw bits to the field"] 21 | #[inline(always)] 22 | pub fn bits(self, value: u8) -> &'a mut W { 23 | self.w.bits = (self.w.bits & !0xff) | ((value as u32) & 0xff); 24 | self.w 25 | } 26 | } 27 | impl R { 28 | #[doc = "Bits 0:7"] 29 | #[inline(always)] 30 | pub fn den(&self) -> DEN_R { 31 | DEN_R::new((self.bits & 0xff) as u8) 32 | } 33 | } 34 | impl W { 35 | #[doc = "Bits 0:7"] 36 | #[inline(always)] 37 | pub fn den(&mut self) -> DEN_W { 38 | DEN_W { w: self } 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/gpio_porta_ahb/dir.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register DIR"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register DIR"] 4 | pub type W = crate::W; 5 | #[doc = "Register DIR `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::DIR { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | #[doc = "Reader of field `DIR`"] 14 | pub type DIR_R = crate::R; 15 | #[doc = "Write proxy for field `DIR`"] 16 | pub struct DIR_W<'a> { 17 | w: &'a mut W, 18 | } 19 | impl<'a> DIR_W<'a> { 20 | #[doc = r"Writes raw bits to the field"] 21 | #[inline(always)] 22 | pub fn bits(self, value: u8) -> &'a mut W { 23 | self.w.bits = (self.w.bits & !0xff) | ((value as u32) & 0xff); 24 | self.w 25 | } 26 | } 27 | impl R { 28 | #[doc = "Bits 0:7"] 29 | #[inline(always)] 30 | pub fn dir(&self) -> DIR_R { 31 | DIR_R::new((self.bits & 0xff) as u8) 32 | } 33 | } 34 | impl W { 35 | #[doc = "Bits 0:7"] 36 | #[inline(always)] 37 | pub fn dir(&mut self) -> DIR_W { 38 | DIR_W { w: self } 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /crates/tm4c129x/src/gpio_porta_ahb/odr.rs: -------------------------------------------------------------------------------- 1 | #[doc = "Reader of register ODR"] 2 | pub type R = crate::R; 3 | #[doc = "Writer for register ODR"] 4 | pub type W = crate::W; 5 | #[doc = "Register ODR `reset()`'s with value 0"] 6 | impl crate::ResetValue for super::ODR { 7 | type Type = u32; 8 | #[inline(always)] 9 | fn reset_value() -> Self::Type { 10 | 0 11 | } 12 | } 13 | #[doc = "Reader of field `ODE`"] 14 | pub type ODE_R = crate::R; 15 | #[doc = "Write proxy for field `ODE`"] 16 | pub struct ODE_W<'a> { 17 | w: &'a mut W, 18 | } 19 | impl<'a> ODE_W<'a> { 20 | #[doc = r"Writes raw bits to the field"] 21 | #[inline(always)] 22 | pub fn bits(self, value: u8) -> &'a mut W { 23 | self.w.bits = (self.w.bits & !0xff) | ((value as u32) & 0xff); 24 | self.w 25 | } 26 | } 27 | impl R { 28 | #[doc = "Bits 0:7"] 29 | #[inline(always)] 30 | pub fn ode(&self) -> ODE_R { 31 | ODE_R::new((self.bits & 0xff) as u8) 32 | } 33 | } 34 | impl W { 35 | #[doc = "Bits 0:7"] 36 | #[inline(always)] 37 | pub fn ode(&mut self) -> ODE_W { 38 | ODE_W { w: self } 39 | } 40 | } 41 | --------------------------------------------------------------------------------