[−][src]Struct drone_stm32_map_periph_adc::Adc1

pub struct Adc1(_);

ADC1 peripheral variant.

Trait Implementations

`impl RccBusenrAdcen for Adc1`[src]

`type URccBusenrAdcen = Adcen<Urt>`

`type SRccBusenrAdcen = Adcen<Srt>`

`type CRccBusenrAdcen = Adcen<Crt>`

`impl RccBusenr for Adc1`[src]

`type RccBusenrVal = Val`

`type URccBusenr = Reg<Urt>`

`type SRccBusenr = Reg<Srt>`

`type CRccBusenr = Reg<Crt>`

`impl RccBusrstrAdcrst for Adc1`[src]

`type URccBusrstrAdcrst = Adcrst<Urt>`

`type SRccBusrstrAdcrst = Adcrst<Srt>`

`type CRccBusrstrAdcrst = Adcrst<Crt>`

`impl RccBusrstr for Adc1`[src]

`type RccBusrstrVal = Val`

`type URccBusrstr = Reg<Urt>`

`type SRccBusrstr = Reg<Srt>`

`type CRccBusrstr = Reg<Crt>`

`impl RccBussmenrAdcsmen for Adc1`[src]

`type URccBussmenrAdcsmen = Adcsmen<Urt>`

`type SRccBussmenrAdcsmen = Adcsmen<Srt>`

`type CRccBussmenrAdcsmen = Adcsmen<Crt>`

`impl RccBussmenr for Adc1`[src]

`type RccBussmenrVal = Val`

`type URccBussmenr = Reg<Urt>`

`type SRccBussmenr = Reg<Srt>`

`type CRccBussmenr = Reg<Crt>`

`impl RccCciprAdcsel for Adc1`[src]

`type URccCciprAdcsel = Adcsel<Urt>`

`type SRccCciprAdcsel = Adcsel<Srt>`

`type CRccCciprAdcsel = Adcsel<Crt>`

`impl RccCcipr for Adc1`[src]

`type RccCciprVal = Val`

`type URccCcipr = Reg<Urt>`

`type SRccCcipr = Reg<Srt>`

`type CRccCcipr = Reg<Crt>`

`impl AdcIsrAdrdy<Adc1> for Adc1`[src]

`type UAdcIsrAdrdy = Adrdy<Urt>`

`type SAdcIsrAdrdy = Adrdy<Srt>`

`type CAdcIsrAdrdy = Adrdy<Crt>`

`impl AdcIsrAwd1<Adc1> for Adc1`[src]

`type UAdcIsrAwd1 = Awd1<Urt>`

`type SAdcIsrAwd1 = Awd1<Srt>`

`type CAdcIsrAwd1 = Awd1<Crt>`

`impl AdcIsrAwd2<Adc1> for Adc1`[src]

`type UAdcIsrAwd2 = Awd2<Urt>`

`type SAdcIsrAwd2 = Awd2<Srt>`

`type CAdcIsrAwd2 = Awd2<Crt>`

`impl AdcIsrAwd3<Adc1> for Adc1`[src]

`type UAdcIsrAwd3 = Awd3<Urt>`

`type SAdcIsrAwd3 = Awd3<Srt>`

`type CAdcIsrAwd3 = Awd3<Crt>`

`impl AdcIsrEoc<Adc1> for Adc1`[src]

`type UAdcIsrEoc = Eoc<Urt>`

`type SAdcIsrEoc = Eoc<Srt>`

`type CAdcIsrEoc = Eoc<Crt>`

`impl AdcIsrEosmp<Adc1> for Adc1`[src]

`type UAdcIsrEosmp = Eosmp<Urt>`

`type SAdcIsrEosmp = Eosmp<Srt>`

`type CAdcIsrEosmp = Eosmp<Crt>`

`impl AdcIsrEos<Adc1> for Adc1`[src]

`type UAdcIsrEos = Eos<Urt>`

`type SAdcIsrEos = Eos<Srt>`

`type CAdcIsrEos = Eos<Crt>`

`impl AdcIsrJeoc<Adc1> for Adc1`[src]

`type UAdcIsrJeoc = Jeoc<Urt>`

`type SAdcIsrJeoc = Jeoc<Srt>`

`type CAdcIsrJeoc = Jeoc<Crt>`

`impl AdcIsrJeos<Adc1> for Adc1`[src]

`type UAdcIsrJeos = Jeos<Urt>`

`type SAdcIsrJeos = Jeos<Srt>`

`type CAdcIsrJeos = Jeos<Crt>`

`impl AdcIsrJqovf<Adc1> for Adc1`[src]

`type UAdcIsrJqovf = Jqovf<Urt>`

`type SAdcIsrJqovf = Jqovf<Srt>`

`type CAdcIsrJqovf = Jqovf<Crt>`

`impl AdcIsrOvr<Adc1> for Adc1`[src]

`type UAdcIsrOvr = Ovr<Urt>`

`type SAdcIsrOvr = Ovr<Srt>`

`type CAdcIsrOvr = Ovr<Crt>`

`impl AdcIsr<Adc1> for Adc1`[src]

`type AdcIsrVal = Val`

`type UAdcIsr = Reg<Urt>`

`type SAdcIsr = Reg<Srt>`

`type CAdcIsr = Reg<Crt>`

`impl UAdcIsr<Adc1> for Reg<Urt>`[src]

`fn from_fields(map: UAdcIsrFields<Adc1>) -> Self`[src]

`fn into_fields(self) -> UAdcIsrFields<Adc1>`[src]

`fn adrdy(&self) -> &Adrdy<Urt>`[src]

`fn awd1(&self) -> &Awd1<Urt>`[src]

`fn awd2(&self) -> &Awd2<Urt>`[src]

`fn awd3(&self) -> &Awd3<Urt>`[src]

`fn eoc(&self) -> &Eoc<Urt>`[src]

`fn eosmp(&self) -> &Eosmp<Urt>`[src]

`fn eos(&self) -> &Eos<Urt>`[src]

`fn jeoc(&self) -> &Jeoc<Urt>`[src]

`fn jeos(&self) -> &Jeos<Urt>`[src]

`fn jqovf(&self) -> &Jqovf<Urt>`[src]

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

`impl SAdcIsr<Adc1> for Reg<Srt>`[src]

`fn from_fields(map: SAdcIsrFields<Adc1>) -> Self`[src]

`fn into_fields(self) -> SAdcIsrFields<Adc1>`[src]

`fn adrdy(&self) -> &Adrdy<Srt>`[src]

`fn awd1(&self) -> &Awd1<Srt>`[src]

`fn awd2(&self) -> &Awd2<Srt>`[src]

`fn awd3(&self) -> &Awd3<Srt>`[src]

`fn eoc(&self) -> &Eoc<Srt>`[src]

`fn eosmp(&self) -> &Eosmp<Srt>`[src]

`fn eos(&self) -> &Eos<Srt>`[src]

`fn jeoc(&self) -> &Jeoc<Srt>`[src]

`fn jeos(&self) -> &Jeos<Srt>`[src]

`fn jqovf(&self) -> &Jqovf<Srt>`[src]

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

`impl CAdcIsr<Adc1> for Reg<Crt>`[src]

`fn from_fields(map: CAdcIsrFields<Adc1>) -> Self`[src]

`fn into_fields(self) -> CAdcIsrFields<Adc1>`[src]

`fn adrdy(&self) -> &Adrdy<Crt>`[src]

`fn awd1(&self) -> &Awd1<Crt>`[src]

`fn awd2(&self) -> &Awd2<Crt>`[src]

`fn awd3(&self) -> &Awd3<Crt>`[src]

`fn eoc(&self) -> &Eoc<Crt>`[src]

`fn eosmp(&self) -> &Eosmp<Crt>`[src]

`fn eos(&self) -> &Eos<Crt>`[src]

`fn jeoc(&self) -> &Jeoc<Crt>`[src]

`fn jeos(&self) -> &Jeos<Crt>`[src]

`fn jqovf(&self) -> &Jqovf<Crt>`[src]

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

`impl AdcIerAdrdyie<Adc1> for Adc1`[src]

`type UAdcIerAdrdyie = Adrdyie<Urt>`

`type SAdcIerAdrdyie = Adrdyie<Srt>`

`type CAdcIerAdrdyie = Adrdyie<Crt>`

`impl AdcIerAwd1Ie<Adc1> for Adc1`[src]

`type UAdcIerAwd1Ie = Awd1Ie<Urt>`

`type SAdcIerAwd1Ie = Awd1Ie<Srt>`

`type CAdcIerAwd1Ie = Awd1Ie<Crt>`

`impl AdcIerAwd2Ie<Adc1> for Adc1`[src]

`type UAdcIerAwd2Ie = Awd2Ie<Urt>`

`type SAdcIerAwd2Ie = Awd2Ie<Srt>`

`type CAdcIerAwd2Ie = Awd2Ie<Crt>`

`impl AdcIerAwd3Ie<Adc1> for Adc1`[src]

`type UAdcIerAwd3Ie = Awd3Ie<Urt>`

`type SAdcIerAwd3Ie = Awd3Ie<Srt>`

`type CAdcIerAwd3Ie = Awd3Ie<Crt>`

`impl AdcIerEocie<Adc1> for Adc1`[src]

`type UAdcIerEocie = Eocie<Urt>`

`type SAdcIerEocie = Eocie<Srt>`

`type CAdcIerEocie = Eocie<Crt>`

`impl AdcIerEosie<Adc1> for Adc1`[src]

`type UAdcIerEosie = Eosie<Urt>`

`type SAdcIerEosie = Eosie<Srt>`

`type CAdcIerEosie = Eosie<Crt>`

`impl AdcIerEosmpie<Adc1> for Adc1`[src]

`type UAdcIerEosmpie = Eosmpie<Urt>`

`type SAdcIerEosmpie = Eosmpie<Srt>`

`type CAdcIerEosmpie = Eosmpie<Crt>`

`impl AdcIerJeocie<Adc1> for Adc1`[src]

`type UAdcIerJeocie = Jeocie<Urt>`

`type SAdcIerJeocie = Jeocie<Srt>`

`type CAdcIerJeocie = Jeocie<Crt>`

`impl AdcIerJeosie<Adc1> for Adc1`[src]

`type UAdcIerJeosie = Jeosie<Urt>`

`type SAdcIerJeosie = Jeosie<Srt>`

`type CAdcIerJeosie = Jeosie<Crt>`

`impl AdcIerJqovfie<Adc1> for Adc1`[src]

`type UAdcIerJqovfie = Jqovfie<Urt>`

`type SAdcIerJqovfie = Jqovfie<Srt>`

`type CAdcIerJqovfie = Jqovfie<Crt>`

`impl AdcIerOvrie<Adc1> for Adc1`[src]

`type UAdcIerOvrie = Ovrie<Urt>`

`type SAdcIerOvrie = Ovrie<Srt>`

`type CAdcIerOvrie = Ovrie<Crt>`

`impl AdcIer<Adc1> for Adc1`[src]

`type AdcIerVal = Val`

`type UAdcIer = Reg<Urt>`

`type SAdcIer = Reg<Srt>`

`type CAdcIer = Reg<Crt>`

`impl UAdcIer<Adc1> for Reg<Urt>`[src]

`fn from_fields(map: UAdcIerFields<Adc1>) -> Self`[src]

`fn into_fields(self) -> UAdcIerFields<Adc1>`[src]

`fn adrdyie(&self) -> &Adrdyie<Urt>`[src]

`fn awd1ie(&self) -> &Awd1Ie<Urt>`[src]

`fn awd2ie(&self) -> &Awd2Ie<Urt>`[src]

`fn awd3ie(&self) -> &Awd3Ie<Urt>`[src]

`fn eocie(&self) -> &Eocie<Urt>`[src]

`fn eosie(&self) -> &Eosie<Urt>`[src]

`fn eosmpie(&self) -> &Eosmpie<Urt>`[src]

`fn jeocie(&self) -> &Jeocie<Urt>`[src]

`fn jeosie(&self) -> &Jeosie<Urt>`[src]

`fn jqovfie(&self) -> &Jqovfie<Urt>`[src]

`fn ovrie(&self) -> &Ovrie<Urt>`[src]

`impl SAdcIer<Adc1> for Reg<Srt>`[src]

`fn from_fields(map: SAdcIerFields<Adc1>) -> Self`[src]

`fn into_fields(self) -> SAdcIerFields<Adc1>`[src]

`fn adrdyie(&self) -> &Adrdyie<Srt>`[src]

`fn awd1ie(&self) -> &Awd1Ie<Srt>`[src]

`fn awd2ie(&self) -> &Awd2Ie<Srt>`[src]

`fn awd3ie(&self) -> &Awd3Ie<Srt>`[src]

