[−][src]Struct drone_stm32_map_periph_i2c::I2C4

pub struct I2C4(_);

I2C4 peripheral variant.

Trait Implementations

`impl RccBusenrI2Cen for I2C4`[src]

`type URccBusenrI2Cen = I2C4En<Urt>`

`type SRccBusenrI2Cen = I2C4En<Srt>`

`type CRccBusenrI2Cen = I2C4En<Crt>`

`impl RccBusenr for I2C4`[src]

`type RccBusenrVal = Val`

`type URccBusenr = Reg<Urt>`

`type SRccBusenr = Reg<Srt>`

`type CRccBusenr = Reg<Crt>`

`impl RccBusrstrI2Crst for I2C4`[src]

`type URccBusrstrI2Crst = I2C4Rst<Urt>`

`type SRccBusrstrI2Crst = I2C4Rst<Srt>`

`type CRccBusrstrI2Crst = I2C4Rst<Crt>`

`impl RccBusrstr for I2C4`[src]

`type RccBusrstrVal = Val`

`type URccBusrstr = Reg<Urt>`

`type SRccBusrstr = Reg<Srt>`

`type CRccBusrstr = Reg<Crt>`

`impl RccBussmenrI2Csmen for I2C4`[src]

`type URccBussmenrI2Csmen = I2C4Smen<Urt>`

`type SRccBussmenrI2Csmen = I2C4Smen<Srt>`

`type CRccBussmenrI2Csmen = I2C4Smen<Crt>`

`impl RccBussmenr for I2C4`[src]

`type RccBussmenrVal = Val`

`type URccBussmenr = Reg<Urt>`

`type SRccBussmenr = Reg<Srt>`

`type CRccBussmenr = Reg<Crt>`

`impl RccCciprI2Csel for I2C4`[src]

`type URccCciprI2Csel = I2C4Sel<Urt>`

`type SRccCciprI2Csel = I2C4Sel<Srt>`

`type CRccCciprI2Csel = I2C4Sel<Crt>`

`impl RccCcipr for I2C4`[src]

`type RccCciprVal = Val`

`type URccCcipr = Reg<Urt>`

`type SRccCcipr = Reg<Srt>`

`type CRccCcipr = Reg<Crt>`

`impl I2CCr1Addrie<I2C4> for I2C4`[src]

`type UI2CCr1Addrie = Addrie<Urt>`

`type SI2CCr1Addrie = Addrie<Srt>`

`type CI2CCr1Addrie = Addrie<Crt>`

`impl I2CCr1Alerten<I2C4> for I2C4`[src]

`type UI2CCr1Alerten = Alerten<Urt>`

`type SI2CCr1Alerten = Alerten<Srt>`

`type CI2CCr1Alerten = Alerten<Crt>`

`impl I2CCr1Anfoff<I2C4> for I2C4`[src]

`type UI2CCr1Anfoff = Anfoff<Urt>`

`type SI2CCr1Anfoff = Anfoff<Srt>`

`type CI2CCr1Anfoff = Anfoff<Crt>`

`impl I2CCr1Dnf<I2C4> for I2C4`[src]

`type UI2CCr1Dnf = Dnf<Urt>`

`type SI2CCr1Dnf = Dnf<Srt>`

`type CI2CCr1Dnf = Dnf<Crt>`

`impl I2CCr1Errie<I2C4> for I2C4`[src]

`type UI2CCr1Errie = Errie<Urt>`

`type SI2CCr1Errie = Errie<Srt>`

`type CI2CCr1Errie = Errie<Crt>`

`impl I2CCr1Gcen<I2C4> for I2C4`[src]

`type UI2CCr1Gcen = Gcen<Urt>`

`type SI2CCr1Gcen = Gcen<Srt>`

`type CI2CCr1Gcen = Gcen<Crt>`

`impl I2CCr1Nackie<I2C4> for I2C4`[src]

`type UI2CCr1Nackie = Nackie<Urt>`

`type SI2CCr1Nackie = Nackie<Srt>`

`type CI2CCr1Nackie = Nackie<Crt>`

`impl I2CCr1Nostretch<I2C4> for I2C4`[src]

`type UI2CCr1Nostretch = Nostretch<Urt>`

`type SI2CCr1Nostretch = Nostretch<Srt>`

`type CI2CCr1Nostretch = Nostretch<Crt>`

`impl I2CCr1Pecen<I2C4> for I2C4`[src]

`type UI2CCr1Pecen = Pecen<Urt>`

`type SI2CCr1Pecen = Pecen<Srt>`

`type CI2CCr1Pecen = Pecen<Crt>`

`impl I2CCr1Pe<I2C4> for I2C4`[src]

`type UI2CCr1Pe = Pe<Urt>`

`type SI2CCr1Pe = Pe<Srt>`

`type CI2CCr1Pe = Pe<Crt>`

`impl I2CCr1Rxdmaen<I2C4> for I2C4`[src]

`type UI2CCr1Rxdmaen = Rxdmaen<Urt>`

`type SI2CCr1Rxdmaen = Rxdmaen<Srt>`

`type CI2CCr1Rxdmaen = Rxdmaen<Crt>`

`impl I2CCr1Rxie<I2C4> for I2C4`[src]

`type UI2CCr1Rxie = Rxie<Urt>`

`type SI2CCr1Rxie = Rxie<Srt>`

`type CI2CCr1Rxie = Rxie<Crt>`

`impl I2CCr1Sbc<I2C4> for I2C4`[src]

`type UI2CCr1Sbc = Sbc<Urt>`

`type SI2CCr1Sbc = Sbc<Srt>`

`type CI2CCr1Sbc = Sbc<Crt>`

`impl I2CCr1Smbden<I2C4> for I2C4`[src]

`type UI2CCr1Smbden = Smbden<Urt>`

`type SI2CCr1Smbden = Smbden<Srt>`

`type CI2CCr1Smbden = Smbden<Crt>`

`impl I2CCr1Smbhen<I2C4> for I2C4`[src]

`type UI2CCr1Smbhen = Smbhen<Urt>`

`type SI2CCr1Smbhen = Smbhen<Srt>`

`type CI2CCr1Smbhen = Smbhen<Crt>`

`impl I2CCr1Stopie<I2C4> for I2C4`[src]

`type UI2CCr1Stopie = Stopie<Urt>`

`type SI2CCr1Stopie = Stopie<Srt>`

`type CI2CCr1Stopie = Stopie<Crt>`

`impl I2CCr1Tcie<I2C4> for I2C4`[src]

`type UI2CCr1Tcie = Tcie<Urt>`

`type SI2CCr1Tcie = Tcie<Srt>`

`type CI2CCr1Tcie = Tcie<Crt>`

`impl I2CCr1Txdmaen<I2C4> for I2C4`[src]

`type UI2CCr1Txdmaen = Txdmaen<Urt>`

`type SI2CCr1Txdmaen = Txdmaen<Srt>`

`type CI2CCr1Txdmaen = Txdmaen<Crt>`

`impl I2CCr1Txie<I2C4> for I2C4`[src]

`type UI2CCr1Txie = Txie<Urt>`

`type SI2CCr1Txie = Txie<Srt>`

`type CI2CCr1Txie = Txie<Crt>`

`impl I2CCr1Wupen<I2C4> for I2C4`[src]

`type UI2CCr1Wupen = Wupen<Urt>`

`type SI2CCr1Wupen = Wupen<Srt>`