`fn eocie(&self) -> &Eocie<Srt>`[src]

`fn eosie(&self) -> &Eosie<Srt>`[src]

`fn eosmpie(&self) -> &Eosmpie<Srt>`[src]

`fn jeocie(&self) -> &Jeocie<Srt>`[src]

`fn jeosie(&self) -> &Jeosie<Srt>`[src]

`fn jqovfie(&self) -> &Jqovfie<Srt>`[src]

`fn ovrie(&self) -> &Ovrie<Srt>`[src]

`impl CAdcIer<Adc1> for Reg<Crt>`[src]

`fn from_fields(map: CAdcIerFields<Adc1>) -> Self`[src]

`fn into_fields(self) -> CAdcIerFields<Adc1>`[src]

`fn adrdyie(&self) -> &Adrdyie<Crt>`[src]

`fn awd1ie(&self) -> &Awd1Ie<Crt>`[src]

`fn awd2ie(&self) -> &Awd2Ie<Crt>`[src]

`fn awd3ie(&self) -> &Awd3Ie<Crt>`[src]

`fn eocie(&self) -> &Eocie<Crt>`[src]

`fn eosie(&self) -> &Eosie<Crt>`[src]

`fn eosmpie(&self) -> &Eosmpie<Crt>`[src]

`fn jeocie(&self) -> &Jeocie<Crt>`[src]

`fn jeosie(&self) -> &Jeosie<Crt>`[src]

`fn jqovfie(&self) -> &Jqovfie<Crt>`[src]

`fn ovrie(&self) -> &Ovrie<Crt>`[src]

`impl AdcCrAdcaldif<Adc1> for Adc1`[src]

`type UAdcCrAdcaldif = Adcaldif<Urt>`

`type SAdcCrAdcaldif = Adcaldif<Srt>`

`type CAdcCrAdcaldif = Adcaldif<Crt>`

`impl AdcCrAdcal<Adc1> for Adc1`[src]

`type UAdcCrAdcal = Adcal<Urt>`

`type SAdcCrAdcal = Adcal<Srt>`

`type CAdcCrAdcal = Adcal<Crt>`

`impl AdcCrAddis<Adc1> for Adc1`[src]

`type UAdcCrAddis = Addis<Urt>`

`type SAdcCrAddis = Addis<Srt>`

`type CAdcCrAddis = Addis<Crt>`

`impl AdcCrAden<Adc1> for Adc1`[src]

`type UAdcCrAden = Aden<Urt>`

`type SAdcCrAden = Aden<Srt>`

`type CAdcCrAden = Aden<Crt>`

`impl AdcCrAdstart<Adc1> for Adc1`[src]

`type UAdcCrAdstart = Adstart<Urt>`

`type SAdcCrAdstart = Adstart<Srt>`

`type CAdcCrAdstart = Adstart<Crt>`

`impl AdcCrAdstp<Adc1> for Adc1`[src]

`type UAdcCrAdstp = Adstp<Urt>`

`type SAdcCrAdstp = Adstp<Srt>`

`type CAdcCrAdstp = Adstp<Crt>`

`impl AdcCrAdvregen<Adc1> for Adc1`[src]

`type UAdcCrAdvregen = Advregen<Urt>`

`type SAdcCrAdvregen = Advregen<Srt>`

`type CAdcCrAdvregen = Advregen<Crt>`

`impl AdcCrDeeppwd<Adc1> for Adc1`[src]

`type UAdcCrDeeppwd = Deeppwd<Urt>`

`type SAdcCrDeeppwd = Deeppwd<Srt>`

`type CAdcCrDeeppwd = Deeppwd<Crt>`

`impl AdcCrJadstart<Adc1> for Adc1`[src]

`type UAdcCrJadstart = Jadstart<Urt>`

`type SAdcCrJadstart = Jadstart<Srt>`

`type CAdcCrJadstart = Jadstart<Crt>`

`impl AdcCrJadstp<Adc1> for Adc1`[src]

`type UAdcCrJadstp = Jadstp<Urt>`

`type SAdcCrJadstp = Jadstp<Srt>`

`type CAdcCrJadstp = Jadstp<Crt>`

`impl AdcCr<Adc1> for Adc1`[src]

`type AdcCrVal = Val`

`type UAdcCr = Reg<Urt>`

`type SAdcCr = Reg<Srt>`

`type CAdcCr = Reg<Crt>`

`impl UAdcCr<Adc1> for Reg<Urt>`[src]

`fn from_fields(map: UAdcCrFields<Adc1>) -> Self`[src]

`fn into_fields(self) -> UAdcCrFields<Adc1>`[src]

`fn adcaldif(&self) -> &Adcaldif<Urt>`[src]

`fn adcal(&self) -> &Adcal<Urt>`[src]

`fn addis(&self) -> &Addis<Urt>`[src]

`fn aden(&self) -> &Aden<Urt>`[src]

`fn adstart(&self) -> &Adstart<Urt>`[src]

`fn adstp(&self) -> &Adstp<Urt>`[src]

`fn advregen(&self) -> &Advregen<Urt>`[src]

`fn deeppwd(&self) -> &Deeppwd<Urt>`[src]

`fn jadstart(&self) -> &Jadstart<Urt>`[src]

`fn jadstp(&self) -> &Jadstp<Urt>`[src]

`impl SAdcCr<Adc1> for Reg<Srt>`[src]

`fn from_fields(map: SAdcCrFields<Adc1>) -> Self`[src]

`fn into_fields(self) -> SAdcCrFields<Adc1>`[src]

`fn adcaldif(&self) -> &Adcaldif<Srt>`[src]

`fn adcal(&self) -> &Adcal<Srt>`[src]

`fn addis(&self) -> &Addis<Srt>`[src]

`fn aden(&self) -> &Aden<Srt>`[src]

`fn adstart(&self) -> &Adstart<Srt>`[src]

`fn adstp(&self) -> &Adstp<Srt>`[src]

`fn advregen(&self) -> &Advregen<Srt>`[src]

`fn deeppwd(&self) -> &Deeppwd<Srt>`[src]

`fn jadstart(&self) -> &Jadstart<Srt>`[src]

`fn jadstp(&self) -> &Jadstp<Srt>`[src]

`impl CAdcCr<Adc1> for Reg<Crt>`[src]

`fn from_fields(map: CAdcCrFields<Adc1>) -> Self`[src]

`fn into_fields(self) -> CAdcCrFields<Adc1>`[src]

`fn adcaldif(&self) -> &Adcaldif<Crt>`[src]

`fn adcal(&self) -> &Adcal<Crt>`[src]

`fn addis(&self) -> &Addis<Crt>`[src]

`fn aden(&self) -> &Aden<Crt>`[src]

`fn adstart(&self) -> &Adstart<Crt>`[src]

`fn adstp(&self) -> &Adstp<Crt>`[src]

`fn advregen(&self) -> &Advregen<Crt>`[src]

`fn deeppwd(&self) -> &Deeppwd<Crt>`[src]

`fn jadstart(&self) -> &Jadstart<Crt>`[src]

`fn jadstp(&self) -> &Jadstp<Crt>`[src]

`impl AdcCfgrAlign<Adc1> for Adc1`[src]

`type UAdcCfgrAlign = Align<Urt>`

`type SAdcCfgrAlign = Align<Srt>`

`type CAdcCfgrAlign = Align<Crt>`

`impl AdcCfgrAutdly<Adc1> for Adc1`[src]

`type UAdcCfgrAutdly = Autdly<Urt>`

`type SAdcCfgrAutdly = Autdly<Srt>`

`type CAdcCfgrAutdly = Autdly<Crt>`

`impl AdcCfgrAwd1En<Adc1> for Adc1`[src]

`type UAdcCfgrAwd1En = Awd1En<Urt>`

`type SAdcCfgrAwd1En = Awd1En<Srt>`

`type CAdcCfgrAwd1En = Awd1En<Crt>`

`impl AdcCfgrAwd1Sgl<Adc1> for Adc1`[src]

`type UAdcCfgrAwd1Sgl = Awd1Sgl<Urt>`

`type SAdcCfgrAwd1Sgl = Awd1Sgl<Srt>`

`type CAdcCfgrAwd1Sgl = Awd1Sgl<Crt>`

`impl AdcCfgrAwdch1Ch<Adc1> for Adc1`[src]

`type UAdcCfgrAwdch1Ch = Awdch1Ch<Urt>`

`type SAdcCfgrAwdch1Ch = Awdch1Ch<Srt>`

`type CAdcCfgrAwdch1Ch = Awdch1Ch<Crt>`

`impl AdcCfgrCont<Adc1> for Adc1`[src]

`type UAdcCfgrCont = Cont<Urt>`

`type SAdcCfgrCont = Cont<Srt>`

`type CAdcCfgrCont = Cont<Crt>`

`impl AdcCfgrDiscen<Adc1> for Adc1`[src]

`type UAdcCfgrDiscen = Discen<Urt>`

`type SAdcCfgrDiscen = Discen<Srt>`

`type CAdcCfgrDiscen = Discen<Crt>`

`impl AdcCfgrDiscnum<Adc1> for Adc1`[src]

`type UAdcCfgrDiscnum = Discnum<Urt>`

`type SAdcCfgrDiscnum = Discnum<Srt>`

`type CAdcCfgrDiscnum = Discnum<Crt>`

`impl AdcCfgrDmacfg<Adc1> for Adc1`[src]

`type UAdcCfgrDmacfg = Dmacfg<Urt>`

`type SAdcCfgrDmacfg = Dmacfg<Srt>`

`type CAdcCfgrDmacfg = Dmacfg<Crt>`

`impl AdcCfgrDmaen<Adc1> for Adc1`[src]

`type UAdcCfgrDmaen = Dmaen<Urt>`

`type SAdcCfgrDmaen = Dmaen<Srt>`

`type CAdcCfgrDmaen = Dmaen<Crt>`

`impl AdcCfgrExten<Adc1> for Adc1`[src]

`type UAdcCfgrExten = Exten<Urt>`

`type SAdcCfgrExten = Exten<Srt>`

`type CAdcCfgrExten = Exten<Crt>`

`impl AdcCfgrExtsel<Adc1> for Adc1`[src]

`type UAdcCfgrExtsel = Extsel<Urt>`

`type SAdcCfgrExtsel = Extsel<Srt>`

`type CAdcCfgrExtsel = Extsel<Crt>`

`impl AdcCfgrJauto<Adc1> for Adc1`[src]

`type UAdcCfgrJauto = Jauto<Urt>`

`type SAdcCfgrJauto = Jauto<Srt>`

`type CAdcCfgrJauto = Jauto<Crt>`

`impl AdcCfgrJawd1En<Adc1> for Adc1`[src]

`type UAdcCfgrJawd1En = Jawd1En<Urt>`

`type SAdcCfgrJawd1En = Jawd1En<Srt>`

`type CAdcCfgrJawd1En = Jawd1En<Crt>`

`impl AdcCfgrJdiscen<Adc1> for Adc1`[src]

`type UAdcCfgrJdiscen = Jdiscen<Urt>`

`type SAdcCfgrJdiscen = Jdiscen<Srt>`

`type CAdcCfgrJdiscen = Jdiscen<Crt>`

`impl AdcCfgrJqdis<Adc1> for Adc1`[src]

`type UAdcCfgrJqdis = Jqdis<Urt>`

`type SAdcCfgrJqdis = Jqdis<Srt>`

`type CAdcCfgrJqdis = Jqdis<Crt>`

`impl AdcCfgrJqm<Adc1> for Adc1`[src]

`type UAdcCfgrJqm = Jqm<Urt>`

`type SAdcCfgrJqm = Jqm<Srt>`

`type CAdcCfgrJqm = Jqm<Crt>`

`impl AdcCfgrOvrmod<Adc1> for Adc1`[src]

`type UAdcCfgrOvrmod = Ovrmod<Urt>`

`type SAdcCfgrOvrmod = Ovrmod<Srt>`

`type CAdcCfgrOvrmod = Ovrmod<Crt>`

`impl AdcCfgrRes<Adc1> for Adc1`[src]

`type UAdcCfgrRes = Res<Urt>`

`type SAdcCfgrRes = Res<Srt>`

`type CAdcCfgrRes = Res<Crt>`

`impl AdcCfgr<Adc1> for Adc1`[src]

`type AdcCfgrVal = Val`

`type UAdcCfgr = Reg<Urt>`

`type SAdcCfgr = Reg<Srt>`

`type CAdcCfgr = Reg<Crt>`

`impl UAdcCfgr<Adc1> for Reg<Urt>`[src]

`fn from_fields(map: UAdcCfgrFields<Adc1>) -> Self`[src]

`fn into_fields(self) -> UAdcCfgrFields<Adc1>`[src]

`fn align(&self) -> &Align<Urt>`[src]