`type CI2CCr1Wupen = Wupen<Crt>`

`impl I2CCr1<I2C4> for I2C4`[src]

`type I2CCr1Val = Val`

`type UI2CCr1 = Reg<Urt>`

`type SI2CCr1 = Reg<Srt>`

`type CI2CCr1 = Reg<Crt>`

`impl UI2CCr1<I2C4> for Reg<Urt>`[src]

`fn from_fields(map: UI2CCr1Fields<I2C4>) -> Self`[src]

`fn into_fields(self) -> UI2CCr1Fields<I2C4>`[src]

`fn addrie(&self) -> &Addrie<Urt>`[src]

`fn alerten(&self) -> &Alerten<Urt>`[src]

`fn anfoff(&self) -> &Anfoff<Urt>`[src]

`fn dnf(&self) -> &Dnf<Urt>`[src]

`fn errie(&self) -> &Errie<Urt>`[src]

`fn gcen(&self) -> &Gcen<Urt>`[src]

`fn nackie(&self) -> &Nackie<Urt>`[src]

`fn nostretch(&self) -> &Nostretch<Urt>`[src]

`fn pecen(&self) -> &Pecen<Urt>`[src]

`fn pe(&self) -> &Pe<Urt>`[src]

`fn rxdmaen(&self) -> &Rxdmaen<Urt>`[src]

`fn rxie(&self) -> &Rxie<Urt>`[src]

`fn sbc(&self) -> &Sbc<Urt>`[src]

`fn smbden(&self) -> &Smbden<Urt>`[src]

`fn smbhen(&self) -> &Smbhen<Urt>`[src]

`fn stopie(&self) -> &Stopie<Urt>`[src]

`fn tcie(&self) -> &Tcie<Urt>`[src]

`fn txdmaen(&self) -> &Txdmaen<Urt>`[src]

`fn txie(&self) -> &Txie<Urt>`[src]

`fn wupen(&self) -> &Wupen<Urt>`[src]

`impl SI2CCr1<I2C4> for Reg<Srt>`[src]

`fn from_fields(map: SI2CCr1Fields<I2C4>) -> Self`[src]

`fn into_fields(self) -> SI2CCr1Fields<I2C4>`[src]

`fn addrie(&self) -> &Addrie<Srt>`[src]

`fn alerten(&self) -> &Alerten<Srt>`[src]

`fn anfoff(&self) -> &Anfoff<Srt>`[src]

`fn dnf(&self) -> &Dnf<Srt>`[src]

`fn errie(&self) -> &Errie<Srt>`[src]

`fn gcen(&self) -> &Gcen<Srt>`[src]

`fn nackie(&self) -> &Nackie<Srt>`[src]

`fn nostretch(&self) -> &Nostretch<Srt>`[src]

`fn pecen(&self) -> &Pecen<Srt>`[src]

`fn pe(&self) -> &Pe<Srt>`[src]

`fn rxdmaen(&self) -> &Rxdmaen<Srt>`[src]

`fn rxie(&self) -> &Rxie<Srt>`[src]

`fn sbc(&self) -> &Sbc<Srt>`[src]

`fn smbden(&self) -> &Smbden<Srt>`[src]

`fn smbhen(&self) -> &Smbhen<Srt>`[src]

`fn stopie(&self) -> &Stopie<Srt>`[src]

`fn tcie(&self) -> &Tcie<Srt>`[src]

`fn txdmaen(&self) -> &Txdmaen<Srt>`[src]

`fn txie(&self) -> &Txie<Srt>`[src]

`fn wupen(&self) -> &Wupen<Srt>`[src]

`impl CI2CCr1<I2C4> for Reg<Crt>`[src]

`fn from_fields(map: CI2CCr1Fields<I2C4>) -> Self`[src]

`fn into_fields(self) -> CI2CCr1Fields<I2C4>`[src]

`fn addrie(&self) -> &Addrie<Crt>`[src]

`fn alerten(&self) -> &Alerten<Crt>`[src]

`fn anfoff(&self) -> &Anfoff<Crt>`[src]

`fn dnf(&self) -> &Dnf<Crt>`[src]

`fn errie(&self) -> &Errie<Crt>`[src]

`fn gcen(&self) -> &Gcen<Crt>`[src]

`fn nackie(&self) -> &Nackie<Crt>`[src]

`fn nostretch(&self) -> &Nostretch<Crt>`[src]

`fn pecen(&self) -> &Pecen<Crt>`[src]

`fn pe(&self) -> &Pe<Crt>`[src]

`fn rxdmaen(&self) -> &Rxdmaen<Crt>`[src]

`fn rxie(&self) -> &Rxie<Crt>`[src]

`fn sbc(&self) -> &Sbc<Crt>`[src]

`fn smbden(&self) -> &Smbden<Crt>`[src]

`fn smbhen(&self) -> &Smbhen<Crt>`[src]

`fn stopie(&self) -> &Stopie<Crt>`[src]

`fn tcie(&self) -> &Tcie<Crt>`[src]

`fn txdmaen(&self) -> &Txdmaen<Crt>`[src]

`fn txie(&self) -> &Txie<Crt>`[src]

`fn wupen(&self) -> &Wupen<Crt>`[src]

`impl I2CCr2Add10<I2C4> for I2C4`[src]

`type UI2CCr2Add10 = Add10<Urt>`

`type SI2CCr2Add10 = Add10<Srt>`

`type CI2CCr2Add10 = Add10<Crt>`

`impl I2CCr2Autoend<I2C4> for I2C4`[src]

`type UI2CCr2Autoend = Autoend<Urt>`

`type SI2CCr2Autoend = Autoend<Srt>`

`type CI2CCr2Autoend = Autoend<Crt>`

`impl I2CCr2Head10R<I2C4> for I2C4`[src]

`type UI2CCr2Head10R = Head10R<Urt>`

`type SI2CCr2Head10R = Head10R<Srt>`

`type CI2CCr2Head10R = Head10R<Crt>`

`impl I2CCr2Nack<I2C4> for I2C4`[src]

`type UI2CCr2Nack = Nack<Urt>`

`type SI2CCr2Nack = Nack<Srt>`

`type CI2CCr2Nack = Nack<Crt>`

`impl I2CCr2Nbytes<I2C4> for I2C4`[src]

`type UI2CCr2Nbytes = Nbytes<Urt>`

`type SI2CCr2Nbytes = Nbytes<Srt>`

`type CI2CCr2Nbytes = Nbytes<Crt>`

`impl I2CCr2Pecbyte<I2C4> for I2C4`[src]

`type UI2CCr2Pecbyte = Pecbyte<Urt>`

`type SI2CCr2Pecbyte = Pecbyte<Srt>`

`type CI2CCr2Pecbyte = Pecbyte<Crt>`

`impl I2CCr2RdWrn<I2C4> for I2C4`[src]

`type UI2CCr2RdWrn = RdWrn<Urt>`

`type SI2CCr2RdWrn = RdWrn<Srt>`

`type CI2CCr2RdWrn = RdWrn<Crt>`

`impl I2CCr2Reload<I2C4> for I2C4`[src]

`type UI2CCr2Reload = Reload<Urt>`

`type SI2CCr2Reload = Reload<Srt>`

`type CI2CCr2Reload = Reload<Crt>`

`impl I2CCr2Sadd<I2C4> for I2C4`[src]

`type UI2CCr2Sadd = Sadd<Urt>`

`type SI2CCr2Sadd = Sadd<Srt>`

`type CI2CCr2Sadd = Sadd<Crt>`

`impl I2CCr2Start<I2C4> for I2C4`[src]

`type UI2CCr2Start = Start<Urt>`

`type SI2CCr2Start = Start<Srt>`

`type CI2CCr2Start = Start<Crt>`

`impl I2CCr2Stop<I2C4> for I2C4`[src]

`type UI2CCr2Stop = Stop<Urt>`

`type SI2CCr2Stop = Stop<Srt>`

`type CI2CCr2Stop = Stop<Crt>`

`impl I2CCr2<I2C4> for I2C4`[src]

`type I2CCr2Val = Val`

`type UI2CCr2 = Reg<Urt>`

`type SI2CCr2 = Reg<Srt>`

`type CI2CCr2 = Reg<Crt>`

`impl UI2CCr2<I2C4> for Reg<Urt>`[src]

`fn from_fields(map: UI2CCr2Fields<I2C4>) -> Self`[src]

`fn into_fields(self) -> UI2CCr2Fields<I2C4>`[src]

`fn add10(&self) -> &Add10<Urt>`[src]

`fn autoend(&self) -> &Autoend<Urt>`[src]

`fn head10r(&self) -> &Head10R<Urt>`[src]

`fn nack(&self) -> &Nack<Urt>`[src]

`fn nbytes(&self) -> &Nbytes<Urt>`[src]

`fn pecbyte(&self) -> &Pecbyte<Urt>`[src]

`fn rd_wrn(&self) -> &RdWrn<Urt>`[src]

`fn reload(&self) -> &Reload<Urt>`[src]

`fn sadd(&self) -> &Sadd<Urt>`[src]

`fn start(&self) -> &Start<Urt>`[src]

`fn stop(&self) -> &Stop<Urt>`[src]

`impl SI2CCr2<I2C4> for Reg<Srt>`[src]

`fn from_fields(map: SI2CCr2Fields<I2C4>) -> Self`[src]

`fn into_fields(self) -> SI2CCr2Fields<I2C4>`[src]

`fn add10(&self) -> &Add10<Srt>`[src]

`fn autoend(&self) -> &Autoend<Srt>`[src]

`fn head10r(&self) -> &Head10R<Srt>`[src]

`fn nack(&self) -> &Nack<Srt>`[src]

`fn nbytes(&self) -> &Nbytes<Srt>`[src]

`fn pecbyte(&self) -> &Pecbyte<Srt>`[src]

`fn rd_wrn(&self) -> &RdWrn<Srt>`[src]

`fn reload(&self) -> &Reload<Srt>`[src]

`fn sadd(&self) -> &Sadd<Srt>`[src]

`fn start(&self) -> &Start<Srt>`[src]

`fn stop(&self) -> &Stop<Srt>`[src]

`impl CI2CCr2<I2C4> for Reg<Crt>`[src]

`fn from_fields(map: CI2CCr2Fields<I2C4>) -> Self`[src]

`fn into_fields(self) -> CI2CCr2Fields<I2C4>`[src]

`fn add10(&self) -> &Add10<Crt>`[src]

`fn autoend(&self) -> &Autoend<Crt>`[src]

`fn head10r(&self) -> &Head10R<Crt>`[src]

`fn nack(&self) -> &Nack<Crt>`[src]

`fn nbytes(&self) -> &Nbytes<Crt>`[src]

`fn pecbyte(&self) -> &Pecbyte<Crt>`[src]

`fn rd_wrn(&self) -> &RdWrn<Crt>`[src]

`fn reload(&self) -> &Reload<Crt>`[src]

`fn sadd(&self) -> &Sadd<Crt>`[src]

`fn start(&self) -> &Start<Crt>`[src]

`fn stop(&self) -> &Stop<Crt>`[src]

`impl I2COar1Oa1En<I2C4> for I2C4`[src]

`type UI2COar1Oa1En = Oa1En<Urt>`

`type SI2COar1Oa1En = Oa1En<Srt>`

`type CI2COar1Oa1En = Oa1En<Crt>`

`impl I2COar1Oa1Mode<I2C4> for I2C4`[src]

`type UI2COar1Oa1Mode = Oa1Mode<Urt>`

`type SI2COar1Oa1Mode = Oa1Mode<Srt>`

`type CI2COar1Oa1Mode = Oa1Mode<Crt>`

`impl I2COar1Oa1<I2C4> for I2C4`[src]

`type UI2COar1Oa1 = Oa1<Urt>`

`type SI2COar1Oa1 = Oa1<Srt>`

`type CI2COar1Oa1 = Oa1<Crt>`

`impl I2COar1<I2C4> for I2C4`[src]

`type I2COar1Val = Val`

`type UI2COar1 = Reg<Urt>`

`type SI2COar1 = Reg<Srt>`

`type CI2COar1 = Reg<Crt>`

`impl UI2COar1<I2C4> for Reg<Urt>`[src]

`fn from_fields(map: UI2COar1Fields<I2C4>) -> Self`[src]

`fn into_fields(self) -> UI2COar1Fields<I2C4>`[src]

`fn oa1en(&self) -> &Oa1En<Urt>`[src]

`fn oa1mode(&self) -> &Oa1Mode<Urt>`[src]

`fn oa1(&self) -> &Oa1<Urt>`[src]

`impl SI2COar1<I2C4> for Reg<Srt>`[src]

`fn from_fields(map: SI2COar1Fields<I2C4>) -> Self`[src]

`fn into_fields(self) -> SI2COar1Fields<I2C4>`[src]

`fn oa1en(&self) -> &Oa1En<Srt>`[src]

`fn oa1mode(&self) -> &Oa1Mode<Srt>`[src]

`fn oa1(&self) -> &Oa1<Srt>`[src]

`impl CI2COar1<I2C4> for Reg<Crt>`[src]

`fn from_fields(map: CI2COar1Fields<I2C4>) -> Self`[src]

`fn into_fields(self) -> CI2COar1Fields<I2C4>`[src]

`fn oa1en(&self) -> &Oa1En<Crt>`[src]

`fn oa1mode(&self) -> &Oa1Mode<Crt>`[src]

`fn oa1(&self) -> &Oa1<Crt>`[src]

`impl I2COar2Oa2En<I2C4> for I2C4`[src]

`type UI2COar2Oa2En = Oa2En<Urt>`

`type SI2COar2Oa2En = Oa2En<Srt>`

`type CI2COar2Oa2En = Oa2En<Crt>`

`impl I2COar2Oa2Msk<I2C4> for I2C4`[src]

`type UI2COar2Oa2Msk = Oa2Msk<Urt>`

`type SI2COar2Oa2Msk = Oa2Msk<Srt>`

`type CI2COar2Oa2Msk = Oa2Msk<Crt>`

`impl I2COar2Oa2<I2C4> for I2C4`[src]

`type UI2COar2Oa2 = Oa2<Urt>`

`type SI2COar2Oa2 = Oa2<Srt>`

`type CI2COar2Oa2 = Oa2<Crt>`

`impl I2COar2<I2C4> for I2C4`[src]

`type I2COar2Val = Val`

`type UI2COar2 = Reg<Urt>`

`type SI2COar2 = Reg<Srt>`

`type CI2COar2 = Reg<Crt>`

`impl UI2COar2<I2C4> for Reg<Urt>`[src]