`fn autdly(&self) -> &Autdly<Urt>`[src]

`fn awd1en(&self) -> &Awd1En<Urt>`[src]

`fn awd1sgl(&self) -> &Awd1Sgl<Urt>`[src]

`fn awdch1ch(&self) -> &Awdch1Ch<Urt>`[src]

`fn cont(&self) -> &Cont<Urt>`[src]

`fn discen(&self) -> &Discen<Urt>`[src]

`fn discnum(&self) -> &Discnum<Urt>`[src]

`fn dmacfg(&self) -> &Dmacfg<Urt>`[src]

`fn dmaen(&self) -> &Dmaen<Urt>`[src]

`fn exten(&self) -> &Exten<Urt>`[src]

`fn extsel(&self) -> &Extsel<Urt>`[src]

`fn jauto(&self) -> &Jauto<Urt>`[src]

`fn jawd1en(&self) -> &Jawd1En<Urt>`[src]

`fn jdiscen(&self) -> &Jdiscen<Urt>`[src]

`fn jqdis(&self) -> &Jqdis<Urt>`[src]

`fn jqm(&self) -> &Jqm<Urt>`[src]

`fn ovrmod(&self) -> &Ovrmod<Urt>`[src]

`fn res(&self) -> &Res<Urt>`[src]

`impl SAdcCfgr<Adc1> for Reg<Srt>`[src]

`fn from_fields(map: SAdcCfgrFields<Adc1>) -> Self`[src]

`fn into_fields(self) -> SAdcCfgrFields<Adc1>`[src]

`fn align(&self) -> &Align<Srt>`[src]

`fn autdly(&self) -> &Autdly<Srt>`[src]

`fn awd1en(&self) -> &Awd1En<Srt>`[src]

`fn awd1sgl(&self) -> &Awd1Sgl<Srt>`[src]

`fn awdch1ch(&self) -> &Awdch1Ch<Srt>`[src]

`fn cont(&self) -> &Cont<Srt>`[src]

`fn discen(&self) -> &Discen<Srt>`[src]

`fn discnum(&self) -> &Discnum<Srt>`[src]

`fn dmacfg(&self) -> &Dmacfg<Srt>`[src]

`fn dmaen(&self) -> &Dmaen<Srt>`[src]

`fn exten(&self) -> &Exten<Srt>`[src]

`fn extsel(&self) -> &Extsel<Srt>`[src]

`fn jauto(&self) -> &Jauto<Srt>`[src]

`fn jawd1en(&self) -> &Jawd1En<Srt>`[src]

`fn jdiscen(&self) -> &Jdiscen<Srt>`[src]

`fn jqdis(&self) -> &Jqdis<Srt>`[src]

`fn jqm(&self) -> &Jqm<Srt>`[src]

`fn ovrmod(&self) -> &Ovrmod<Srt>`[src]

`fn res(&self) -> &Res<Srt>`[src]

`impl CAdcCfgr<Adc1> for Reg<Crt>`[src]

`fn from_fields(map: CAdcCfgrFields<Adc1>) -> Self`[src]

`fn into_fields(self) -> CAdcCfgrFields<Adc1>`[src]

`fn align(&self) -> &Align<Crt>`[src]

`fn autdly(&self) -> &Autdly<Crt>`[src]

`fn awd1en(&self) -> &Awd1En<Crt>`[src]

`fn awd1sgl(&self) -> &Awd1Sgl<Crt>`[src]

`fn awdch1ch(&self) -> &Awdch1Ch<Crt>`[src]

`fn cont(&self) -> &Cont<Crt>`[src]

`fn discen(&self) -> &Discen<Crt>`[src]

`fn discnum(&self) -> &Discnum<Crt>`[src]

`fn dmacfg(&self) -> &Dmacfg<Crt>`[src]

`fn dmaen(&self) -> &Dmaen<Crt>`[src]

`fn exten(&self) -> &Exten<Crt>`[src]

`fn extsel(&self) -> &Extsel<Crt>`[src]

`fn jauto(&self) -> &Jauto<Crt>`[src]

`fn jawd1en(&self) -> &Jawd1En<Crt>`[src]

`fn jdiscen(&self) -> &Jdiscen<Crt>`[src]

`fn jqdis(&self) -> &Jqdis<Crt>`[src]

`fn jqm(&self) -> &Jqm<Crt>`[src]

`fn ovrmod(&self) -> &Ovrmod<Crt>`[src]

`fn res(&self) -> &Res<Crt>`[src]

`impl AdcCfgr2Jovse<Adc1> for Adc1`[src]

`type UAdcCfgr2Jovse = Jovse<Urt>`

`type SAdcCfgr2Jovse = Jovse<Srt>`

`type CAdcCfgr2Jovse = Jovse<Crt>`

`impl AdcCfgr2Ovsr<Adc1> for Adc1`[src]

`type UAdcCfgr2Ovsr = Ovsr<Urt>`

`type SAdcCfgr2Ovsr = Ovsr<Srt>`

`type CAdcCfgr2Ovsr = Ovsr<Crt>`

`impl AdcCfgr2Ovss<Adc1> for Adc1`[src]

`type UAdcCfgr2Ovss = Ovss<Urt>`

`type SAdcCfgr2Ovss = Ovss<Srt>`

`type CAdcCfgr2Ovss = Ovss<Crt>`

`impl AdcCfgr2Rovse<Adc1> for Adc1`[src]

`type UAdcCfgr2Rovse = Rovse<Urt>`

`type SAdcCfgr2Rovse = Rovse<Srt>`

`type CAdcCfgr2Rovse = Rovse<Crt>`

`impl AdcCfgr2Rovsm<Adc1> for Adc1`[src]

`type UAdcCfgr2Rovsm = Rovsm<Urt>`

`type SAdcCfgr2Rovsm = Rovsm<Srt>`

`type CAdcCfgr2Rovsm = Rovsm<Crt>`

`impl AdcCfgr2Trovs<Adc1> for Adc1`[src]

`type UAdcCfgr2Trovs = Trovs<Urt>`

`type SAdcCfgr2Trovs = Trovs<Srt>`

`type CAdcCfgr2Trovs = Trovs<Crt>`

`impl AdcCfgr2<Adc1> for Adc1`[src]

`type AdcCfgr2Val = Val`

`type UAdcCfgr2 = Reg<Urt>`

`type SAdcCfgr2 = Reg<Srt>`

`type CAdcCfgr2 = Reg<Crt>`

`impl UAdcCfgr2<Adc1> for Reg<Urt>`[src]

`fn from_fields(map: UAdcCfgr2Fields<Adc1>) -> Self`[src]

`fn into_fields(self) -> UAdcCfgr2Fields<Adc1>`[src]

`fn jovse(&self) -> &Jovse<Urt>`[src]

`fn ovsr(&self) -> &Ovsr<Urt>`[src]

`fn ovss(&self) -> &Ovss<Urt>`[src]

`fn rovse(&self) -> &Rovse<Urt>`[src]

`fn rovsm(&self) -> &Rovsm<Urt>`[src]

`fn trovs(&self) -> &Trovs<Urt>`[src]

`impl SAdcCfgr2<Adc1> for Reg<Srt>`[src]

`fn from_fields(map: SAdcCfgr2Fields<Adc1>) -> Self`[src]

`fn into_fields(self) -> SAdcCfgr2Fields<Adc1>`[src]

`fn jovse(&self) -> &Jovse<Srt>`[src]

`fn ovsr(&self) -> &Ovsr<Srt>`[src]

`fn ovss(&self) -> &Ovss<Srt>`[src]

`fn rovse(&self) -> &Rovse<Srt>`[src]

`fn rovsm(&self) -> &Rovsm<Srt>`[src]

`fn trovs(&self) -> &Trovs<Srt>`[src]

`impl CAdcCfgr2<Adc1> for Reg<Crt>`[src]

`fn from_fields(map: CAdcCfgr2Fields<Adc1>) -> Self`[src]

`fn into_fields(self) -> CAdcCfgr2Fields<Adc1>`[src]

`fn jovse(&self) -> &Jovse<Crt>`[src]

`fn ovsr(&self) -> &Ovsr<Crt>`[src]

`fn ovss(&self) -> &Ovss<Crt>`[src]

`fn rovse(&self) -> &Rovse<Crt>`[src]

`fn rovsm(&self) -> &Rovsm<Crt>`[src]

`fn trovs(&self) -> &Trovs<Crt>`[src]

`impl AdcSmpr1Smp0<Adc1> for Adc1`[src]

`type UAdcSmpr1Smp0 = Smp0<Urt>`

`type SAdcSmpr1Smp0 = Smp0<Srt>`

`type CAdcSmpr1Smp0 = Smp0<Crt>`

`impl AdcSmpr1Smp1<Adc1> for Adc1`[src]

`type UAdcSmpr1Smp1 = Smp1<Urt>`

`type SAdcSmpr1Smp1 = Smp1<Srt>`

`type CAdcSmpr1Smp1 = Smp1<Crt>`

`impl AdcSmpr1Smp2<Adc1> for Adc1`[src]

`type UAdcSmpr1Smp2 = Smp2<Urt>`

`type SAdcSmpr1Smp2 = Smp2<Srt>`

`type CAdcSmpr1Smp2 = Smp2<Crt>`

`impl AdcSmpr1Smp3<Adc1> for Adc1`[src]

`type UAdcSmpr1Smp3 = Smp3<Urt>`

`type SAdcSmpr1Smp3 = Smp3<Srt>`

`type CAdcSmpr1Smp3 = Smp3<Crt>`

`impl AdcSmpr1Smp4<Adc1> for Adc1`[src]

`type UAdcSmpr1Smp4 = Smp4<Urt>`

`type SAdcSmpr1Smp4 = Smp4<Srt>`

`type CAdcSmpr1Smp4 = Smp4<Crt>`

`impl AdcSmpr1Smp5<Adc1> for Adc1`[src]

`type UAdcSmpr1Smp5 = Smp5<Urt>`

`type SAdcSmpr1Smp5 = Smp5<Srt>`

`type CAdcSmpr1Smp5 = Smp5<Crt>`

`impl AdcSmpr1Smp6<Adc1> for Adc1`[src]

`type UAdcSmpr1Smp6 = Smp6<Urt>`

`type SAdcSmpr1Smp6 = Smp6<Srt>`

`type CAdcSmpr1Smp6 = Smp6<Crt>`

`impl AdcSmpr1Smp7<Adc1> for Adc1`[src]

`type UAdcSmpr1Smp7 = Smp7<Urt>`

`type SAdcSmpr1Smp7 = Smp7<Srt>`

`type CAdcSmpr1Smp7 = Smp7<Crt>`

`impl AdcSmpr1Smp8<Adc1> for Adc1`[src]

`type UAdcSmpr1Smp8 = Smp8<Urt>`

`type SAdcSmpr1Smp8 = Smp8<Srt>`

`type CAdcSmpr1Smp8 = Smp8<Crt>`

`impl AdcSmpr1Smp9<Adc1> for Adc1`[src]

`type UAdcSmpr1Smp9 = Smp9<Urt>`

`type SAdcSmpr1Smp9 = Smp9<Srt>`

`type CAdcSmpr1Smp9 = Smp9<Crt>`

`impl AdcSmpr1Smpplus<Adc1> for Adc1`[src]

`type UAdcSmpr1Smpplus = Smpplus<Urt>`

`type SAdcSmpr1Smpplus = Smpplus<Srt>`

`type CAdcSmpr1Smpplus = Smpplus<Crt>`

`impl AdcSmpr1<Adc1> for Adc1`[src]

`type AdcSmpr1Val = Val`

`type UAdcSmpr1 = Reg<Urt>`

`type SAdcSmpr1 = Reg<Srt>`

`type CAdcSmpr1 = Reg<Crt>`

`impl UAdcSmpr1<Adc1> for Reg<Urt>`[src]

`fn from_fields(map: UAdcSmpr1Fields<Adc1>) -> Self`[src]

`fn into_fields(self) -> UAdcSmpr1Fields<Adc1>`[src]

`fn smp0(&self) -> &Smp0<Urt>`[src]

`fn smp1(&self) -> &Smp1<Urt>`[src]

`fn smp2(&self) -> &Smp2<Urt>`[src]

`fn smp3(&self) -> &Smp3<Urt>`[src]

`fn smp4(&self) -> &Smp4<Urt>`[src]

`fn smp5(&self) -> &Smp5<Urt>`[src]

`fn smp6(&self) -> &Smp6<Urt>`[src]

`fn smp7(&self) -> &Smp7<Urt>`[src]

`fn smp8(&self) -> &Smp8<Urt>`[src]

`fn smp9(&self) -> &Smp9<Urt>`[src]

`fn smpplus(&self) -> &Smpplus<Urt>`[src]