`fn from_fields(map: UI2COar2Fields<I2C4>) -> Self`[src]

`fn into_fields(self) -> UI2COar2Fields<I2C4>`[src]

`fn oa2en(&self) -> &Oa2En<Urt>`[src]

`fn oa2msk(&self) -> &Oa2Msk<Urt>`[src]

`fn oa2(&self) -> &Oa2<Urt>`[src]

`impl SI2COar2<I2C4> for Reg<Srt>`[src]

`fn from_fields(map: SI2COar2Fields<I2C4>) -> Self`[src]

`fn into_fields(self) -> SI2COar2Fields<I2C4>`[src]

`fn oa2en(&self) -> &Oa2En<Srt>`[src]

`fn oa2msk(&self) -> &Oa2Msk<Srt>`[src]

`fn oa2(&self) -> &Oa2<Srt>`[src]

`impl CI2COar2<I2C4> for Reg<Crt>`[src]

`fn from_fields(map: CI2COar2Fields<I2C4>) -> Self`[src]

`fn into_fields(self) -> CI2COar2Fields<I2C4>`[src]

`fn oa2en(&self) -> &Oa2En<Crt>`[src]

`fn oa2msk(&self) -> &Oa2Msk<Crt>`[src]

`fn oa2(&self) -> &Oa2<Crt>`[src]

`impl I2CTimingrPresc<I2C4> for I2C4`[src]

`type UI2CTimingrPresc = Presc<Urt>`

`type SI2CTimingrPresc = Presc<Srt>`

`type CI2CTimingrPresc = Presc<Crt>`

`impl I2CTimingrScldel<I2C4> for I2C4`[src]

`type UI2CTimingrScldel = Scldel<Urt>`

`type SI2CTimingrScldel = Scldel<Srt>`

`type CI2CTimingrScldel = Scldel<Crt>`

`impl I2CTimingrSclh<I2C4> for I2C4`[src]

`type UI2CTimingrSclh = Sclh<Urt>`

`type SI2CTimingrSclh = Sclh<Srt>`

`type CI2CTimingrSclh = Sclh<Crt>`

`impl I2CTimingrScll<I2C4> for I2C4`[src]

`type UI2CTimingrScll = Scll<Urt>`

`type SI2CTimingrScll = Scll<Srt>`

`type CI2CTimingrScll = Scll<Crt>`

`impl I2CTimingrSdadel<I2C4> for I2C4`[src]

`type UI2CTimingrSdadel = Sdadel<Urt>`

`type SI2CTimingrSdadel = Sdadel<Srt>`

`type CI2CTimingrSdadel = Sdadel<Crt>`

`impl I2CTimingr<I2C4> for I2C4`[src]

`type I2CTimingrVal = Val`

`type UI2CTimingr = Reg<Urt>`

`type SI2CTimingr = Reg<Srt>`

`type CI2CTimingr = Reg<Crt>`

`impl UI2CTimingr<I2C4> for Reg<Urt>`[src]

`fn from_fields(map: UI2CTimingrFields<I2C4>) -> Self`[src]

`fn into_fields(self) -> UI2CTimingrFields<I2C4>`[src]

`fn presc(&self) -> &Presc<Urt>`[src]

`fn scldel(&self) -> &Scldel<Urt>`[src]

`fn sclh(&self) -> &Sclh<Urt>`[src]

`fn scll(&self) -> &Scll<Urt>`[src]

`fn sdadel(&self) -> &Sdadel<Urt>`[src]

`impl SI2CTimingr<I2C4> for Reg<Srt>`[src]

`fn from_fields(map: SI2CTimingrFields<I2C4>) -> Self`[src]

`fn into_fields(self) -> SI2CTimingrFields<I2C4>`[src]

`fn presc(&self) -> &Presc<Srt>`[src]

`fn scldel(&self) -> &Scldel<Srt>`[src]

`fn sclh(&self) -> &Sclh<Srt>`[src]

`fn scll(&self) -> &Scll<Srt>`[src]

`fn sdadel(&self) -> &Sdadel<Srt>`[src]

`impl CI2CTimingr<I2C4> for Reg<Crt>`[src]

`fn from_fields(map: CI2CTimingrFields<I2C4>) -> Self`[src]

`fn into_fields(self) -> CI2CTimingrFields<I2C4>`[src]

`fn presc(&self) -> &Presc<Crt>`[src]

`fn scldel(&self) -> &Scldel<Crt>`[src]

`fn sclh(&self) -> &Sclh<Crt>`[src]

`fn scll(&self) -> &Scll<Crt>`[src]

`fn sdadel(&self) -> &Sdadel<Crt>`[src]

`impl I2CTimeoutrTexten<I2C4> for I2C4`[src]

`type UI2CTimeoutrTexten = Texten<Urt>`

`type SI2CTimeoutrTexten = Texten<Srt>`

`type CI2CTimeoutrTexten = Texten<Crt>`

`impl I2CTimeoutrTidle<I2C4> for I2C4`[src]

`type UI2CTimeoutrTidle = Tidle<Urt>`

`type SI2CTimeoutrTidle = Tidle<Srt>`

`type CI2CTimeoutrTidle = Tidle<Crt>`

`impl I2CTimeoutrTimeouta<I2C4> for I2C4`[src]

`type UI2CTimeoutrTimeouta = Timeouta<Urt>`

`type SI2CTimeoutrTimeouta = Timeouta<Srt>`

`type CI2CTimeoutrTimeouta = Timeouta<Crt>`

`impl I2CTimeoutrTimeoutb<I2C4> for I2C4`[src]

`type UI2CTimeoutrTimeoutb = Timeoutb<Urt>`

`type SI2CTimeoutrTimeoutb = Timeoutb<Srt>`

`type CI2CTimeoutrTimeoutb = Timeoutb<Crt>`

`impl I2CTimeoutrTimouten<I2C4> for I2C4`[src]

`type UI2CTimeoutrTimouten = Timouten<Urt>`

`type SI2CTimeoutrTimouten = Timouten<Srt>`

`type CI2CTimeoutrTimouten = Timouten<Crt>`

`impl I2CTimeoutr<I2C4> for I2C4`[src]

`type I2CTimeoutrVal = Val`

`type UI2CTimeoutr = Reg<Urt>`

`type SI2CTimeoutr = Reg<Srt>`

`type CI2CTimeoutr = Reg<Crt>`

`impl UI2CTimeoutr<I2C4> for Reg<Urt>`[src]

`fn from_fields(map: UI2CTimeoutrFields<I2C4>) -> Self`[src]

`fn into_fields(self) -> UI2CTimeoutrFields<I2C4>`[src]

`fn texten(&self) -> &Texten<Urt>`[src]

`fn tidle(&self) -> &Tidle<Urt>`[src]

`fn timeouta(&self) -> &Timeouta<Urt>`[src]

`fn timeoutb(&self) -> &Timeoutb<Urt>`[src]

`fn timouten(&self) -> &Timouten<Urt>`[src]

`impl SI2CTimeoutr<I2C4> for Reg<Srt>`[src]

`fn from_fields(map: SI2CTimeoutrFields<I2C4>) -> Self`[src]

`fn into_fields(self) -> SI2CTimeoutrFields<I2C4>`[src]

`fn texten(&self) -> &Texten<Srt>`[src]

`fn tidle(&self) -> &Tidle<Srt>`[src]

`fn timeouta(&self) -> &Timeouta<Srt>`[src]