`impl SAdcSmpr1<Adc1> for Reg<Srt>`[src]

`fn from_fields(map: SAdcSmpr1Fields<Adc1>) -> Self`[src]

`fn into_fields(self) -> SAdcSmpr1Fields<Adc1>`[src]

`fn smp0(&self) -> &Smp0<Srt>`[src]

`fn smp1(&self) -> &Smp1<Srt>`[src]

`fn smp2(&self) -> &Smp2<Srt>`[src]

`fn smp3(&self) -> &Smp3<Srt>`[src]

`fn smp4(&self) -> &Smp4<Srt>`[src]

`fn smp5(&self) -> &Smp5<Srt>`[src]

`fn smp6(&self) -> &Smp6<Srt>`[src]

`fn smp7(&self) -> &Smp7<Srt>`[src]

`fn smp8(&self) -> &Smp8<Srt>`[src]

`fn smp9(&self) -> &Smp9<Srt>`[src]

`fn smpplus(&self) -> &Smpplus<Srt>`[src]

`impl CAdcSmpr1<Adc1> for Reg<Crt>`[src]

`fn from_fields(map: CAdcSmpr1Fields<Adc1>) -> Self`[src]

`fn into_fields(self) -> CAdcSmpr1Fields<Adc1>`[src]

`fn smp0(&self) -> &Smp0<Crt>`[src]

`fn smp1(&self) -> &Smp1<Crt>`[src]

`fn smp2(&self) -> &Smp2<Crt>`[src]

`fn smp3(&self) -> &Smp3<Crt>`[src]

`fn smp4(&self) -> &Smp4<Crt>`[src]

`fn smp5(&self) -> &Smp5<Crt>`[src]

`fn smp6(&self) -> &Smp6<Crt>`[src]

`fn smp7(&self) -> &Smp7<Crt>`[src]

`fn smp8(&self) -> &Smp8<Crt>`[src]

`fn smp9(&self) -> &Smp9<Crt>`[src]

`fn smpplus(&self) -> &Smpplus<Crt>`[src]

`impl AdcSmpr2Smp10<Adc1> for Adc1`[src]

`type UAdcSmpr2Smp10 = Smp10<Urt>`

`type SAdcSmpr2Smp10 = Smp10<Srt>`

`type CAdcSmpr2Smp10 = Smp10<Crt>`

`impl AdcSmpr2Smp11<Adc1> for Adc1`[src]

`type UAdcSmpr2Smp11 = Smp11<Urt>`

`type SAdcSmpr2Smp11 = Smp11<Srt>`

`type CAdcSmpr2Smp11 = Smp11<Crt>`

`impl AdcSmpr2Smp12<Adc1> for Adc1`[src]

`type UAdcSmpr2Smp12 = Smp12<Urt>`

`type SAdcSmpr2Smp12 = Smp12<Srt>`

`type CAdcSmpr2Smp12 = Smp12<Crt>`

`impl AdcSmpr2Smp13<Adc1> for Adc1`[src]

`type UAdcSmpr2Smp13 = Smp13<Urt>`

`type SAdcSmpr2Smp13 = Smp13<Srt>`

`type CAdcSmpr2Smp13 = Smp13<Crt>`

`impl AdcSmpr2Smp14<Adc1> for Adc1`[src]

`type UAdcSmpr2Smp14 = Smp14<Urt>`

`type SAdcSmpr2Smp14 = Smp14<Srt>`

`type CAdcSmpr2Smp14 = Smp14<Crt>`

`impl AdcSmpr2Smp15<Adc1> for Adc1`[src]

`type UAdcSmpr2Smp15 = Smp15<Urt>`

`type SAdcSmpr2Smp15 = Smp15<Srt>`

`type CAdcSmpr2Smp15 = Smp15<Crt>`

`impl AdcSmpr2Smp16<Adc1> for Adc1`[src]

`type UAdcSmpr2Smp16 = Smp16<Urt>`

`type SAdcSmpr2Smp16 = Smp16<Srt>`

`type CAdcSmpr2Smp16 = Smp16<Crt>`

`impl AdcSmpr2Smp17<Adc1> for Adc1`[src]

`type UAdcSmpr2Smp17 = Smp17<Urt>`

`type SAdcSmpr2Smp17 = Smp17<Srt>`

`type CAdcSmpr2Smp17 = Smp17<Crt>`

`impl AdcSmpr2Smp18<Adc1> for Adc1`[src]

`type UAdcSmpr2Smp18 = Smp18<Urt>`

`type SAdcSmpr2Smp18 = Smp18<Srt>`

`type CAdcSmpr2Smp18 = Smp18<Crt>`

`impl AdcSmpr2<Adc1> for Adc1`[src]

`type AdcSmpr2Val = Val`

`type UAdcSmpr2 = Reg<Urt>`

`type SAdcSmpr2 = Reg<Srt>`

`type CAdcSmpr2 = Reg<Crt>`

`impl UAdcSmpr2<Adc1> for Reg<Urt>`[src]

`fn from_fields(map: UAdcSmpr2Fields<Adc1>) -> Self`[src]

`fn into_fields(self) -> UAdcSmpr2Fields<Adc1>`[src]

`fn smp10(&self) -> &Smp10<Urt>`[src]

`fn smp11(&self) -> &Smp11<Urt>`[src]

`fn smp12(&self) -> &Smp12<Urt>`[src]

`fn smp13(&self) -> &Smp13<Urt>`[src]

`fn smp14(&self) -> &Smp14<Urt>`[src]

`fn smp15(&self) -> &Smp15<Urt>`[src]

`fn smp16(&self) -> &Smp16<Urt>`[src]

`fn smp17(&self) -> &Smp17<Urt>`[src]

`fn smp18(&self) -> &Smp18<Urt>`[src]

`impl SAdcSmpr2<Adc1> for Reg<Srt>`[src]

`fn from_fields(map: SAdcSmpr2Fields<Adc1>) -> Self`[src]

`fn into_fields(self) -> SAdcSmpr2Fields<Adc1>`[src]

`fn smp10(&self) -> &Smp10<Srt>`[src]

`fn smp11(&self) -> &Smp11<Srt>`[src]

`fn smp12(&self) -> &Smp12<Srt>`[src]

`fn smp13(&self) -> &Smp13<Srt>`[src]

`fn smp14(&self) -> &Smp14<Srt>`[src]

`fn smp15(&self) -> &Smp15<Srt>`[src]

`fn smp16(&self) -> &Smp16<Srt>`[src]

`fn smp17(&self) -> &Smp17<Srt>`[src]

`fn smp18(&self) -> &Smp18<Srt>`[src]

`impl CAdcSmpr2<Adc1> for Reg<Crt>`[src]

`fn from_fields(map: CAdcSmpr2Fields<Adc1>) -> Self`[src]

`fn into_fields(self) -> CAdcSmpr2Fields<Adc1>`[src]

`fn smp10(&self) -> &Smp10<Crt>`[src]

`fn smp11(&self) -> &Smp11<Crt>`[src]

`fn smp12(&self) -> &Smp12<Crt>`[src]

`fn smp13(&self) -> &Smp13<Crt>`[src]

`fn smp14(&self) -> &Smp14<Crt>`[src]

`fn smp15(&self) -> &Smp15<Crt>`[src]

`fn smp16(&self) -> &Smp16<Crt>`[src]

`fn smp17(&self) -> &Smp17<Crt>`[src]

`fn smp18(&self) -> &Smp18<Crt>`[src]

`impl AdcTr1Ht1<Adc1> for Adc1`[src]

`type UAdcTr1Ht1 = Ht1<Urt>`

`type SAdcTr1Ht1 = Ht1<Srt>`

`type CAdcTr1Ht1 = Ht1<Crt>`

`impl AdcTr1Lt1<Adc1> for Adc1`[src]

`type UAdcTr1Lt1 = Lt1<Urt>`

`type SAdcTr1Lt1 = Lt1<Srt>`

`type CAdcTr1Lt1 = Lt1<Crt>`

`impl AdcTr1<Adc1> for Adc1`[src]

`type AdcTr1Val = Val`

`type UAdcTr1 = Reg<Urt>`

`type SAdcTr1 = Reg<Srt>`

`type CAdcTr1 = Reg<Crt>`

`impl UAdcTr1<Adc1> for Reg<Urt>`[src]

`fn from_fields(map: UAdcTr1Fields<Adc1>) -> Self`[src]

`fn into_fields(self) -> UAdcTr1Fields<Adc1>`[src]

`fn ht1(&self) -> &Ht1<Urt>`[src]

`fn lt1(&self) -> &Lt1<Urt>`[src]

`impl SAdcTr1<Adc1> for Reg<Srt>`[src]

`fn from_fields(map: SAdcTr1Fields<Adc1>) -> Self`[src]

`fn into_fields(self) -> SAdcTr1Fields<Adc1>`[src]

`fn ht1(&self) -> &Ht1<Srt>`[src]

`fn lt1(&self) -> &Lt1<Srt>`[src]

`impl CAdcTr1<Adc1> for Reg<Crt>`[src]

`fn from_fields(map: CAdcTr1Fields<Adc1>) -> Self`[src]

`fn into_fields(self) -> CAdcTr1Fields<Adc1>`[src]

`fn ht1(&self) -> &Ht1<Crt>`[src]

`fn lt1(&self) -> &Lt1<Crt>`[src]

`impl AdcTr2Ht2<Adc1> for Adc1`[src]

`type UAdcTr2Ht2 = Ht2<Urt>`

`type SAdcTr2Ht2 = Ht2<Srt>`

`type CAdcTr2Ht2 = Ht2<Crt>`

`impl AdcTr2Lt2<Adc1> for Adc1`[src]

`type UAdcTr2Lt2 = Lt2<Urt>`

`type SAdcTr2Lt2 = Lt2<Srt>`

`type CAdcTr2Lt2 = Lt2<Crt>`

`impl AdcTr2<Adc1> for Adc1`[src]

`type AdcTr2Val = Val`

`type UAdcTr2 = Reg<Urt>`

`type SAdcTr2 = Reg<Srt>`

`type CAdcTr2 = Reg<Crt>`

`impl UAdcTr2<Adc1> for Reg<Urt>`[src]

`fn from_fields(map: UAdcTr2Fields<Adc1>) -> Self`[src]

`fn into_fields(self) -> UAdcTr2Fields<Adc1>`[src]

`fn ht2(&self) -> &Ht2<Urt>`[src]

`fn lt2(&self) -> &Lt2<Urt>`[src]

`impl SAdcTr2<Adc1> for Reg<Srt>`[src]

`fn from_fields(map: SAdcTr2Fields<Adc1>) -> Self`[src]

`fn into_fields(self) -> SAdcTr2Fields<Adc1>`[src]

`fn ht2(&self) -> &Ht2<Srt>`[src]

`fn lt2(&self) -> &Lt2<Srt>`[src]

`impl CAdcTr2<Adc1> for Reg<Crt>`[src]

`fn from_fields(map: CAdcTr2Fields<Adc1>) -> Self`[src]

`fn into_fields(self) -> CAdcTr2Fields<Adc1>`[src]

`fn ht2(&self) -> &Ht2<Crt>`[src]

`fn lt2(&self) -> &Lt2<Crt>`[src]

`impl AdcTr3Ht3<Adc1> for Adc1`[src]

`type UAdcTr3Ht3 = Ht3<Urt>`

`type SAdcTr3Ht3 = Ht3<Srt>`

`type CAdcTr3Ht3 = Ht3<Crt>`

`impl AdcTr3Lt3<Adc1> for Adc1`[src]

`type UAdcTr3Lt3 = Lt3<Urt>`

`type SAdcTr3Lt3 = Lt3<Srt>`

`type CAdcTr3Lt3 = Lt3<Crt>`

`impl AdcTr3<Adc1> for Adc1`[src]

`type AdcTr3Val = Val`

`type UAdcTr3 = Reg<Urt>`

`type SAdcTr3 = Reg<Srt>`

`type CAdcTr3 = Reg<Crt>`

`impl UAdcTr3<Adc1> for Reg<Urt>`[src]

`fn from_fields(map: UAdcTr3Fields<Adc1>) -> Self`[src]

`fn into_fields(self) -> UAdcTr3Fields<Adc1>`[src]

`fn ht3(&self) -> &Ht3<Urt>`[src]

`fn lt3(&self) -> &Lt3<Urt>`[src]

`impl SAdcTr3<Adc1> for Reg<Srt>`[src]

`fn from_fields(map: SAdcTr3Fields<Adc1>) -> Self`[src]

`fn into_fields(self) -> SAdcTr3Fields<Adc1>`[src]

`fn ht3(&self) -> &Ht3<Srt>`[src]

`fn lt3(&self) -> &Lt3<Srt>`[src]