`fn timeoutb(&self) -> &Timeoutb<Srt>`[src]

`fn timouten(&self) -> &Timouten<Srt>`[src]

`impl CI2CTimeoutr<I2C4> for Reg<Crt>`[src]

`fn from_fields(map: CI2CTimeoutrFields<I2C4>) -> Self`[src]

`fn into_fields(self) -> CI2CTimeoutrFields<I2C4>`[src]

`fn texten(&self) -> &Texten<Crt>`[src]

`fn tidle(&self) -> &Tidle<Crt>`[src]

`fn timeouta(&self) -> &Timeouta<Crt>`[src]

`fn timeoutb(&self) -> &Timeoutb<Crt>`[src]

`fn timouten(&self) -> &Timouten<Crt>`[src]

`impl I2CIsrAddcode<I2C4> for I2C4`[src]

`type UI2CIsrAddcode = Addcode<Urt>`

`type SI2CIsrAddcode = Addcode<Srt>`

`type CI2CIsrAddcode = Addcode<Crt>`

`impl I2CIsrAddr<I2C4> for I2C4`[src]

`type UI2CIsrAddr = Addr<Urt>`

`type SI2CIsrAddr = Addr<Srt>`

`type CI2CIsrAddr = Addr<Crt>`

`impl I2CIsrAlert<I2C4> for I2C4`[src]

`type UI2CIsrAlert = Alert<Urt>`

`type SI2CIsrAlert = Alert<Srt>`

`type CI2CIsrAlert = Alert<Crt>`

`impl I2CIsrArlo<I2C4> for I2C4`[src]

`type UI2CIsrArlo = Arlo<Urt>`

`type SI2CIsrArlo = Arlo<Srt>`

`type CI2CIsrArlo = Arlo<Crt>`

`impl I2CIsrBerr<I2C4> for I2C4`[src]

`type UI2CIsrBerr = Berr<Urt>`

`type SI2CIsrBerr = Berr<Srt>`

`type CI2CIsrBerr = Berr<Crt>`

`impl I2CIsrBusy<I2C4> for I2C4`[src]

`type UI2CIsrBusy = Busy<Urt>`

`type SI2CIsrBusy = Busy<Srt>`

`type CI2CIsrBusy = Busy<Crt>`

`impl I2CIsrDir<I2C4> for I2C4`[src]

`type UI2CIsrDir = Dir<Urt>`

`type SI2CIsrDir = Dir<Srt>`

`type CI2CIsrDir = Dir<Crt>`

`impl I2CIsrNackf<I2C4> for I2C4`[src]

`type UI2CIsrNackf = Nackf<Urt>`

`type SI2CIsrNackf = Nackf<Srt>`

`type CI2CIsrNackf = Nackf<Crt>`

`impl I2CIsrOvr<I2C4> for I2C4`[src]

`type UI2CIsrOvr = Ovr<Urt>`

`type SI2CIsrOvr = Ovr<Srt>`

`type CI2CIsrOvr = Ovr<Crt>`

`impl I2CIsrPecerr<I2C4> for I2C4`[src]

`type UI2CIsrPecerr = Pecerr<Urt>`

`type SI2CIsrPecerr = Pecerr<Srt>`

`type CI2CIsrPecerr = Pecerr<Crt>`

`impl I2CIsrRxne<I2C4> for I2C4`[src]

`type UI2CIsrRxne = Rxne<Urt>`

`type SI2CIsrRxne = Rxne<Srt>`

`type CI2CIsrRxne = Rxne<Crt>`

`impl I2CIsrStopf<I2C4> for I2C4`[src]

`type UI2CIsrStopf = Stopf<Urt>`

`type SI2CIsrStopf = Stopf<Srt>`

`type CI2CIsrStopf = Stopf<Crt>`

`impl I2CIsrTc<I2C4> for I2C4`[src]

`type UI2CIsrTc = Tc<Urt>`

`type SI2CIsrTc = Tc<Srt>`

`type CI2CIsrTc = Tc<Crt>`

`impl I2CIsrTcr<I2C4> for I2C4`[src]

`type UI2CIsrTcr = Tcr<Urt>`

`type SI2CIsrTcr = Tcr<Srt>`

`type CI2CIsrTcr = Tcr<Crt>`

`impl I2CIsrTimeout<I2C4> for I2C4`[src]

`type UI2CIsrTimeout = Timeout<Urt>`

`type SI2CIsrTimeout = Timeout<Srt>`

`type CI2CIsrTimeout = Timeout<Crt>`

`impl I2CIsrTxe<I2C4> for I2C4`[src]

`type UI2CIsrTxe = Txe<Urt>`

`type SI2CIsrTxe = Txe<Srt>`

`type CI2CIsrTxe = Txe<Crt>`

`impl I2CIsrTxis<I2C4> for I2C4`[src]

`type UI2CIsrTxis = Txis<Urt>`

`type SI2CIsrTxis = Txis<Srt>`

`type CI2CIsrTxis = Txis<Crt>`

`impl I2CIsr<I2C4> for I2C4`[src]

`type I2CIsrVal = Val`

`type UI2CIsr = Reg<Urt>`

`type SI2CIsr = Reg<Srt>`

`type CI2CIsr = Reg<Crt>`

`impl UI2CIsr<I2C4> for Reg<Urt>`[src]

`fn from_fields(map: UI2CIsrFields<I2C4>) -> Self`[src]

`fn into_fields(self) -> UI2CIsrFields<I2C4>`[src]

`fn addcode(&self) -> &Addcode<Urt>`[src]

`fn addr(&self) -> &Addr<Urt>`[src]

`fn alert(&self) -> &Alert<Urt>`[src]

`fn arlo(&self) -> &Arlo<Urt>`[src]

`fn berr(&self) -> &Berr<Urt>`[src]

`fn busy(&self) -> &Busy<Urt>`[src]

`fn dir(&self) -> &Dir<Urt>`[src]

`fn nackf(&self) -> &Nackf<Urt>`[src]

`fn ovr(&self) -> &Ovr<Urt>`[src]

`fn pecerr(&self) -> &Pecerr<Urt>`[src]

`fn rxne(&self) -> &Rxne<Urt>`[src]

`fn stopf(&self) -> &Stopf<Urt>`[src]

`fn tcr(&self) -> &Tcr<Urt>`[src]

`fn tc(&self) -> &Tc<Urt>`[src]

`fn timeout(&self) -> &Timeout<Urt>`[src]

`fn txe(&self) -> &Txe<Urt>`[src]

`fn txis(&self) -> &Txis<Urt>`[src]

`impl SI2CIsr<I2C4> for Reg<Srt>`[src]

`fn from_fields(map: SI2CIsrFields<I2C4>) -> Self`[src]

`fn into_fields(self) -> SI2CIsrFields<I2C4>`[src]

`fn addcode(&self) -> &Addcode<Srt>`[src]

`fn addr(&self) -> &Addr<Srt>`[src]

`fn alert(&self) -> &Alert<Srt>`[src]

`fn arlo(&self) -> &Arlo<Srt>`[src]

`fn berr(&self) -> &Berr<Srt>`[src]

`fn busy(&self) -> &Busy<Srt>`[src]

`fn dir(&self) -> &Dir<Srt>`[src]

`fn nackf(&self) -> &Nackf<Srt>`[src]

`fn ovr(&self) -> &Ovr<Srt>`[src]

`fn pecerr(&self) -> &Pecerr<Srt>`[src]

`fn rxne(&self) -> &Rxne<Srt>`[src]

`fn stopf(&self) -> &Stopf<Srt>`[src]

`fn tcr(&self) -> &Tcr<Srt>`[src]

`fn tc(&self) -> &Tc<Srt>`[src]

`fn timeout(&self) -> &Timeout<Srt>`[src]

`fn txe(&self) -> &Txe<Srt>`[src]

`fn txis(&self) -> &Txis<Srt>`[src]

`impl CI2CIsr<I2C4> for Reg<Crt>`[src]

`fn from_fields(map: CI2CIsrFields<I2C4>) -> Self`[src]

`fn into_fields(self) -> CI2CIsrFields<I2C4>`[src]

`fn addcode(&self) -> &Addcode<Crt>`[src]

`fn addr(&self) -> &Addr<Crt>`[src]

`fn alert(&self) -> &Alert<Crt>`[src]

`fn arlo(&self) -> &Arlo<Crt>`[src]

`fn berr(&self) -> &Berr<Crt>`[src]

`fn busy(&self) -> &Busy<Crt>`[src]

`fn dir(&self) -> &Dir<Crt>`[src]

`fn nackf(&self) -> &Nackf<Crt>`[src]

`fn ovr(&self) -> &Ovr<Crt>`[src]

`fn pecerr(&self) -> &Pecerr<Crt>`[src]

`fn rxne(&self) -> &Rxne<Crt>`[src]

`fn stopf(&self) -> &Stopf<Crt>`[src]

`fn tcr(&self) -> &Tcr<Crt>`[src]

`fn tc(&self) -> &Tc<Crt>`[src]

`fn timeout(&self) -> &Timeout<Crt>`[src]

`fn txe(&self) -> &Txe<Crt>`[src]

`fn txis(&self) -> &Txis<Crt>`[src]

`impl I2CIcrAddrcf<I2C4> for I2C4`[src]

`type UI2CIcrAddrcf = Addrcf<Urt>`

`type SI2CIcrAddrcf = Addrcf<Srt>`

`type CI2CIcrAddrcf = Addrcf<Crt>`

`impl I2CIcrAlertcf<I2C4> for I2C4`[src]

`type UI2CIcrAlertcf = Alertcf<Urt>`

`type SI2CIcrAlertcf = Alertcf<Srt>`

`type CI2CIcrAlertcf = Alertcf<Crt>`

`impl I2CIcrArlocf<I2C4> for I2C4`[src]

`type UI2CIcrArlocf = Arlocf<Urt>`

`type SI2CIcrArlocf = Arlocf<Srt>`

`type CI2CIcrArlocf = Arlocf<Crt>`

`impl I2CIcrBerrcf<I2C4> for I2C4`[src]

`type UI2CIcrBerrcf = Berrcf<Urt>`

`type SI2CIcrBerrcf = Berrcf<Srt>`

`type CI2CIcrBerrcf = Berrcf<Crt>`

`impl I2CIcrNackcf<I2C4> for I2C4`[src]

`type UI2CIcrNackcf = Nackcf<Urt>`

`type SI2CIcrNackcf = Nackcf<Srt>`

`type CI2CIcrNackcf = Nackcf<Crt>`

`impl I2CIcrOvrcf<I2C4> for I2C4`[src]

`type UI2CIcrOvrcf = Ovrcf<Urt>`

`type SI2CIcrOvrcf = Ovrcf<Srt>`

`type CI2CIcrOvrcf = Ovrcf<Crt>`

`impl I2CIcrPeccf<I2C4> for I2C4`[src]

`type UI2CIcrPeccf = Peccf<Urt>`

`type SI2CIcrPeccf = Peccf<Srt>`

`type CI2CIcrPeccf = Peccf<Crt>`

`impl I2CIcrStopcf<I2C4> for I2C4`[src]

`type UI2CIcrStopcf = Stopcf<Urt>`

`type SI2CIcrStopcf = Stopcf<Srt>`

`type CI2CIcrStopcf = Stopcf<Crt>`

`impl I2CIcrTimoutcf<I2C4> for I2C4`[src]

`type UI2CIcrTimoutcf = Timoutcf<Urt>`

`type SI2CIcrTimoutcf = Timoutcf<Srt>`

`type CI2CIcrTimoutcf = Timoutcf<Crt>`

`impl I2CIcr<I2C4> for I2C4`[src]

`type I2CIcrVal = Val`

`type UI2CIcr = Reg<Urt>`

`type SI2CIcr = Reg<Srt>`

`type CI2CIcr = Reg<Crt>`

`impl UI2CIcr<I2C4> for Reg<Urt>`[src]

`fn from_fields(map: UI2CIcrFields<I2C4>) -> Self`[src]

`fn into_fields(self) -> UI2CIcrFields<I2C4>`[src]

`fn addrcf(&self) -> &Addrcf<Urt>`[src]

`fn alertcf(&self) -> &Alertcf<Urt>`[src]

`fn arlocf(&self) -> &Arlocf<Urt>`[src]

`fn berrcf(&self) -> &Berrcf<Urt>`[src]

`fn nackcf(&self) -> &Nackcf<Urt>`[src]

`fn ovrcf(&self) -> &Ovrcf<Urt>`[src]

`fn peccf(&self) -> &Peccf<Urt>`[src]

`fn stopcf(&self) -> &Stopcf<Urt>`[src]

`fn timoutcf(&self) -> &Timoutcf<Urt>`[src]

`impl SI2CIcr<I2C4> for Reg<Srt>`[src]

`fn from_fields(map: SI2CIcrFields<I2C4>) -> Self`[src]

`fn into_fields(self) -> SI2CIcrFields<I2C4>`[src]

`fn addrcf(&self) -> &Addrcf<Srt>`[src]

`fn alertcf(&self) -> &Alertcf<Srt>`[src]

`fn arlocf(&self) -> &Arlocf<Srt>`[src]

`fn berrcf(&self) -> &Berrcf<Srt>`[src]

`fn nackcf(&self) -> &Nackcf<Srt>`[src]

`fn ovrcf(&self) -> &Ovrcf<Srt>`[src]

`fn peccf(&self) -> &Peccf<Srt>`[src]

`fn stopcf(&self) -> &Stopcf<Srt>`[src]

`fn timoutcf(&self) -> &Timoutcf<Srt>`[src]

`impl CI2CIcr<I2C4> for Reg<Crt>`[src]

`fn from_fields(map: CI2CIcrFields<I2C4>) -> Self`[src]

`fn into_fields(self) -> CI2CIcrFields<I2C4>`[src]

`fn addrcf(&self) -> &Addrcf<Crt>`[src]

`fn alertcf(&self) -> &Alertcf<Crt>`[src]

`fn arlocf(&self) -> &Arlocf<Crt>`[src]

`fn berrcf(&self) -> &Berrcf<Crt>`[src]

`fn nackcf(&self) -> &Nackcf<Crt>`[src]

`fn ovrcf(&self) -> &Ovrcf<Crt>`[src]

`fn peccf(&self) -> &Peccf<Crt>`[src]

`fn stopcf(&self) -> &Stopcf<Crt>`[src]

`fn timoutcf(&self) -> &Timoutcf<Crt>`[src]

`impl I2CPecrPec<I2C4> for I2C4`[src]

`type UI2CPecrPec = Pec<Urt>`