`impl CAdcTr3<Adc1> for Reg<Crt>`[src]

`fn from_fields(map: CAdcTr3Fields<Adc1>) -> Self`[src]

`fn into_fields(self) -> CAdcTr3Fields<Adc1>`[src]

`fn ht3(&self) -> &Ht3<Crt>`[src]

`fn lt3(&self) -> &Lt3<Crt>`[src]

`impl AdcSqr1L<Adc1> for Adc1`[src]

`type UAdcSqr1L = L<Urt>`

`type SAdcSqr1L = L<Srt>`

`type CAdcSqr1L = L<Crt>`

`impl AdcSqr1Sq1<Adc1> for Adc1`[src]

`type UAdcSqr1Sq1 = Sq1<Urt>`

`type SAdcSqr1Sq1 = Sq1<Srt>`

`type CAdcSqr1Sq1 = Sq1<Crt>`

`impl AdcSqr1Sq2<Adc1> for Adc1`[src]

`type UAdcSqr1Sq2 = Sq2<Urt>`

`type SAdcSqr1Sq2 = Sq2<Srt>`

`type CAdcSqr1Sq2 = Sq2<Crt>`

`impl AdcSqr1Sq3<Adc1> for Adc1`[src]

`type UAdcSqr1Sq3 = Sq3<Urt>`

`type SAdcSqr1Sq3 = Sq3<Srt>`

`type CAdcSqr1Sq3 = Sq3<Crt>`

`impl AdcSqr1Sq4<Adc1> for Adc1`[src]

`type UAdcSqr1Sq4 = Sq4<Urt>`

`type SAdcSqr1Sq4 = Sq4<Srt>`

`type CAdcSqr1Sq4 = Sq4<Crt>`

`impl AdcSqr1<Adc1> for Adc1`[src]

`type AdcSqr1Val = Val`

`type UAdcSqr1 = Reg<Urt>`

`type SAdcSqr1 = Reg<Srt>`

`type CAdcSqr1 = Reg<Crt>`

`impl UAdcSqr1<Adc1> for Reg<Urt>`[src]

`fn from_fields(map: UAdcSqr1Fields<Adc1>) -> Self`[src]

`fn into_fields(self) -> UAdcSqr1Fields<Adc1>`[src]

`fn l(&self) -> &L<Urt>`[src]

`fn sq1(&self) -> &Sq1<Urt>`[src]

`fn sq2(&self) -> &Sq2<Urt>`[src]

`fn sq3(&self) -> &Sq3<Urt>`[src]

`fn sq4(&self) -> &Sq4<Urt>`[src]

`impl SAdcSqr1<Adc1> for Reg<Srt>`[src]

`fn from_fields(map: SAdcSqr1Fields<Adc1>) -> Self`[src]

`fn into_fields(self) -> SAdcSqr1Fields<Adc1>`[src]

`fn l(&self) -> &L<Srt>`[src]

`fn sq1(&self) -> &Sq1<Srt>`[src]

`fn sq2(&self) -> &Sq2<Srt>`[src]

`fn sq3(&self) -> &Sq3<Srt>`[src]

`fn sq4(&self) -> &Sq4<Srt>`[src]

`impl CAdcSqr1<Adc1> for Reg<Crt>`[src]

`fn from_fields(map: CAdcSqr1Fields<Adc1>) -> Self`[src]

`fn into_fields(self) -> CAdcSqr1Fields<Adc1>`[src]

`fn l(&self) -> &L<Crt>`[src]

`fn sq1(&self) -> &Sq1<Crt>`[src]

`fn sq2(&self) -> &Sq2<Crt>`[src]

`fn sq3(&self) -> &Sq3<Crt>`[src]

`fn sq4(&self) -> &Sq4<Crt>`[src]

`impl AdcSqr2Sq5<Adc1> for Adc1`[src]

`type UAdcSqr2Sq5 = Sq5<Urt>`

`type SAdcSqr2Sq5 = Sq5<Srt>`

`type CAdcSqr2Sq5 = Sq5<Crt>`

`impl AdcSqr2Sq6<Adc1> for Adc1`[src]

`type UAdcSqr2Sq6 = Sq6<Urt>`

`type SAdcSqr2Sq6 = Sq6<Srt>`

`type CAdcSqr2Sq6 = Sq6<Crt>`

`impl AdcSqr2Sq7<Adc1> for Adc1`[src]

`type UAdcSqr2Sq7 = Sq7<Urt>`

`type SAdcSqr2Sq7 = Sq7<Srt>`

`type CAdcSqr2Sq7 = Sq7<Crt>`

`impl AdcSqr2Sq8<Adc1> for Adc1`[src]

`type UAdcSqr2Sq8 = Sq8<Urt>`

`type SAdcSqr2Sq8 = Sq8<Srt>`

`type CAdcSqr2Sq8 = Sq8<Crt>`

`impl AdcSqr2Sq9<Adc1> for Adc1`[src]

`type UAdcSqr2Sq9 = Sq9<Urt>`

`type SAdcSqr2Sq9 = Sq9<Srt>`

`type CAdcSqr2Sq9 = Sq9<Crt>`

`impl AdcSqr2<Adc1> for Adc1`[src]

`type AdcSqr2Val = Val`

`type UAdcSqr2 = Reg<Urt>`

`type SAdcSqr2 = Reg<Srt>`

`type CAdcSqr2 = Reg<Crt>`

`impl UAdcSqr2<Adc1> for Reg<Urt>`[src]

`fn from_fields(map: UAdcSqr2Fields<Adc1>) -> Self`[src]

`fn into_fields(self) -> UAdcSqr2Fields<Adc1>`[src]

`fn sq5(&self) -> &Sq5<Urt>`[src]

`fn sq6(&self) -> &Sq6<Urt>`[src]

`fn sq7(&self) -> &Sq7<Urt>`[src]

`fn sq8(&self) -> &Sq8<Urt>`[src]

`fn sq9(&self) -> &Sq9<Urt>`[src]

`impl SAdcSqr2<Adc1> for Reg<Srt>`[src]

`fn from_fields(map: SAdcSqr2Fields<Adc1>) -> Self`[src]

`fn into_fields(self) -> SAdcSqr2Fields<Adc1>`[src]

`fn sq5(&self) -> &Sq5<Srt>`[src]

`fn sq6(&self) -> &Sq6<Srt>`[src]

`fn sq7(&self) -> &Sq7<Srt>`[src]

`fn sq8(&self) -> &Sq8<Srt>`[src]

`fn sq9(&self) -> &Sq9<Srt>`[src]

`impl CAdcSqr2<Adc1> for Reg<Crt>`[src]

`fn from_fields(map: CAdcSqr2Fields<Adc1>) -> Self`[src]

`fn into_fields(self) -> CAdcSqr2Fields<Adc1>`[src]

`fn sq5(&self) -> &Sq5<Crt>`[src]

`fn sq6(&self) -> &Sq6<Crt>`[src]

`fn sq7(&self) -> &Sq7<Crt>`[src]

`fn sq8(&self) -> &Sq8<Crt>`[src]

`fn sq9(&self) -> &Sq9<Crt>`[src]

`impl AdcSqr3Sq10<Adc1> for Adc1`[src]

`type UAdcSqr3Sq10 = Sq10<Urt>`

`type SAdcSqr3Sq10 = Sq10<Srt>`

`type CAdcSqr3Sq10 = Sq10<Crt>`

`impl AdcSqr3Sq11<Adc1> for Adc1`[src]

`type UAdcSqr3Sq11 = Sq11<Urt>`

`type SAdcSqr3Sq11 = Sq11<Srt>`

`type CAdcSqr3Sq11 = Sq11<Crt>`

`impl AdcSqr3Sq12<Adc1> for Adc1`[src]

`type UAdcSqr3Sq12 = Sq12<Urt>`

`type SAdcSqr3Sq12 = Sq12<Srt>`

`type CAdcSqr3Sq12 = Sq12<Crt>`

`impl AdcSqr3Sq13<Adc1> for Adc1`[src]

`type UAdcSqr3Sq13 = Sq13<Urt>`

`type SAdcSqr3Sq13 = Sq13<Srt>`

`type CAdcSqr3Sq13 = Sq13<Crt>`

`impl AdcSqr3Sq14<Adc1> for Adc1`[src]

`type UAdcSqr3Sq14 = Sq14<Urt>`

`type SAdcSqr3Sq14 = Sq14<Srt>`

`type CAdcSqr3Sq14 = Sq14<Crt>`

`impl AdcSqr3<Adc1> for Adc1`[src]

`type AdcSqr3Val = Val`

`type UAdcSqr3 = Reg<Urt>`

`type SAdcSqr3 = Reg<Srt>`

`type CAdcSqr3 = Reg<Crt>`

`impl UAdcSqr3<Adc1> for Reg<Urt>`[src]

`fn from_fields(map: UAdcSqr3Fields<Adc1>) -> Self`[src]

`fn into_fields(self) -> UAdcSqr3Fields<Adc1>`[src]

`fn sq10(&self) -> &Sq10<Urt>`[src]

`fn sq11(&self) -> &Sq11<Urt>`[src]

`fn sq12(&self) -> &Sq12<Urt>`[src]

`fn sq13(&self) -> &Sq13<Urt>`[src]

`fn sq14(&self) -> &Sq14<Urt>`[src]

`impl SAdcSqr3<Adc1> for Reg<Srt>`[src]

`fn from_fields(map: SAdcSqr3Fields<Adc1>) -> Self`[src]

`fn into_fields(self) -> SAdcSqr3Fields<Adc1>`[src]

`fn sq10(&self) -> &Sq10<Srt>`[src]

`fn sq11(&self) -> &Sq11<Srt>`[src]

`fn sq12(&self) -> &Sq12<Srt>`[src]

`fn sq13(&self) -> &Sq13<Srt>`[src]

`fn sq14(&self) -> &Sq14<Srt>`[src]

`impl CAdcSqr3<Adc1> for Reg<Crt>`[src]

`fn from_fields(map: CAdcSqr3Fields<Adc1>) -> Self`[src]

`fn into_fields(self) -> CAdcSqr3Fields<Adc1>`[src]

`fn sq10(&self) -> &Sq10<Crt>`[src]

`fn sq11(&self) -> &Sq11<Crt>`[src]

`fn sq12(&self) -> &Sq12<Crt>`[src]

`fn sq13(&self) -> &Sq13<Crt>`[src]

`fn sq14(&self) -> &Sq14<Crt>`[src]

`impl AdcSqr4Sq15<Adc1> for Adc1`[src]

`type UAdcSqr4Sq15 = Sq15<Urt>`

`type SAdcSqr4Sq15 = Sq15<Srt>`

`type CAdcSqr4Sq15 = Sq15<Crt>`

`impl AdcSqr4Sq16<Adc1> for Adc1`[src]

`type UAdcSqr4Sq16 = Sq16<Urt>`

`type SAdcSqr4Sq16 = Sq16<Srt>`

`type CAdcSqr4Sq16 = Sq16<Crt>`

`impl AdcSqr4<Adc1> for Adc1`[src]

`type AdcSqr4Val = Val`

`type UAdcSqr4 = Reg<Urt>`

`type SAdcSqr4 = Reg<Srt>`

`type CAdcSqr4 = Reg<Crt>`

`impl UAdcSqr4<Adc1> for Reg<Urt>`[src]

`fn from_fields(map: UAdcSqr4Fields<Adc1>) -> Self`[src]

`fn into_fields(self) -> UAdcSqr4Fields<Adc1>`[src]

`fn sq15(&self) -> &Sq15<Urt>`[src]

`fn sq16(&self) -> &Sq16<Urt>`[src]

`impl SAdcSqr4<Adc1> for Reg<Srt>`[src]

`fn from_fields(map: SAdcSqr4Fields<Adc1>) -> Self`[src]

`fn into_fields(self) -> SAdcSqr4Fields<Adc1>`[src]

`fn sq15(&self) -> &Sq15<Srt>`[src]

`fn sq16(&self) -> &Sq16<Srt>`[src]

`impl CAdcSqr4<Adc1> for Reg<Crt>`[src]

`fn from_fields(map: CAdcSqr4Fields<Adc1>) -> Self`[src]

`fn into_fields(self) -> CAdcSqr4Fields<Adc1>`[src]

`fn sq15(&self) -> &Sq15<Crt>`[src]

`fn sq16(&self) -> &Sq16<Crt>`[src]

`impl AdcDrRdata<Adc1> for Adc1`[src]

`type UAdcDrRdata = Rdata<Urt>`

`type SAdcDrRdata = Rdata<Srt>`

`type CAdcDrRdata = Rdata<Crt>`

`impl AdcDr<Adc1> for Adc1`[src]

`type AdcDrVal = Val`

`type UAdcDr = Reg<Urt>`

`type SAdcDr = Reg<Srt>`

`type CAdcDr = Reg<Crt>`

`impl UAdcDr<Adc1> for Reg<Urt>`[src]

`fn from_fields(map: UAdcDrFields<Adc1>) -> Self`[src]

`fn into_fields(self) -> UAdcDrFields<Adc1>`[src]

`fn rdata(&self) -> &Rdata<Urt>`[src]

`impl SAdcDr<Adc1> for Reg<Srt>`[src]

`fn from_fields(map: SAdcDrFields<Adc1>) -> Self`[src]

`fn into_fields(self) -> SAdcDrFields<Adc1>`[src]

`fn rdata(&self) -> &Rdata<Srt>`[src]

`impl CAdcDr<Adc1> for Reg<Crt>`[src]

`fn from_fields(map: CAdcDrFields<Adc1>) -> Self`[src]

`fn into_fields(self) -> CAdcDrFields<Adc1>`[src]

`fn rdata(&self) -> &Rdata<Crt>`[src]

`impl AdcJsqrJexten<Adc1> for Adc1`[src]

`type UAdcJsqrJexten = Jexten<Urt>`

`type SAdcJsqrJexten = Jexten<Srt>`

`type CAdcJsqrJexten = Jexten<Crt>`

`impl AdcJsqrJextsel<Adc1> for Adc1`[src]

`type UAdcJsqrJextsel = Jextsel<Urt>`

`type SAdcJsqrJextsel = Jextsel<Srt>`

`type CAdcJsqrJextsel = Jextsel<Crt>`

`impl AdcJsqrJl<Adc1> for Adc1`[src]

`type UAdcJsqrJl = Jl<Urt>`

`type SAdcJsqrJl = Jl<Srt>`

`type CAdcJsqrJl = Jl<Crt>`

`impl AdcJsqrJsq1<Adc1> for Adc1`[src]

`type UAdcJsqrJsq1 = Jsq1<Urt>`

`type SAdcJsqrJsq1 = Jsq1<Srt>`

`type CAdcJsqrJsq1 = Jsq1<Crt>`

`impl AdcJsqrJsq2<Adc1> for Adc1`[src]

`type UAdcJsqrJsq2 = Jsq2<Urt>`

`type SAdcJsqrJsq2 = Jsq2<Srt>`

`type CAdcJsqrJsq2 = Jsq2<Crt>`

`impl AdcJsqrJsq3<Adc1> for Adc1`[src]

`type UAdcJsqrJsq3 = Jsq3<Urt>`

`type SAdcJsqrJsq3 = Jsq3<Srt>`

`type CAdcJsqrJsq3 = Jsq3<Crt>`

`impl AdcJsqrJsq4<Adc1> for Adc1`[src]

`type UAdcJsqrJsq4 = Jsq4<Urt>`

`type SAdcJsqrJsq4 = Jsq4<Srt>`

`type CAdcJsqrJsq4 = Jsq4<Crt>`

`impl AdcJsqr<Adc1> for Adc1`[src]

`type AdcJsqrVal = Val`

`type UAdcJsqr = Reg<Urt>`

`type SAdcJsqr = Reg<Srt>`

`type CAdcJsqr = Reg<Crt>`

`impl UAdcJsqr<Adc1> for Reg<Urt>`[src]

`fn from_fields(map: UAdcJsqrFields<Adc1>) -> Self`[src]

`fn into_fields(self) -> UAdcJsqrFields<Adc1>`[src]

`fn jexten(&self) -> &Jexten<Urt>`[src]

`fn jextsel(&self) -> &Jextsel<Urt>`[src]

`fn jl(&self) -> &Jl<Urt>`[src]

`fn jsq1(&self) -> &Jsq1<Urt>`[src]

`fn jsq2(&self) -> &Jsq2<Urt>`[src]

`fn jsq3(&self) -> &Jsq3<Urt>`[src]

`fn jsq4(&self) -> &Jsq4<Urt>`[src]

`impl SAdcJsqr<Adc1> for Reg<Srt>`[src]

`fn from_fields(map: SAdcJsqrFields<Adc1>) -> Self`[src]

`fn into_fields(self) -> SAdcJsqrFields<Adc1>`[src]

`fn jexten(&self) -> &Jexten<Srt>`[src]

`fn jextsel(&self) -> &Jextsel<Srt>`[src]

`fn jl(&self) -> &Jl<Srt>`[src]

`fn jsq1(&self) -> &Jsq1<Srt>`[src]

`fn jsq2(&self) -> &Jsq2<Srt>`[src]

`fn jsq3(&self) -> &Jsq3<Srt>`[src]

`fn jsq4(&self) -> &Jsq4<Srt>`[src]

`impl CAdcJsqr<Adc1> for Reg<Crt>`[src]

`fn from_fields(map: CAdcJsqrFields<Adc1>) -> Self`[src]

`fn into_fields(self) -> CAdcJsqrFields<Adc1>`[src]

`fn jexten(&self) -> &Jexten<Crt>`[src]

`fn jextsel(&self) -> &Jextsel<Crt>`[src]

`fn jl(&self) -> &Jl<Crt>`[src]

`fn jsq1(&self) -> &Jsq1<Crt>`[src]

`fn jsq2(&self) -> &Jsq2<Crt>`[src]

`fn jsq3(&self) -> &Jsq3<Crt>`[src]

`fn jsq4(&self) -> &Jsq4<Crt>`[src]

`impl AdcOfr1Offset1Ch<Adc1> for Adc1`[src]

`type UAdcOfr1Offset1Ch = Offset1Ch<Urt>`

`type SAdcOfr1Offset1Ch = Offset1Ch<Srt>`

`type CAdcOfr1Offset1Ch = Offset1Ch<Crt>`

`impl AdcOfr1Offset1En<Adc1> for Adc1`[src]

`type UAdcOfr1Offset1En = Offset1En<Urt>`

`type SAdcOfr1Offset1En = Offset1En<Srt>`

`type CAdcOfr1Offset1En = Offset1En<Crt>`

`impl AdcOfr1Offset1<Adc1> for Adc1`[src]

`type UAdcOfr1Offset1 = Offset1<Urt>`

`type SAdcOfr1Offset1 = Offset1<Srt>`

`type CAdcOfr1Offset1 = Offset1<Crt>`

`impl AdcOfr1<Adc1> for Adc1`[src]

`type AdcOfr1Val = Val`

`type UAdcOfr1 = Reg<Urt>`

`type SAdcOfr1 = Reg<Srt>`

`type CAdcOfr1 = Reg<Crt>`

`impl UAdcOfr1<Adc1> for Reg<Urt>`[src]

`fn from_fields(map: UAdcOfr1Fields<Adc1>) -> Self`[src]

`fn into_fields(self) -> UAdcOfr1Fields<Adc1>`[src]

`fn offset1_ch(&self) -> &Offset1Ch<Urt>`[src]

`fn offset1_en(&self) -> &Offset1En<Urt>`[src]

`fn offset1(&self) -> &Offset1<Urt>`[src]

`impl SAdcOfr1<Adc1> for Reg<Srt>`[src]

`fn from_fields(map: SAdcOfr1Fields<Adc1>) -> Self`[src]

`fn into_fields(self) -> SAdcOfr1Fields<Adc1>`[src]

`fn offset1_ch(&self) -> &Offset1Ch<Srt>`[src]

`fn offset1_en(&self) -> &Offset1En<Srt>`[src]

`fn offset1(&self) -> &Offset1<Srt>`[src]

`impl CAdcOfr1<Adc1> for Reg<Crt>`[src]

`fn from_fields(map: CAdcOfr1Fields<Adc1>) -> Self`[src]

`fn into_fields(self) -> CAdcOfr1Fields<Adc1>`[src]

`fn offset1_ch(&self) -> &Offset1Ch<Crt>`[src]

`fn offset1_en(&self) -> &Offset1En<Crt>`[src]

`fn offset1(&self) -> &Offset1<Crt>`[src]

`impl AdcOfr2Offset2Ch<Adc1> for Adc1`[src]

`type UAdcOfr2Offset2Ch = Offset2Ch<Urt>`

`type SAdcOfr2Offset2Ch = Offset2Ch<Srt>`

`type CAdcOfr2Offset2Ch = Offset2Ch<Crt>`

`impl AdcOfr2Offset2En<Adc1> for Adc1`[src]

`type UAdcOfr2Offset2En = Offset2En<Urt>`

`type SAdcOfr2Offset2En = Offset2En<Srt>`

`type CAdcOfr2Offset2En = Offset2En<Crt>`

`impl AdcOfr2Offset2<Adc1> for Adc1`[src]

`type UAdcOfr2Offset2 = Offset2<Urt>`

`type SAdcOfr2Offset2 = Offset2<Srt>`

`type CAdcOfr2Offset2 = Offset2<Crt>`

`impl AdcOfr2<Adc1> for Adc1`[src]

`type AdcOfr2Val = Val`

`type UAdcOfr2 = Reg<Urt>`

`type SAdcOfr2 = Reg<Srt>`

`type CAdcOfr2 = Reg<Crt>`

`impl UAdcOfr2<Adc1> for Reg<Urt>`[src]

`fn from_fields(map: UAdcOfr2Fields<Adc1>) -> Self`[src]

`fn into_fields(self) -> UAdcOfr2Fields<Adc1>`[src]

`fn offset2_ch(&self) -> &Offset2Ch<Urt>`[src]

`fn offset2_en(&self) -> &Offset2En<Urt>`[src]

`fn offset2(&self) -> &Offset2<Urt>`[src]

`impl SAdcOfr2<Adc1> for Reg<Srt>`[src]

`fn from_fields(map: SAdcOfr2Fields<Adc1>) -> Self`[src]

`fn into_fields(self) -> SAdcOfr2Fields<Adc1>`[src]

`fn offset2_ch(&self) -> &Offset2Ch<Srt>`[src]

`fn offset2_en(&self) -> &Offset2En<Srt>`[src]

`fn offset2(&self) -> &Offset2<Srt>`[src]

`impl CAdcOfr2<Adc1> for Reg<Crt>`[src]

`fn from_fields(map: CAdcOfr2Fields<Adc1>) -> Self`[src]

`fn into_fields(self) -> CAdcOfr2Fields<Adc1>`[src]

`fn offset2_ch(&self) -> &Offset2Ch<Crt>`[src]

`fn offset2_en(&self) -> &Offset2En<Crt>`[src]

`fn offset2(&self) -> &Offset2<Crt>`[src]

`impl AdcOfr3Offset3Ch<Adc1> for Adc1`[src]

`type UAdcOfr3Offset3Ch = Offset3Ch<Urt>`

`type SAdcOfr3Offset3Ch = Offset3Ch<Srt>`

`type CAdcOfr3Offset3Ch = Offset3Ch<Crt>`

`impl AdcOfr3Offset3En<Adc1> for Adc1`[src]

`type UAdcOfr3Offset3En = Offset3En<Urt>`

`type SAdcOfr3Offset3En = Offset3En<Srt>`

`type CAdcOfr3Offset3En = Offset3En<Crt>`

`impl AdcOfr3Offset3<Adc1> for Adc1`[src]

`type UAdcOfr3Offset3 = Offset3<Urt>`

`type SAdcOfr3Offset3 = Offset3<Srt>`

`type CAdcOfr3Offset3 = Offset3<Crt>`

`impl AdcOfr3<Adc1> for Adc1`[src]

`type AdcOfr3Val = Val`

`type UAdcOfr3 = Reg<Urt>`

`type SAdcOfr3 = Reg<Srt>`

`type CAdcOfr3 = Reg<Crt>`

`impl UAdcOfr3<Adc1> for Reg<Urt>`[src]

`fn from_fields(map: UAdcOfr3Fields<Adc1>) -> Self`[src]

`fn into_fields(self) -> UAdcOfr3Fields<Adc1>`[src]

`fn offset3_ch(&self) -> &Offset3Ch<Urt>`[src]

`fn offset3_en(&self) -> &Offset3En<Urt>`[src]

`fn offset3(&self) -> &Offset3<Urt>`[src]

`impl SAdcOfr3<Adc1> for Reg<Srt>`[src]

`fn from_fields(map: SAdcOfr3Fields<Adc1>) -> Self`[src]

`fn into_fields(self) -> SAdcOfr3Fields<Adc1>`[src]

`fn offset3_ch(&self) -> &Offset3Ch<Srt>`[src]

`fn offset3_en(&self) -> &Offset3En<Srt>`[src]

`fn offset3(&self) -> &Offset3<Srt>`[src]

`impl CAdcOfr3<Adc1> for Reg<Crt>`[src]

`fn from_fields(map: CAdcOfr3Fields<Adc1>) -> Self`[src]

`fn into_fields(self) -> CAdcOfr3Fields<Adc1>`[src]