`type SI2CPecrPec = Pec<Srt>`

`type CI2CPecrPec = Pec<Crt>`

`impl I2CPecr<I2C4> for I2C4`[src]

`type I2CPecrVal = Val`

`type UI2CPecr = Reg<Urt>`

`type SI2CPecr = Reg<Srt>`

`type CI2CPecr = Reg<Crt>`

`impl UI2CPecr<I2C4> for Reg<Urt>`[src]

`fn from_fields(map: UI2CPecrFields<I2C4>) -> Self`[src]

`fn into_fields(self) -> UI2CPecrFields<I2C4>`[src]

`fn pec(&self) -> &Pec<Urt>`[src]

`impl SI2CPecr<I2C4> for Reg<Srt>`[src]

`fn from_fields(map: SI2CPecrFields<I2C4>) -> Self`[src]

`fn into_fields(self) -> SI2CPecrFields<I2C4>`[src]

`fn pec(&self) -> &Pec<Srt>`[src]

`impl CI2CPecr<I2C4> for Reg<Crt>`[src]

`fn from_fields(map: CI2CPecrFields<I2C4>) -> Self`[src]

`fn into_fields(self) -> CI2CPecrFields<I2C4>`[src]

`fn pec(&self) -> &Pec<Crt>`[src]

`impl I2CRxdrRxdata<I2C4> for I2C4`[src]

`type UI2CRxdrRxdata = Rxdata<Urt>`

`type SI2CRxdrRxdata = Rxdata<Srt>`

`type CI2CRxdrRxdata = Rxdata<Crt>`

`impl I2CRxdr<I2C4> for I2C4`[src]

`type I2CRxdrVal = Val`

`type UI2CRxdr = Reg<Urt>`

`type SI2CRxdr = Reg<Srt>`

`type CI2CRxdr = Reg<Crt>`

`impl UI2CRxdr<I2C4> for Reg<Urt>`[src]

`fn from_fields(map: UI2CRxdrFields<I2C4>) -> Self`[src]

`fn into_fields(self) -> UI2CRxdrFields<I2C4>`[src]

`fn rxdata(&self) -> &Rxdata<Urt>`[src]

`impl SI2CRxdr<I2C4> for Reg<Srt>`[src]

`fn from_fields(map: SI2CRxdrFields<I2C4>) -> Self`[src]

`fn into_fields(self) -> SI2CRxdrFields<I2C4>`[src]

`fn rxdata(&self) -> &Rxdata<Srt>`[src]

`impl CI2CRxdr<I2C4> for Reg<Crt>`[src]

`fn from_fields(map: CI2CRxdrFields<I2C4>) -> Self`[src]

`fn into_fields(self) -> CI2CRxdrFields<I2C4>`[src]

`fn rxdata(&self) -> &Rxdata<Crt>`[src]

`impl I2CTxdrTxdata<I2C4> for I2C4`[src]

`type UI2CTxdrTxdata = Txdata<Urt>`

`type SI2CTxdrTxdata = Txdata<Srt>`

`type CI2CTxdrTxdata = Txdata<Crt>`

`impl I2CTxdr<I2C4> for I2C4`[src]

`type I2CTxdrVal = Val`

`type UI2CTxdr = Reg<Urt>`

`type SI2CTxdr = Reg<Srt>`

`type CI2CTxdr = Reg<Crt>`

`impl UI2CTxdr<I2C4> for Reg<Urt>`[src]

`fn from_fields(map: UI2CTxdrFields<I2C4>) -> Self`[src]

`fn into_fields(self) -> UI2CTxdrFields<I2C4>`[src]

`fn txdata(&self) -> &Txdata<Urt>`[src]

`impl SI2CTxdr<I2C4> for Reg<Srt>`[src]

`fn from_fields(map: SI2CTxdrFields<I2C4>) -> Self`[src]

`fn into_fields(self) -> SI2CTxdrFields<I2C4>`[src]

`fn txdata(&self) -> &Txdata<Srt>`[src]

`impl CI2CTxdr<I2C4> for Reg<Crt>`[src]

`fn from_fields(map: CI2CTxdrFields<I2C4>) -> Self`[src]

`fn into_fields(self) -> CI2CTxdrFields<I2C4>`[src]

`fn txdata(&self) -> &Txdata<Crt>`[src]

`impl I2CMap for I2C4`[src]

Auto Trait Implementations

`impl Unpin for I2C4`

`impl Send for I2C4`

`impl Sync for I2C4`

Blanket Implementations

`impl<T> From<T> for T`[src]

`fn from(t: T) -> T`[src]

`impl<T, U> TryFrom for T where U: Into<T>,` [src]

`type Error = Infallible`

The type returned in the event of a conversion error.

`fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>`[src]

`impl<T, U> Into for T where U: From<T>,` [src]

`fn into(self) -> U`[src]

`impl<T, U> TryInto for T where U: TryFrom<T>,` [src]

`type Error = >::Error`

The type returned in the event of a conversion error.

`fn try_into(self) -> Result<U, >::Error>`[src]

`impl<T> Borrow<T> for T where T: ?Sized,` [src]

`fn borrow(&self) -> &T`[src]

`impl<T> BorrowMut<T> for T where T: ?Sized,` [src]

`fn borrow_mut(&mut self) -> &mut T`[src]

`impl<T> Any for T where T: 'static + ?Sized,` [src]

`fn type_id(&self) -> TypeId`[src]

[−][src]Struct drone_stm32_map_periph_i2c::I2C4

Trait Implementations

impl RccBusenrI2Cen for I2C4[src]

type URccBusenrI2Cen = I2C4En<Urt>

type SRccBusenrI2Cen = I2C4En<Srt>

type CRccBusenrI2Cen = I2C4En<Crt>

impl RccBusenr for I2C4[src]

type RccBusenrVal = Val

type URccBusenr = Reg<Urt>

type SRccBusenr = Reg<Srt>

type CRccBusenr = Reg<Crt>

impl RccBusrstrI2Crst for I2C4[src]

type URccBusrstrI2Crst = I2C4Rst<Urt>

type SRccBusrstrI2Crst = I2C4Rst<Srt>

type CRccBusrstrI2Crst = I2C4Rst<Crt>

impl RccBusrstr for I2C4[src]

type RccBusrstrVal = Val

type URccBusrstr = Reg<Urt>

type SRccBusrstr = Reg<Srt>

type CRccBusrstr = Reg<Crt>

impl RccBussmenrI2Csmen for I2C4[src]

type URccBussmenrI2Csmen = I2C4Smen<Urt>

type SRccBussmenrI2Csmen = I2C4Smen<Srt>

type CRccBussmenrI2Csmen = I2C4Smen<Crt>

impl RccBussmenr for I2C4[src]

type RccBussmenrVal = Val

type URccBussmenr = Reg<Urt>

type SRccBussmenr = Reg<Srt>

type CRccBussmenr = Reg<Crt>

impl RccCciprI2Csel for I2C4[src]

type URccCciprI2Csel = I2C4Sel<Urt>

type SRccCciprI2Csel = I2C4Sel<Srt>

type CRccCciprI2Csel = I2C4Sel<Crt>

impl RccCcipr for I2C4[src]

type RccCciprVal = Val

type URccCcipr = Reg<Urt>

type SRccCcipr = Reg<Srt>

type CRccCcipr = Reg<Crt>

impl I2CCr1Addrie<I2C4> for I2C4[src]

type UI2CCr1Addrie = Addrie<Urt>

type SI2CCr1Addrie = Addrie<Srt>

type CI2CCr1Addrie = Addrie<Crt>

impl I2CCr1Alerten<I2C4> for I2C4[src]

type UI2CCr1Alerten = Alerten<Urt>

type SI2CCr1Alerten = Alerten<Srt>

type CI2CCr1Alerten = Alerten<Crt>

impl I2CCr1Anfoff<I2C4> for I2C4[src]

type UI2CCr1Anfoff = Anfoff<Urt>

type SI2CCr1Anfoff = Anfoff<Srt>

type CI2CCr1Anfoff = Anfoff<Crt>

impl I2CCr1Dnf<I2C4> for I2C4[src]

type UI2CCr1Dnf = Dnf<Urt>

type SI2CCr1Dnf = Dnf<Srt>

type CI2CCr1Dnf = Dnf<Crt>

impl I2CCr1Errie<I2C4> for I2C4[src]

type UI2CCr1Errie = Errie<Urt>

type SI2CCr1Errie = Errie<Srt>

type CI2CCr1Errie = Errie<Crt>

impl I2CCr1Gcen<I2C4> for I2C4[src]

type UI2CCr1Gcen = Gcen<Urt>

type SI2CCr1Gcen = Gcen<Srt>

type CI2CCr1Gcen = Gcen<Crt>

impl I2CCr1Nackie<I2C4> for I2C4[src]

type UI2CCr1Nackie = Nackie<Urt>

type SI2CCr1Nackie = Nackie<Srt>

type CI2CCr1Nackie = Nackie<Crt>

impl I2CCr1Nostretch<I2C4> for I2C4[src]

type UI2CCr1Nostretch = Nostretch<Urt>

type SI2CCr1Nostretch = Nostretch<Srt>

type CI2CCr1Nostretch = Nostretch<Crt>

impl I2CCr1Pecen<I2C4> for I2C4[src]

type UI2CCr1Pecen = Pecen<Urt>

type SI2CCr1Pecen = Pecen<Srt>

type CI2CCr1Pecen = Pecen<Crt>

impl I2CCr1Pe<I2C4> for I2C4[src]

type UI2CCr1Pe = Pe<Urt>

type SI2CCr1Pe = Pe<Srt>

type CI2CCr1Pe = Pe<Crt>

impl I2CCr1Rxdmaen<I2C4> for I2C4[src]

type UI2CCr1Rxdmaen = Rxdmaen<Urt>

`impl RccBusenrI2Cen for I2C4`[src]

`type URccBusenrI2Cen = I2C4En<Urt>`

`type SRccBusenrI2Cen = I2C4En<Srt>`

`type CRccBusenrI2Cen = I2C4En<Crt>`

`impl RccBusenr for I2C4`[src]

`type RccBusenrVal = Val`

`type URccBusenr = Reg<Urt>`

`type SRccBusenr = Reg<Srt>`

`type CRccBusenr = Reg<Crt>`

`impl RccBusrstrI2Crst for I2C4`[src]

`type URccBusrstrI2Crst = I2C4Rst<Urt>`

`type SRccBusrstrI2Crst = I2C4Rst<Srt>`

`type CRccBusrstrI2Crst = I2C4Rst<Crt>`

`impl RccBusrstr for I2C4`[src]

`type RccBusrstrVal = Val`

`type URccBusrstr = Reg<Urt>`

`type SRccBusrstr = Reg<Srt>`

`type CRccBusrstr = Reg<Crt>`

`impl RccBussmenrI2Csmen for I2C4`[src]

`type URccBussmenrI2Csmen = I2C4Smen<Urt>`

`type SRccBussmenrI2Csmen = I2C4Smen<Srt>`

`type CRccBussmenrI2Csmen = I2C4Smen<Crt>`

`impl RccBussmenr for I2C4`[src]

`type RccBussmenrVal = Val`

`type URccBussmenr = Reg<Urt>`

`type SRccBussmenr = Reg<Srt>`

`type CRccBussmenr = Reg<Crt>`

`impl RccCciprI2Csel for I2C4`[src]

`type URccCciprI2Csel = I2C4Sel<Urt>`

`type SRccCciprI2Csel = I2C4Sel<Srt>`

`type CRccCciprI2Csel = I2C4Sel<Crt>`

`impl RccCcipr for I2C4`[src]

`type RccCciprVal = Val`

`type URccCcipr = Reg<Urt>`

`type SRccCcipr = Reg<Srt>`

`type CRccCcipr = Reg<Crt>`

`impl I2CCr1Addrie<I2C4> for I2C4`[src]

`type UI2CCr1Addrie = Addrie<Urt>`

`type SI2CCr1Addrie = Addrie<Srt>`

`type CI2CCr1Addrie = Addrie<Crt>`

`impl I2CCr1Alerten<I2C4> for I2C4`[src]

`type UI2CCr1Alerten = Alerten<Urt>`

`type SI2CCr1Alerten = Alerten<Srt>`

`type CI2CCr1Alerten = Alerten<Crt>`

`impl I2CCr1Anfoff<I2C4> for I2C4`[src]

`type UI2CCr1Anfoff = Anfoff<Urt>`

`type SI2CCr1Anfoff = Anfoff<Srt>`

`type CI2CCr1Anfoff = Anfoff<Crt>`

`impl I2CCr1Dnf<I2C4> for I2C4`[src]

`type UI2CCr1Dnf = Dnf<Urt>`

`type SI2CCr1Dnf = Dnf<Srt>`

`type CI2CCr1Dnf = Dnf<Crt>`

`impl I2CCr1Errie<I2C4> for I2C4`[src]

`type UI2CCr1Errie = Errie<Urt>`

`type SI2CCr1Errie = Errie<Srt>`

`type CI2CCr1Errie = Errie<Crt>`

`impl I2CCr1Gcen<I2C4> for I2C4`[src]

`type UI2CCr1Gcen = Gcen<Urt>`

`type SI2CCr1Gcen = Gcen<Srt>`

`type CI2CCr1Gcen = Gcen<Crt>`

`impl I2CCr1Nackie<I2C4> for I2C4`[src]

`type UI2CCr1Nackie = Nackie<Urt>`

`type SI2CCr1Nackie = Nackie<Srt>`

`type CI2CCr1Nackie = Nackie<Crt>`

`impl I2CCr1Nostretch<I2C4> for I2C4`[src]

`type UI2CCr1Nostretch = Nostretch<Urt>`

`type SI2CCr1Nostretch = Nostretch<Srt>`

`type CI2CCr1Nostretch = Nostretch<Crt>`

`impl I2CCr1Pecen<I2C4> for I2C4`[src]

`type UI2CCr1Pecen = Pecen<Urt>`

`type SI2CCr1Pecen = Pecen<Srt>`

`type CI2CCr1Pecen = Pecen<Crt>`

`impl I2CCr1Pe<I2C4> for I2C4`[src]

`type UI2CCr1Pe = Pe<Urt>`

`type SI2CCr1Pe = Pe<Srt>`

`type CI2CCr1Pe = Pe<Crt>`

`impl I2CCr1Rxdmaen<I2C4> for I2C4`[src]

`type UI2CCr1Rxdmaen = Rxdmaen<Urt>`

`type SI2CCr1Rxdmaen = Rxdmaen<Srt>`

`type CI2CCr1Rxdmaen = Rxdmaen<Crt>`