`fn offset3_ch(&self) -> &Offset3Ch<Crt>`[src]

`fn offset3_en(&self) -> &Offset3En<Crt>`[src]

`fn offset3(&self) -> &Offset3<Crt>`[src]

`impl AdcOfr4Offset4Ch<Adc1> for Adc1`[src]

`type UAdcOfr4Offset4Ch = Offset4Ch<Urt>`

`type SAdcOfr4Offset4Ch = Offset4Ch<Srt>`

`type CAdcOfr4Offset4Ch = Offset4Ch<Crt>`

`impl AdcOfr4Offset4En<Adc1> for Adc1`[src]

`type UAdcOfr4Offset4En = Offset4En<Urt>`

`type SAdcOfr4Offset4En = Offset4En<Srt>`

`type CAdcOfr4Offset4En = Offset4En<Crt>`

`impl AdcOfr4Offset4<Adc1> for Adc1`[src]

`type UAdcOfr4Offset4 = Offset4<Urt>`

`type SAdcOfr4Offset4 = Offset4<Srt>`

`type CAdcOfr4Offset4 = Offset4<Crt>`

`impl AdcOfr4<Adc1> for Adc1`[src]

`type AdcOfr4Val = Val`

`type UAdcOfr4 = Reg<Urt>`

`type SAdcOfr4 = Reg<Srt>`

`type CAdcOfr4 = Reg<Crt>`

`impl UAdcOfr4<Adc1> for Reg<Urt>`[src]

`fn from_fields(map: UAdcOfr4Fields<Adc1>) -> Self`[src]

`fn into_fields(self) -> UAdcOfr4Fields<Adc1>`[src]

`fn offset4_ch(&self) -> &Offset4Ch<Urt>`[src]

`fn offset4_en(&self) -> &Offset4En<Urt>`[src]

`fn offset4(&self) -> &Offset4<Urt>`[src]

`impl SAdcOfr4<Adc1> for Reg<Srt>`[src]

`fn from_fields(map: SAdcOfr4Fields<Adc1>) -> Self`[src]

`fn into_fields(self) -> SAdcOfr4Fields<Adc1>`[src]

`fn offset4_ch(&self) -> &Offset4Ch<Srt>`[src]

`fn offset4_en(&self) -> &Offset4En<Srt>`[src]

`fn offset4(&self) -> &Offset4<Srt>`[src]

`impl CAdcOfr4<Adc1> for Reg<Crt>`[src]

`fn from_fields(map: CAdcOfr4Fields<Adc1>) -> Self`[src]

`fn into_fields(self) -> CAdcOfr4Fields<Adc1>`[src]

`fn offset4_ch(&self) -> &Offset4Ch<Crt>`[src]

`fn offset4_en(&self) -> &Offset4En<Crt>`[src]

`fn offset4(&self) -> &Offset4<Crt>`[src]

`impl AdcJdr1Jdata1<Adc1> for Adc1`[src]

`type UAdcJdr1Jdata1 = Jdata1<Urt>`

`type SAdcJdr1Jdata1 = Jdata1<Srt>`

`type CAdcJdr1Jdata1 = Jdata1<Crt>`

`impl AdcJdr1<Adc1> for Adc1`[src]

`type AdcJdr1Val = Val`

`type UAdcJdr1 = Reg<Urt>`

`type SAdcJdr1 = Reg<Srt>`

`type CAdcJdr1 = Reg<Crt>`

`impl UAdcJdr1<Adc1> for Reg<Urt>`[src]

`fn from_fields(map: UAdcJdr1Fields<Adc1>) -> Self`[src]

`fn into_fields(self) -> UAdcJdr1Fields<Adc1>`[src]

`fn jdata1(&self) -> &Jdata1<Urt>`[src]

`impl SAdcJdr1<Adc1> for Reg<Srt>`[src]

`fn from_fields(map: SAdcJdr1Fields<Adc1>) -> Self`[src]

`fn into_fields(self) -> SAdcJdr1Fields<Adc1>`[src]

`fn jdata1(&self) -> &Jdata1<Srt>`[src]

`impl CAdcJdr1<Adc1> for Reg<Crt>`[src]

`fn from_fields(map: CAdcJdr1Fields<Adc1>) -> Self`[src]

`fn into_fields(self) -> CAdcJdr1Fields<Adc1>`[src]

`fn jdata1(&self) -> &Jdata1<Crt>`[src]

`impl AdcJdr2Jdata2<Adc1> for Adc1`[src]

`type UAdcJdr2Jdata2 = Jdata2<Urt>`

`type SAdcJdr2Jdata2 = Jdata2<Srt>`

`type CAdcJdr2Jdata2 = Jdata2<Crt>`

`impl AdcJdr2<Adc1> for Adc1`[src]

`type AdcJdr2Val = Val`

`type UAdcJdr2 = Reg<Urt>`

`type SAdcJdr2 = Reg<Srt>`

`type CAdcJdr2 = Reg<Crt>`

`impl UAdcJdr2<Adc1> for Reg<Urt>`[src]

`fn from_fields(map: UAdcJdr2Fields<Adc1>) -> Self`[src]

`fn into_fields(self) -> UAdcJdr2Fields<Adc1>`[src]

`fn jdata2(&self) -> &Jdata2<Urt>`[src]

`impl SAdcJdr2<Adc1> for Reg<Srt>`[src]

`fn from_fields(map: SAdcJdr2Fields<Adc1>) -> Self`[src]

`fn into_fields(self) -> SAdcJdr2Fields<Adc1>`[src]

`fn jdata2(&self) -> &Jdata2<Srt>`[src]

`impl CAdcJdr2<Adc1> for Reg<Crt>`[src]

`fn from_fields(map: CAdcJdr2Fields<Adc1>) -> Self`[src]

`fn into_fields(self) -> CAdcJdr2Fields<Adc1>`[src]

`fn jdata2(&self) -> &Jdata2<Crt>`[src]

`impl AdcJdr3Jdata3<Adc1> for Adc1`[src]

`type UAdcJdr3Jdata3 = Jdata3<Urt>`

`type SAdcJdr3Jdata3 = Jdata3<Srt>`

`type CAdcJdr3Jdata3 = Jdata3<Crt>`

`impl AdcJdr3<Adc1> for Adc1`[src]

`type AdcJdr3Val = Val`

`type UAdcJdr3 = Reg<Urt>`

`type SAdcJdr3 = Reg<Srt>`

`type CAdcJdr3 = Reg<Crt>`

`impl UAdcJdr3<Adc1> for Reg<Urt>`[src]

`fn from_fields(map: UAdcJdr3Fields<Adc1>) -> Self`[src]

`fn into_fields(self) -> UAdcJdr3Fields<Adc1>`[src]

`fn jdata3(&self) -> &Jdata3<Urt>`[src]

`impl SAdcJdr3<Adc1> for Reg<Srt>`[src]

`fn from_fields(map: SAdcJdr3Fields<Adc1>) -> Self`[src]

`fn into_fields(self) -> SAdcJdr3Fields<Adc1>`[src]

`fn jdata3(&self) -> &Jdata3<Srt>`[src]

`impl CAdcJdr3<Adc1> for Reg<Crt>`[src]

`fn from_fields(map: CAdcJdr3Fields<Adc1>) -> Self`[src]

`fn into_fields(self) -> CAdcJdr3Fields<Adc1>`[src]

`fn jdata3(&self) -> &Jdata3<Crt>`[src]

`impl AdcJdr4Jdata4<Adc1> for Adc1`[src]

`type UAdcJdr4Jdata4 = Jdata4<Urt>`

`type SAdcJdr4Jdata4 = Jdata4<Srt>`

`type CAdcJdr4Jdata4 = Jdata4<Crt>`

`impl AdcJdr4<Adc1> for Adc1`[src]

`type AdcJdr4Val = Val`

`type UAdcJdr4 = Reg<Urt>`

`type SAdcJdr4 = Reg<Srt>`

`type CAdcJdr4 = Reg<Crt>`

`impl UAdcJdr4<Adc1> for Reg<Urt>`[src]

`fn from_fields(map: UAdcJdr4Fields<Adc1>) -> Self`[src]

`fn into_fields(self) -> UAdcJdr4Fields<Adc1>`[src]

`fn jdata4(&self) -> &Jdata4<Urt>`[src]

`impl SAdcJdr4<Adc1> for Reg<Srt>`[src]

`fn from_fields(map: SAdcJdr4Fields<Adc1>) -> Self`[src]

`fn into_fields(self) -> SAdcJdr4Fields<Adc1>`[src]

`fn jdata4(&self) -> &Jdata4<Srt>`[src]

`impl CAdcJdr4<Adc1> for Reg<Crt>`[src]

`fn from_fields(map: CAdcJdr4Fields<Adc1>) -> Self`[src]

`fn into_fields(self) -> CAdcJdr4Fields<Adc1>`[src]

`fn jdata4(&self) -> &Jdata4<Crt>`[src]

`impl AdcAwd2CrAwd2Ch<Adc1> for Adc1`[src]

`type UAdcAwd2CrAwd2Ch = Awd2Ch<Urt>`

`type SAdcAwd2CrAwd2Ch = Awd2Ch<Srt>`

`type CAdcAwd2CrAwd2Ch = Awd2Ch<Crt>`

`impl AdcAwd2Cr<Adc1> for Adc1`[src]

`type AdcAwd2CrVal = Val`

`type UAdcAwd2Cr = Reg<Urt>`

`type SAdcAwd2Cr = Reg<Srt>`

`type CAdcAwd2Cr = Reg<Crt>`

`impl UAdcAwd2Cr<Adc1> for Reg<Urt>`[src]

`fn from_fields(map: UAdcAwd2CrFields<Adc1>) -> Self`[src]

`fn into_fields(self) -> UAdcAwd2CrFields<Adc1>`[src]

`fn awd2ch(&self) -> &Awd2Ch<Urt>`[src]

`impl SAdcAwd2Cr<Adc1> for Reg<Srt>`[src]

`fn from_fields(map: SAdcAwd2CrFields<Adc1>) -> Self`[src]

`fn into_fields(self) -> SAdcAwd2CrFields<Adc1>`[src]

`fn awd2ch(&self) -> &Awd2Ch<Srt>`[src]

`impl CAdcAwd2Cr<Adc1> for Reg<Crt>`[src]

`fn from_fields(map: CAdcAwd2CrFields<Adc1>) -> Self`[src]

`fn into_fields(self) -> CAdcAwd2CrFields<Adc1>`[src]

`fn awd2ch(&self) -> &Awd2Ch<Crt>`[src]

`impl AdcAwd3CrAwd3Ch<Adc1> for Adc1`[src]

`type UAdcAwd3CrAwd3Ch = Awd3Ch<Urt>`

`type SAdcAwd3CrAwd3Ch = Awd3Ch<Srt>`

`type CAdcAwd3CrAwd3Ch = Awd3Ch<Crt>`

`impl AdcAwd3Cr<Adc1> for Adc1`[src]

`type AdcAwd3CrVal = Val`

`type UAdcAwd3Cr = Reg<Urt>`

`type SAdcAwd3Cr = Reg<Srt>`

`type CAdcAwd3Cr = Reg<Crt>`

`impl UAdcAwd3Cr<Adc1> for Reg<Urt>`[src]

`fn from_fields(map: UAdcAwd3CrFields<Adc1>) -> Self`[src]

`fn into_fields(self) -> UAdcAwd3CrFields<Adc1>`[src]

`fn awd3ch(&self) -> &Awd3Ch<Urt>`[src]

`impl SAdcAwd3Cr<Adc1> for Reg<Srt>`[src]

`fn from_fields(map: SAdcAwd3CrFields<Adc1>) -> Self`[src]

`fn into_fields(self) -> SAdcAwd3CrFields<Adc1>`[src]

`fn awd3ch(&self) -> &Awd3Ch<Srt>`[src]

`impl CAdcAwd3Cr<Adc1> for Reg<Crt>`[src]

`fn from_fields(map: CAdcAwd3CrFields<Adc1>) -> Self`[src]

`fn into_fields(self) -> CAdcAwd3CrFields<Adc1>`[src]

`fn awd3ch(&self) -> &Awd3Ch<Crt>`[src]

`impl AdcDifselDifsel115<Adc1> for Adc1`[src]

`type UAdcDifselDifsel115 = Difsel115<Urt>`

`type SAdcDifselDifsel115 = Difsel115<Srt>`

`type CAdcDifselDifsel115 = Difsel115<Crt>`

`impl AdcDifselDifsel1618<Adc1> for Adc1`[src]

`type UAdcDifselDifsel1618 = Difsel1618<Urt>`

`type SAdcDifselDifsel1618 = Difsel1618<Srt>`

`type CAdcDifselDifsel1618 = Difsel1618<Crt>`

`impl AdcDifsel<Adc1> for Adc1`[src]

`type AdcDifselVal = Val`

`type UAdcDifsel = Reg<Urt>`

`type SAdcDifsel = Reg<Srt>`

`type CAdcDifsel = Reg<Crt>`

`impl UAdcDifsel<Adc1> for Reg<Urt>`[src]

`fn from_fields(map: UAdcDifselFields<Adc1>) -> Self`[src]

`fn into_fields(self) -> UAdcDifselFields<Adc1>`[src]

`fn difsel_1_15(&self) -> &Difsel115<Urt>`[src]

`fn difsel_16_18(&self) -> &Difsel1618<Urt>`[src]

`impl SAdcDifsel<Adc1> for Reg<Srt>`[src]

`fn from_fields(map: SAdcDifselFields<Adc1>) -> Self`[src]

`fn into_fields(self) -> SAdcDifselFields<Adc1>`[src]

`fn difsel_1_15(&self) -> &Difsel115<Srt>`[src]

`fn difsel_16_18(&self) -> &Difsel1618<Srt>`[src]

`impl CAdcDifsel<Adc1> for Reg<Crt>`[src]

`fn from_fields(map: CAdcDifselFields<Adc1>) -> Self`[src]

`fn into_fields(self) -> CAdcDifselFields<Adc1>`[src]

`fn difsel_1_15(&self) -> &Difsel115<Crt>`[src]

`fn difsel_16_18(&self) -> &Difsel1618<Crt>`[src]

`impl AdcCalfactCalfactD<Adc1> for Adc1`[src]

`type UAdcCalfactCalfactD = CalfactD<Urt>`

`type SAdcCalfactCalfactD = CalfactD<Srt>`

`type CAdcCalfactCalfactD = CalfactD<Crt>`

`impl AdcCalfactCalfactS<Adc1> for Adc1`[src]

`type UAdcCalfactCalfactS = CalfactS<Urt>`

`type SAdcCalfactCalfactS = CalfactS<Srt>`

`type CAdcCalfactCalfactS = CalfactS<Crt>`

`impl AdcCalfact<Adc1> for Adc1`[src]

`type AdcCalfactVal = Val`

`type UAdcCalfact = Reg<Urt>`

`type SAdcCalfact = Reg<Srt>`

`type CAdcCalfact = Reg<Crt>`

`impl UAdcCalfact<Adc1> for Reg<Urt>`[src]

`fn from_fields(map: UAdcCalfactFields<Adc1>) -> Self`[src]

`fn into_fields(self) -> UAdcCalfactFields<Adc1>`[src]

`fn calfact_d(&self) -> &CalfactD<Urt>`[src]

`fn calfact_s(&self) -> &CalfactS<Urt>`[src]

`impl SAdcCalfact<Adc1> for Reg<Srt>`[src]

`fn from_fields(map: SAdcCalfactFields<Adc1>) -> Self`[src]

`fn into_fields(self) -> SAdcCalfactFields<Adc1>`[src]

`fn calfact_d(&self) -> &CalfactD<Srt>`[src]

`fn calfact_s(&self) -> &CalfactS<Srt>`[src]

`impl CAdcCalfact<Adc1> for Reg<Crt>`[src]

`fn from_fields(map: CAdcCalfactFields<Adc1>) -> Self`[src]

`fn into_fields(self) -> CAdcCalfactFields<Adc1>`[src]

`fn calfact_d(&self) -> &CalfactD<Crt>`[src]

`fn calfact_s(&self) -> &CalfactS<Crt>`[src]

`impl AdcMap for Adc1`[src]

Auto Trait Implementations

`impl Unpin for Adc1`

`impl Send for Adc1`

`impl Sync for Adc1`

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_adc::Adc1

Trait Implementations

impl RccBusenrAdcen for Adc1[src]

type URccBusenrAdcen = Adcen<Urt>

type SRccBusenrAdcen = Adcen<Srt>

type CRccBusenrAdcen = Adcen<Crt>

impl RccBusenr for Adc1[src]

type RccBusenrVal = Val

type URccBusenr = Reg<Urt>

type SRccBusenr = Reg<Srt>

type CRccBusenr = Reg<Crt>

impl RccBusrstrAdcrst for Adc1[src]

type URccBusrstrAdcrst = Adcrst<Urt>

type SRccBusrstrAdcrst = Adcrst<Srt>

type CRccBusrstrAdcrst = Adcrst<Crt>

impl RccBusrstr for Adc1[src]

type RccBusrstrVal = Val

type URccBusrstr = Reg<Urt>

type SRccBusrstr = Reg<Srt>

type CRccBusrstr = Reg<Crt>

impl RccBussmenrAdcsmen for Adc1[src]

type URccBussmenrAdcsmen = Adcsmen<Urt>

type SRccBussmenrAdcsmen = Adcsmen<Srt>

type CRccBussmenrAdcsmen = Adcsmen<Crt>

impl RccBussmenr for Adc1[src]

type RccBussmenrVal = Val

type URccBussmenr = Reg<Urt>

type SRccBussmenr = Reg<Srt>

type CRccBussmenr = Reg<Crt>

impl RccCciprAdcsel for Adc1[src]

type URccCciprAdcsel = Adcsel<Urt>

type SRccCciprAdcsel = Adcsel<Srt>

type CRccCciprAdcsel = Adcsel<Crt>

impl RccCcipr for Adc1[src]

type RccCciprVal = Val

type URccCcipr = Reg<Urt>

type SRccCcipr = Reg<Srt>

type CRccCcipr = Reg<Crt>

impl AdcIsrAdrdy<Adc1> for Adc1[src]

type UAdcIsrAdrdy = Adrdy<Urt>

type SAdcIsrAdrdy = Adrdy<Srt>

type CAdcIsrAdrdy = Adrdy<Crt>

impl AdcIsrAwd1<Adc1> for Adc1[src]

type UAdcIsrAwd1 = Awd1<Urt>

type SAdcIsrAwd1 = Awd1<Srt>

type CAdcIsrAwd1 = Awd1<Crt>

impl AdcIsrAwd2<Adc1> for Adc1[src]

type UAdcIsrAwd2 = Awd2<Urt>

type SAdcIsrAwd2 = Awd2<Srt>

type CAdcIsrAwd2 = Awd2<Crt>

impl AdcIsrAwd3<Adc1> for Adc1[src]

type UAdcIsrAwd3 = Awd3<Urt>

type SAdcIsrAwd3 = Awd3<Srt>

type CAdcIsrAwd3 = Awd3<Crt>

impl AdcIsrEoc<Adc1> for Adc1[src]

type UAdcIsrEoc = Eoc<Urt>

type SAdcIsrEoc = Eoc<Srt>

type CAdcIsrEoc = Eoc<Crt>

impl AdcIsrEosmp<Adc1> for Adc1[src]

type UAdcIsrEosmp = Eosmp<Urt>

type SAdcIsrEosmp = Eosmp<Srt>

type CAdcIsrEosmp = Eosmp<Crt>

impl AdcIsrEos<Adc1> for Adc1[src]

type UAdcIsrEos = Eos<Urt>

type SAdcIsrEos = Eos<Srt>

type CAdcIsrEos = Eos<Crt>

impl AdcIsrJeoc<Adc1> for Adc1[src]

type UAdcIsrJeoc = Jeoc<Urt>

type SAdcIsrJeoc = Jeoc<Srt>

type CAdcIsrJeoc = Jeoc<Crt>

impl AdcIsrJeos<Adc1> for Adc1[src]

type UAdcIsrJeos = Jeos<Urt>

type SAdcIsrJeos = Jeos<Srt>

type CAdcIsrJeos = Jeos<Crt>

impl AdcIsrJqovf<Adc1> for Adc1[src]

type UAdcIsrJqovf = Jqovf<Urt>

type SAdcIsrJqovf = Jqovf<Srt>

type CAdcIsrJqovf = Jqovf<Crt>

impl AdcIsrOvr<Adc1> for Adc1[src]

type UAdcIsrOvr = Ovr<Urt>

`impl RccBusenrAdcen for Adc1`[src]

`type URccBusenrAdcen = Adcen<Urt>`

`type SRccBusenrAdcen = Adcen<Srt>`

`type CRccBusenrAdcen = Adcen<Crt>`

`impl RccBusenr for Adc1`[src]

`type RccBusenrVal = Val`

`type URccBusenr = Reg<Urt>`

`type SRccBusenr = Reg<Srt>`

`type CRccBusenr = Reg<Crt>`

`impl RccBusrstrAdcrst for Adc1`[src]

`type URccBusrstrAdcrst = Adcrst<Urt>`

`type SRccBusrstrAdcrst = Adcrst<Srt>`

`type CRccBusrstrAdcrst = Adcrst<Crt>`

`impl RccBusrstr for Adc1`[src]

`type RccBusrstrVal = Val`

`type URccBusrstr = Reg<Urt>`

`type SRccBusrstr = Reg<Srt>`

`type CRccBusrstr = Reg<Crt>`

`impl RccBussmenrAdcsmen for Adc1`[src]

`type URccBussmenrAdcsmen = Adcsmen<Urt>`

`type SRccBussmenrAdcsmen = Adcsmen<Srt>`

`type CRccBussmenrAdcsmen = Adcsmen<Crt>`

`impl RccBussmenr for Adc1`[src]

`type RccBussmenrVal = Val`

`type URccBussmenr = Reg<Urt>`

`type SRccBussmenr = Reg<Srt>`

`type CRccBussmenr = Reg<Crt>`

`impl RccCciprAdcsel for Adc1`[src]

`type URccCciprAdcsel = Adcsel<Urt>`

`type SRccCciprAdcsel = Adcsel<Srt>`

`type CRccCciprAdcsel = Adcsel<Crt>`

`impl RccCcipr for Adc1`[src]

`type RccCciprVal = Val`

`type URccCcipr = Reg<Urt>`

`type SRccCcipr = Reg<Srt>`

`type CRccCcipr = Reg<Crt>`

`impl AdcIsrAdrdy<Adc1> for Adc1`[src]

`type UAdcIsrAdrdy = Adrdy<Urt>`

`type SAdcIsrAdrdy = Adrdy<Srt>`

`type CAdcIsrAdrdy = Adrdy<Crt>`

`impl AdcIsrAwd1<Adc1> for Adc1`[src]

`type UAdcIsrAwd1 = Awd1<Urt>`

`type SAdcIsrAwd1 = Awd1<Srt>`

`type CAdcIsrAwd1 = Awd1<Crt>`

`impl AdcIsrAwd2<Adc1> for Adc1`[src]

`type UAdcIsrAwd2 = Awd2<Urt>`

`type SAdcIsrAwd2 = Awd2<Srt>`

`type CAdcIsrAwd2 = Awd2<Crt>`

`impl AdcIsrAwd3<Adc1> for Adc1`[src]

`type UAdcIsrAwd3 = Awd3<Urt>`

`type SAdcIsrAwd3 = Awd3<Srt>`

`type CAdcIsrAwd3 = Awd3<Crt>`

`impl AdcIsrEoc<Adc1> for Adc1`[src]

`type UAdcIsrEoc = Eoc<Urt>`

`type SAdcIsrEoc = Eoc<Srt>`

`type CAdcIsrEoc = Eoc<Crt>`

`impl AdcIsrEosmp<Adc1> for Adc1`[src]

`type UAdcIsrEosmp = Eosmp<Urt>`

`type SAdcIsrEosmp = Eosmp<Srt>`

`type CAdcIsrEosmp = Eosmp<Crt>`

`impl AdcIsrEos<Adc1> for Adc1`[src]

`type UAdcIsrEos = Eos<Urt>`

`type SAdcIsrEos = Eos<Srt>`

`type CAdcIsrEos = Eos<Crt>`

`impl AdcIsrJeoc<Adc1> for Adc1`[src]

`type UAdcIsrJeoc = Jeoc<Urt>`

`type SAdcIsrJeoc = Jeoc<Srt>`

`type CAdcIsrJeoc = Jeoc<Crt>`

`impl AdcIsrJeos<Adc1> for Adc1`[src]

`type UAdcIsrJeos = Jeos<Urt>`

`type SAdcIsrJeos = Jeos<Srt>`

`type CAdcIsrJeos = Jeos<Crt>`

`impl AdcIsrJqovf<Adc1> for Adc1`[src]

`type UAdcIsrJqovf = Jqovf<Urt>`

`type SAdcIsrJqovf = Jqovf<Srt>`

`type CAdcIsrJqovf = Jqovf<Crt>`

`impl AdcIsrOvr<Adc1> for Adc1`[src]

`type UAdcIsrOvr = Ovr<Urt>`

`type SAdcIsrOvr = Ovr<Srt>`

`type CAdcIsrOvr = Ovr<Crt>`