[−][src]Struct drone_stm32_map_periph_spi::Spi3

pub struct Spi3(_);

SPI3 peripheral variant.

Trait Implementations

`impl RccBusenrSpien for Spi3`[src]

`type URccBusenrSpien = Spi3En<Urt>`

`type SRccBusenrSpien = Spi3En<Srt>`

`type CRccBusenrSpien = Spi3En<Crt>`

`impl RccBusenr for Spi3`[src]

`type RccBusenrVal = Val`

`type URccBusenr = Reg<Urt>`

`type SRccBusenr = Reg<Srt>`

`type CRccBusenr = Reg<Crt>`

`impl RccBusrstrSpirst for Spi3`[src]

`type URccBusrstrSpirst = Spi3Rst<Urt>`

`type SRccBusrstrSpirst = Spi3Rst<Srt>`

`type CRccBusrstrSpirst = Spi3Rst<Crt>`

`impl RccBusrstr for Spi3`[src]

`type RccBusrstrVal = Val`

`type URccBusrstr = Reg<Urt>`

`type SRccBusrstr = Reg<Srt>`

`type CRccBusrstr = Reg<Crt>`

`impl RccBussmenrSpismen for Spi3`[src]

`type URccBussmenrSpismen = Spi3Smen<Urt>`

`type SRccBussmenrSpismen = Spi3Smen<Srt>`

`type CRccBussmenrSpismen = Spi3Smen<Crt>`

`impl RccBussmenr for Spi3`[src]

`type RccBussmenrVal = Val`

`type URccBussmenr = Reg<Urt>`

`type SRccBussmenr = Reg<Srt>`

`type CRccBussmenr = Reg<Crt>`

`impl SpiCr1Bidimode<Spi3> for Spi3`[src]

`type USpiCr1Bidimode = Bidimode<Urt>`

`type SSpiCr1Bidimode = Bidimode<Srt>`

`type CSpiCr1Bidimode = Bidimode<Crt>`

`impl SpiCr1Bidioe<Spi3> for Spi3`[src]

`type USpiCr1Bidioe = Bidioe<Urt>`

`type SSpiCr1Bidioe = Bidioe<Srt>`

`type CSpiCr1Bidioe = Bidioe<Crt>`

`impl SpiCr1Br<Spi3> for Spi3`[src]

`type USpiCr1Br = Br<Urt>`

`type SSpiCr1Br = Br<Srt>`

`type CSpiCr1Br = Br<Crt>`

`impl SpiCr1Cpha<Spi3> for Spi3`[src]

`type USpiCr1Cpha = Cpha<Urt>`

`type SSpiCr1Cpha = Cpha<Srt>`

`type CSpiCr1Cpha = Cpha<Crt>`

`impl SpiCr1Cpol<Spi3> for Spi3`[src]

`type USpiCr1Cpol = Cpol<Urt>`

`type SSpiCr1Cpol = Cpol<Srt>`

`type CSpiCr1Cpol = Cpol<Crt>`

`impl SpiCr1Crcen<Spi3> for Spi3`[src]

`type USpiCr1Crcen = Crcen<Urt>`

`type SSpiCr1Crcen = Crcen<Srt>`

`type CSpiCr1Crcen = Crcen<Crt>`

`impl SpiCr1Crcnext<Spi3> for Spi3`[src]

`type USpiCr1Crcnext = Crcnext<Urt>`

`type SSpiCr1Crcnext = Crcnext<Srt>`

`type CSpiCr1Crcnext = Crcnext<Crt>`

`impl SpiCr1Dff<Spi3> for Spi3`[src]

`type USpiCr1Dff = Dff<Urt>`

`type SSpiCr1Dff = Dff<Srt>`

`type CSpiCr1Dff = Dff<Crt>`

`impl SpiCr1Lsbfirst<Spi3> for Spi3`[src]

`type USpiCr1Lsbfirst = Lsbfirst<Urt>`

`type SSpiCr1Lsbfirst = Lsbfirst<Srt>`

`type CSpiCr1Lsbfirst = Lsbfirst<Crt>`

`impl SpiCr1Mstr<Spi3> for Spi3`[src]

`type USpiCr1Mstr = Mstr<Urt>`

`type SSpiCr1Mstr = Mstr<Srt>`

`type CSpiCr1Mstr = Mstr<Crt>`

`impl SpiCr1Rxonly<Spi3> for Spi3`[src]

`type USpiCr1Rxonly = Rxonly<Urt>`

`type SSpiCr1Rxonly = Rxonly<Srt>`

`type CSpiCr1Rxonly = Rxonly<Crt>`

`impl SpiCr1Spe<Spi3> for Spi3`[src]

`type USpiCr1Spe = Spe<Urt>`

`type SSpiCr1Spe = Spe<Srt>`

`type CSpiCr1Spe = Spe<Crt>`

`impl SpiCr1Ssi<Spi3> for Spi3`[src]

`type USpiCr1Ssi = Ssi<Urt>`

`type SSpiCr1Ssi = Ssi<Srt>`

`type CSpiCr1Ssi = Ssi<Crt>`

`impl SpiCr1Ssm<Spi3> for Spi3`[src]

`type USpiCr1Ssm = Ssm<Urt>`

`type SSpiCr1Ssm = Ssm<Srt>`

`type CSpiCr1Ssm = Ssm<Crt>`

`impl SpiCr1<Spi3> for Spi3`[src]

`type SpiCr1Val = Val`

`type USpiCr1 = Reg<Urt>`

`type SSpiCr1 = Reg<Srt>`

`type CSpiCr1 = Reg<Crt>`

`impl USpiCr1<Spi3> for Reg<Urt>`[src]

`fn from_fields(map: USpiCr1Fields<Spi3>) -> Self`[src]

`fn into_fields(self) -> USpiCr1Fields<Spi3>`[src]

`fn bidimode(&self) -> &Bidimode<Urt>`[src]

`fn bidioe(&self) -> &Bidioe<Urt>`[src]

`fn br(&self) -> &Br<Urt>`[src]

`fn cpha(&self) -> &Cpha<Urt>`[src]

`fn cpol(&self) -> &Cpol<Urt>`[src]

`fn crcen(&self) -> &Crcen<Urt>`[src]

`fn crcnext(&self) -> &Crcnext<Urt>`[src]

`fn dff(&self) -> &Dff<Urt>`[src]

`fn lsbfirst(&self) -> &Lsbfirst<Urt>`[src]

`fn mstr(&self) -> &Mstr<Urt>`[src]

`fn rxonly(&self) -> &Rxonly<Urt>`[src]

`fn spe(&self) -> &Spe<Urt>`[src]

`fn ssi(&self) -> &Ssi<Urt>`[src]

`fn ssm(&self) -> &Ssm<Urt>`[src]

`impl SSpiCr1<Spi3> for Reg<Srt>`[src]

`fn from_fields(map: SSpiCr1Fields<Spi3>) -> Self`[src]

`fn into_fields(self) -> SSpiCr1Fields<Spi3>`[src]

`fn bidimode(&self) -> &Bidimode<Srt>`[src]

`fn bidioe(&self) -> &Bidioe<Srt>`[src]

`fn br(&self) -> &Br<Srt>`[src]

`fn cpha(&self) -> &Cpha<Srt>`[src]

`fn cpol(&self) -> &Cpol<Srt>`[src]

`fn crcen(&self) -> &Crcen<Srt>`[src]

`fn crcnext(&self) -> &Crcnext<Srt>`[src]

`fn dff(&self) -> &Dff<Srt>`[src]

`fn lsbfirst(&self) -> &Lsbfirst<Srt>`[src]

`fn mstr(&self) -> &Mstr<Srt>`[src]

`fn rxonly(&self) -> &Rxonly<Srt>`[src]

`fn spe(&self) -> &Spe<Srt>`[src]

`fn ssi(&self) -> &Ssi<Srt>`[src]

`fn ssm(&self) -> &Ssm<Srt>`[src]

`impl CSpiCr1<Spi3> for Reg<Crt>`[src]

`fn from_fields(map: CSpiCr1Fields<Spi3>) -> Self`[src]

`fn into_fields(self) -> CSpiCr1Fields<Spi3>`[src]

`fn bidimode(&self) -> &Bidimode<Crt>`[src]

`fn bidioe(&self) -> &Bidioe<Crt>`[src]

`fn br(&self) -> &Br<Crt>`[src]

`fn cpha(&self) -> &Cpha<Crt>`[src]

`fn cpol(&self) -> &Cpol<Crt>`[src]

`fn crcen(&self) -> &Crcen<Crt>`[src]

`fn crcnext(&self) -> &Crcnext<Crt>`[src]

`fn dff(&self) -> &Dff<Crt>`[src]

`fn lsbfirst(&self) -> &Lsbfirst<Crt>`[src]

`fn mstr(&self) -> &Mstr<Crt>`[src]

`fn rxonly(&self) -> &Rxonly<Crt>`[src]

`fn spe(&self) -> &Spe<Crt>`[src]

`fn ssi(&self) -> &Ssi<Crt>`[src]

`fn ssm(&self) -> &Ssm<Crt>`[src]

`impl SpiCr2Ds<Spi3> for Spi3`[src]

`type USpiCr2Ds = Ds<Urt>`

`type SSpiCr2Ds = Ds<Srt>`

`type CSpiCr2Ds = Ds<Crt>`

`impl SpiCr2Errie<Spi3> for Spi3`[src]

`type USpiCr2Errie = Errie<Urt>`

`type SSpiCr2Errie = Errie<Srt>`

`type CSpiCr2Errie = Errie<Crt>`

`impl SpiCr2Frf<Spi3> for Spi3`[src]

`type USpiCr2Frf = Frf<Urt>`

`type SSpiCr2Frf = Frf<Srt>`

`type CSpiCr2Frf = Frf<Crt>`

`impl SpiCr2Frxth<Spi3> for Spi3`[src]

`type USpiCr2Frxth = Frxth<Urt>`

`type SSpiCr2Frxth = Frxth<Srt>`

`type CSpiCr2Frxth = Frxth<Crt>`

`impl SpiCr2LdmaRx<Spi3> for Spi3`[src]

`type USpiCr2LdmaRx = LdmaRx<Urt>`

`type SSpiCr2LdmaRx = LdmaRx<Srt>`

`type CSpiCr2LdmaRx = LdmaRx<Crt>`

`impl SpiCr2LdmaTx<Spi3> for Spi3`[src]

`type USpiCr2LdmaTx = LdmaTx<Urt>`

`type SSpiCr2LdmaTx = LdmaTx<Srt>`

`type CSpiCr2LdmaTx = LdmaTx<Crt>`

`impl SpiCr2Nssp<Spi3> for Spi3`[src]

`type USpiCr2Nssp = Nssp<Urt>`

`type SSpiCr2Nssp = Nssp<Srt>`

`type CSpiCr2Nssp = Nssp<Crt>`

`impl SpiCr2Rxdmaen<Spi3> for Spi3`[src]

`type USpiCr2Rxdmaen = Rxdmaen<Urt>`

`type SSpiCr2Rxdmaen = Rxdmaen<Srt>`

`type CSpiCr2Rxdmaen = Rxdmaen<Crt>`

`impl SpiCr2Rxneie<Spi3> for Spi3`[src]

`type USpiCr2Rxneie = Rxneie<Urt>`

`type SSpiCr2Rxneie = Rxneie<Srt>`

`type CSpiCr2Rxneie = Rxneie<Crt>`

`impl SpiCr2Ssoe<Spi3> for Spi3`[src]

`type USpiCr2Ssoe = Ssoe<Urt>`

`type SSpiCr2Ssoe = Ssoe<Srt>`

`type CSpiCr2Ssoe = Ssoe<Crt>`

`impl SpiCr2Txdmaen<Spi3> for Spi3`[src]

`type USpiCr2Txdmaen = Txdmaen<Urt>`

`type SSpiCr2Txdmaen = Txdmaen<Srt>`

`type CSpiCr2Txdmaen = Txdmaen<Crt>`

`impl SpiCr2Txeie<Spi3> for Spi3`[src]

`type USpiCr2Txeie = Txeie<Urt>`

`type SSpiCr2Txeie = Txeie<Srt>`

`type CSpiCr2Txeie = Txeie<Crt>`

`impl SpiCr2<Spi3> for Spi3`[src]

`type SpiCr2Val = Val`

`type USpiCr2 = Reg<Urt>`

`type SSpiCr2 = Reg<Srt>`

`type CSpiCr2 = Reg<Crt>`

`impl USpiCr2<Spi3> for Reg<Urt>`[src]

`fn from_fields(map: USpiCr2Fields<Spi3>) -> Self`[src]

`fn into_fields(self) -> USpiCr2Fields<Spi3>`[src]

`fn ds(&self) -> &Ds<Urt>`[src]

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

`fn frf(&self) -> &Frf<Urt>`[src]

`fn frxth(&self) -> &Frxth<Urt>`[src]

`fn ldma_rx(&self) -> &LdmaRx<Urt>`[src]

`fn ldma_tx(&self) -> &LdmaTx<Urt>`[src]

`fn nssp(&self) -> &Nssp<Urt>`[src]

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

`fn rxneie(&self) -> &Rxneie<Urt>`[src]

`fn ssoe(&self) -> &Ssoe<Urt>`[src]

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

`fn txeie(&self) -> &Txeie<Urt>`[src]

`impl SSpiCr2<Spi3> for Reg<Srt>`[src]

`fn from_fields(map: SSpiCr2Fields<Spi3>) -> Self`[src]

`fn into_fields(self) -> SSpiCr2Fields<Spi3>`[src]

`fn ds(&self) -> &Ds<Srt>`[src]

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

`fn frf(&self) -> &Frf<Srt>`[src]

`fn frxth(&self) -> &Frxth<Srt>`[src]

`fn ldma_rx(&self) -> &LdmaRx<Srt>`[src]

`fn ldma_tx(&self) -> &LdmaTx<Srt>`[src]

`fn nssp(&self) -> &Nssp<Srt>`[src]

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

`fn rxneie(&self) -> &Rxneie<Srt>`[src]

`fn ssoe(&self) -> &Ssoe<Srt>`[src]

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

`fn txeie(&self) -> &Txeie<Srt>`[src]

`impl CSpiCr2<Spi3> for Reg<Crt>`[src]

`fn from_fields(map: CSpiCr2Fields<Spi3>) -> Self`[src]

`fn into_fields(self) -> CSpiCr2Fields<Spi3>`[src]

`fn ds(&self) -> &Ds<Crt>`[src]

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

`fn frf(&self) -> &Frf<Crt>`[src]

`fn frxth(&self) -> &Frxth<Crt>`[src]

`fn ldma_rx(&self) -> &LdmaRx<Crt>`[src]

`fn ldma_tx(&self) -> &LdmaTx<Crt>`[src]

`fn nssp(&self) -> &Nssp<Crt>`[src]

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

`fn rxneie(&self) -> &Rxneie<Crt>`[src]

`fn ssoe(&self) -> &Ssoe<Crt>`[src]

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

`fn txeie(&self) -> &Txeie<Crt>`[src]

`impl SpiSrBsy<Spi3> for Spi3`[src]

`type USpiSrBsy = Bsy<Urt>`

`type SSpiSrBsy = Bsy<Srt>`

`type CSpiSrBsy = Bsy<Crt>`

`impl SpiSrCrcerr<Spi3> for Spi3`[src]

`type USpiSrCrcerr = Crcerr<Urt>`

`type SSpiSrCrcerr = Crcerr<Srt>`

`type CSpiSrCrcerr = Crcerr<Crt>`

`impl SpiSrFrlvl<Spi3> for Spi3`[src]

`type USpiSrFrlvl = Frlvl<Urt>`

`type SSpiSrFrlvl = Frlvl<Srt>`

`type CSpiSrFrlvl = Frlvl<Crt>`

`impl SpiSrFtlvl<Spi3> for Spi3`[src]

`type USpiSrFtlvl = Ftlvl<Urt>`

`type SSpiSrFtlvl = Ftlvl<Srt>`

`type CSpiSrFtlvl = Ftlvl<Crt>`

`impl SpiSrModf<Spi3> for Spi3`[src]

`type USpiSrModf = Modf<Urt>`

`type SSpiSrModf = Modf<Srt>`

`type CSpiSrModf = Modf<Crt>`

`impl SpiSrOvr<Spi3> for Spi3`[src]

`type USpiSrOvr = Ovr<Urt>`

`type SSpiSrOvr = Ovr<Srt>`

`type CSpiSrOvr = Ovr<Crt>`

`impl SpiSrRxne<Spi3> for Spi3`[src]

`type USpiSrRxne = Rxne<Urt>`

`type SSpiSrRxne = Rxne<Srt>`

`type CSpiSrRxne = Rxne<Crt>`

`impl SpiSrTifrfe<Spi3> for Spi3`[src]

`type USpiSrTifrfe = Tifrfe<Urt>`

`type SSpiSrTifrfe = Tifrfe<Srt>`

`type CSpiSrTifrfe = Tifrfe<Crt>`

`impl SpiSrTxe<Spi3> for Spi3`[src]

`type USpiSrTxe = Txe<Urt>`

`type SSpiSrTxe = Txe<Srt>`

`type CSpiSrTxe = Txe<Crt>`

`impl SpiSr<Spi3> for Spi3`[src]

`type SpiSrVal = Val`

`type USpiSr = Reg<Urt>`

`type SSpiSr = Reg<Srt>`

`type CSpiSr = Reg<Crt>`

`impl USpiSr<Spi3> for Reg<Urt>`[src]

`fn from_fields(map: USpiSrFields<Spi3>) -> Self`[src]

`fn into_fields(self) -> USpiSrFields<Spi3>`[src]

`fn bsy(&self) -> &Bsy<Urt>`[src]

`fn crcerr(&self) -> &Crcerr<Urt>`[src]

`fn frlvl(&self) -> &Frlvl<Urt>`[src]

`fn ftlvl(&self) -> &Ftlvl<Urt>`[src]

`fn modf(&self) -> &Modf<Urt>`[src]

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

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

`fn tifrfe(&self) -> &Tifrfe<Urt>`[src]

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

`impl SSpiSr<Spi3> for Reg<Srt>`[src]

`fn from_fields(map: SSpiSrFields<Spi3>) -> Self`[src]

`fn into_fields(self) -> SSpiSrFields<Spi3>`[src]

`fn bsy(&self) -> &Bsy<Srt>`[src]

`fn crcerr(&self) -> &Crcerr<Srt>`[src]

`fn frlvl(&self) -> &Frlvl<Srt>`[src]

`fn ftlvl(&self) -> &Ftlvl<Srt>`[src]

`fn modf(&self) -> &Modf<Srt>`[src]

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

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

`fn tifrfe(&self) -> &Tifrfe<Srt>`[src]

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

`impl CSpiSr<Spi3> for Reg<Crt>`[src]

`fn from_fields(map: CSpiSrFields<Spi3>) -> Self`[src]

`fn into_fields(self) -> CSpiSrFields<Spi3>`[src]

`fn bsy(&self) -> &Bsy<Crt>`[src]

`fn crcerr(&self) -> &Crcerr<Crt>`[src]

`fn frlvl(&self) -> &Frlvl<Crt>`[src]

`fn ftlvl(&self) -> &Ftlvl<Crt>`[src]

`fn modf(&self) -> &Modf<Crt>`[src]

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

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

`fn tifrfe(&self) -> &Tifrfe<Crt>`[src]

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

`impl SpiDrDr<Spi3> for Spi3`[src]

`type USpiDrDr = Dr<Urt>`

`type SSpiDrDr = Dr<Srt>`

`type CSpiDrDr = Dr<Crt>`

`impl SpiDr<Spi3> for Spi3`[src]

`type SpiDrVal = Val`

`type USpiDr = Reg<Urt>`

`type SSpiDr = Reg<Srt>`

`type CSpiDr = Reg<Crt>`

`impl USpiDr<Spi3> for Reg<Urt>`[src]

`fn from_fields(map: USpiDrFields<Spi3>) -> Self`[src]

`fn into_fields(self) -> USpiDrFields<Spi3>`[src]

`fn dr(&self) -> &Dr<Urt>`[src]

`impl SSpiDr<Spi3> for Reg<Srt>`[src]

`fn from_fields(map: SSpiDrFields<Spi3>) -> Self`[src]

`fn into_fields(self) -> SSpiDrFields<Spi3>`[src]

`fn dr(&self) -> &Dr<Srt>`[src]

`impl CSpiDr<Spi3> for Reg<Crt>`[src]

`fn from_fields(map: CSpiDrFields<Spi3>) -> Self`[src]

`fn into_fields(self) -> CSpiDrFields<Spi3>`[src]

`fn dr(&self) -> &Dr<Crt>`[src]

`impl SpiCrcprCrcpoly<Spi3> for Spi3`[src]

`type USpiCrcprCrcpoly = Crcpoly<Urt>`

`type SSpiCrcprCrcpoly = Crcpoly<Srt>`

`type CSpiCrcprCrcpoly = Crcpoly<Crt>`

`impl SpiCrcpr<Spi3> for Spi3`[src]

`type SpiCrcprVal = Val`

`type USpiCrcpr = Reg<Urt>`

`type SSpiCrcpr = Reg<Srt>`

`type CSpiCrcpr = Reg<Crt>`

`impl USpiCrcpr<Spi3> for Reg<Urt>`[src]

`fn from_fields(map: USpiCrcprFields<Spi3>) -> Self`[src]

`fn into_fields(self) -> USpiCrcprFields<Spi3>`[src]

`fn crcpoly(&self) -> &Crcpoly<Urt>`[src]

`impl SSpiCrcpr<Spi3> for Reg<Srt>`[src]

`fn from_fields(map: SSpiCrcprFields<Spi3>) -> Self`[src]

`fn into_fields(self) -> SSpiCrcprFields<Spi3>`[src]

`fn crcpoly(&self) -> &Crcpoly<Srt>`[src]

`impl CSpiCrcpr<Spi3> for Reg<Crt>`[src]

`fn from_fields(map: CSpiCrcprFields<Spi3>) -> Self`[src]

`fn into_fields(self) -> CSpiCrcprFields<Spi3>`[src]

`fn crcpoly(&self) -> &Crcpoly<Crt>`[src]

`impl SpiRxcrcrRxCRC<Spi3> for Spi3`[src]

`type USpiRxcrcrRxCRC = RxCRC<Urt>`

`type SSpiRxcrcrRxCRC = RxCRC<Srt>`

`type CSpiRxcrcrRxCRC = RxCRC<Crt>`

`impl SpiRxcrcr<Spi3> for Spi3`[src]

`type SpiRxcrcrVal = Val`

`type USpiRxcrcr = Reg<Urt>`

`type SSpiRxcrcr = Reg<Srt>`

`type CSpiRxcrcr = Reg<Crt>`

`impl USpiRxcrcr<Spi3> for Reg<Urt>`[src]

`fn from_fields(map: USpiRxcrcrFields<Spi3>) -> Self`[src]

`fn into_fields(self) -> USpiRxcrcrFields<Spi3>`[src]

`fn rx_crc(&self) -> &RxCRC<Urt>`[src]

`impl SSpiRxcrcr<Spi3> for Reg<Srt>`[src]

`fn from_fields(map: SSpiRxcrcrFields<Spi3>) -> Self`[src]

`fn into_fields(self) -> SSpiRxcrcrFields<Spi3>`[src]

`fn rx_crc(&self) -> &RxCRC<Srt>`[src]

`impl CSpiRxcrcr<Spi3> for Reg<Crt>`[src]

`fn from_fields(map: CSpiRxcrcrFields<Spi3>) -> Self`[src]

`fn into_fields(self) -> CSpiRxcrcrFields<Spi3>`[src]

`fn rx_crc(&self) -> &RxCRC<Crt>`[src]

`impl SpiTxcrcrTxCRC<Spi3> for Spi3`[src]

`type USpiTxcrcrTxCRC = TxCRC<Urt>`

`type SSpiTxcrcrTxCRC = TxCRC<Srt>`

`type CSpiTxcrcrTxCRC = TxCRC<Crt>`

`impl SpiTxcrcr<Spi3> for Spi3`[src]

`type SpiTxcrcrVal = Val`

`type USpiTxcrcr = Reg<Urt>`

`type SSpiTxcrcr = Reg<Srt>`

`type CSpiTxcrcr = Reg<Crt>`

`impl USpiTxcrcr<Spi3> for Reg<Urt>`[src]

`fn from_fields(map: USpiTxcrcrFields<Spi3>) -> Self`[src]

`fn into_fields(self) -> USpiTxcrcrFields<Spi3>`[src]

`fn tx_crc(&self) -> &TxCRC<Urt>`[src]

`impl SSpiTxcrcr<Spi3> for Reg<Srt>`[src]

`fn from_fields(map: SSpiTxcrcrFields<Spi3>) -> Self`[src]

`fn into_fields(self) -> SSpiTxcrcrFields<Spi3>`[src]

`fn tx_crc(&self) -> &TxCRC<Srt>`[src]

`impl CSpiTxcrcr<Spi3> for Reg<Crt>`[src]

`fn from_fields(map: CSpiTxcrcrFields<Spi3>) -> Self`[src]

`fn into_fields(self) -> CSpiTxcrcrFields<Spi3>`[src]

`fn tx_crc(&self) -> &TxCRC<Crt>`[src]

`impl SpiMap for Spi3`[src]

Auto Trait Implementations

`impl Unpin for Spi3`

`impl Send for Spi3`

`impl Sync for Spi3`

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_spi::Spi3

Trait Implementations

impl RccBusenrSpien for Spi3[src]

type URccBusenrSpien = Spi3En<Urt>

type SRccBusenrSpien = Spi3En<Srt>

type CRccBusenrSpien = Spi3En<Crt>

impl RccBusenr for Spi3[src]

type RccBusenrVal = Val

type URccBusenr = Reg<Urt>

type SRccBusenr = Reg<Srt>

type CRccBusenr = Reg<Crt>

impl RccBusrstrSpirst for Spi3[src]

type URccBusrstrSpirst = Spi3Rst<Urt>

type SRccBusrstrSpirst = Spi3Rst<Srt>

type CRccBusrstrSpirst = Spi3Rst<Crt>

impl RccBusrstr for Spi3[src]

type RccBusrstrVal = Val

type URccBusrstr = Reg<Urt>

type SRccBusrstr = Reg<Srt>

type CRccBusrstr = Reg<Crt>

impl RccBussmenrSpismen for Spi3[src]

type URccBussmenrSpismen = Spi3Smen<Urt>

type SRccBussmenrSpismen = Spi3Smen<Srt>

type CRccBussmenrSpismen = Spi3Smen<Crt>

impl RccBussmenr for Spi3[src]

type RccBussmenrVal = Val

type URccBussmenr = Reg<Urt>

type SRccBussmenr = Reg<Srt>

type CRccBussmenr = Reg<Crt>

impl SpiCr1Bidimode<Spi3> for Spi3[src]

type USpiCr1Bidimode = Bidimode<Urt>

type SSpiCr1Bidimode = Bidimode<Srt>

type CSpiCr1Bidimode = Bidimode<Crt>

impl SpiCr1Bidioe<Spi3> for Spi3[src]

type USpiCr1Bidioe = Bidioe<Urt>

type SSpiCr1Bidioe = Bidioe<Srt>

type CSpiCr1Bidioe = Bidioe<Crt>

impl SpiCr1Br<Spi3> for Spi3[src]

type USpiCr1Br = Br<Urt>

type SSpiCr1Br = Br<Srt>

type CSpiCr1Br = Br<Crt>

impl SpiCr1Cpha<Spi3> for Spi3[src]

type USpiCr1Cpha = Cpha<Urt>

type SSpiCr1Cpha = Cpha<Srt>

type CSpiCr1Cpha = Cpha<Crt>

impl SpiCr1Cpol<Spi3> for Spi3[src]

type USpiCr1Cpol = Cpol<Urt>

type SSpiCr1Cpol = Cpol<Srt>

type CSpiCr1Cpol = Cpol<Crt>

impl SpiCr1Crcen<Spi3> for Spi3[src]

type USpiCr1Crcen = Crcen<Urt>

type SSpiCr1Crcen = Crcen<Srt>

type CSpiCr1Crcen = Crcen<Crt>

impl SpiCr1Crcnext<Spi3> for Spi3[src]

type USpiCr1Crcnext = Crcnext<Urt>

type SSpiCr1Crcnext = Crcnext<Srt>

type CSpiCr1Crcnext = Crcnext<Crt>

impl SpiCr1Dff<Spi3> for Spi3[src]

type USpiCr1Dff = Dff<Urt>

type SSpiCr1Dff = Dff<Srt>

type CSpiCr1Dff = Dff<Crt>

impl SpiCr1Lsbfirst<Spi3> for Spi3[src]

type USpiCr1Lsbfirst = Lsbfirst<Urt>

type SSpiCr1Lsbfirst = Lsbfirst<Srt>

type CSpiCr1Lsbfirst = Lsbfirst<Crt>

impl SpiCr1Mstr<Spi3> for Spi3[src]

type USpiCr1Mstr = Mstr<Urt>

type SSpiCr1Mstr = Mstr<Srt>

type CSpiCr1Mstr = Mstr<Crt>

impl SpiCr1Rxonly<Spi3> for Spi3[src]

type USpiCr1Rxonly = Rxonly<Urt>

type SSpiCr1Rxonly = Rxonly<Srt>

type CSpiCr1Rxonly = Rxonly<Crt>

impl SpiCr1Spe<Spi3> for Spi3[src]

type USpiCr1Spe = Spe<Urt>

type SSpiCr1Spe = Spe<Srt>

type CSpiCr1Spe = Spe<Crt>

impl SpiCr1Ssi<Spi3> for Spi3[src]

type USpiCr1Ssi = Ssi<Urt>

type SSpiCr1Ssi = Ssi<Srt>

`impl RccBusenrSpien for Spi3`[src]

`type URccBusenrSpien = Spi3En<Urt>`

`type SRccBusenrSpien = Spi3En<Srt>`

`type CRccBusenrSpien = Spi3En<Crt>`

`impl RccBusenr for Spi3`[src]

`type RccBusenrVal = Val`

`type URccBusenr = Reg<Urt>`

`type SRccBusenr = Reg<Srt>`

`type CRccBusenr = Reg<Crt>`

`impl RccBusrstrSpirst for Spi3`[src]

`type URccBusrstrSpirst = Spi3Rst<Urt>`

`type SRccBusrstrSpirst = Spi3Rst<Srt>`

`type CRccBusrstrSpirst = Spi3Rst<Crt>`

`impl RccBusrstr for Spi3`[src]

`type RccBusrstrVal = Val`

`type URccBusrstr = Reg<Urt>`

`type SRccBusrstr = Reg<Srt>`

`type CRccBusrstr = Reg<Crt>`

`impl RccBussmenrSpismen for Spi3`[src]

`type URccBussmenrSpismen = Spi3Smen<Urt>`

`type SRccBussmenrSpismen = Spi3Smen<Srt>`

`type CRccBussmenrSpismen = Spi3Smen<Crt>`

`impl RccBussmenr for Spi3`[src]

`type RccBussmenrVal = Val`

`type URccBussmenr = Reg<Urt>`

`type SRccBussmenr = Reg<Srt>`

`type CRccBussmenr = Reg<Crt>`

`impl SpiCr1Bidimode<Spi3> for Spi3`[src]

`type USpiCr1Bidimode = Bidimode<Urt>`

`type SSpiCr1Bidimode = Bidimode<Srt>`

`type CSpiCr1Bidimode = Bidimode<Crt>`

`impl SpiCr1Bidioe<Spi3> for Spi3`[src]

`type USpiCr1Bidioe = Bidioe<Urt>`

`type SSpiCr1Bidioe = Bidioe<Srt>`

`type CSpiCr1Bidioe = Bidioe<Crt>`

`impl SpiCr1Br<Spi3> for Spi3`[src]

`type USpiCr1Br = Br<Urt>`

`type SSpiCr1Br = Br<Srt>`

`type CSpiCr1Br = Br<Crt>`

`impl SpiCr1Cpha<Spi3> for Spi3`[src]

`type USpiCr1Cpha = Cpha<Urt>`

`type SSpiCr1Cpha = Cpha<Srt>`

`type CSpiCr1Cpha = Cpha<Crt>`

`impl SpiCr1Cpol<Spi3> for Spi3`[src]

`type USpiCr1Cpol = Cpol<Urt>`

`type SSpiCr1Cpol = Cpol<Srt>`

`type CSpiCr1Cpol = Cpol<Crt>`

`impl SpiCr1Crcen<Spi3> for Spi3`[src]

`type USpiCr1Crcen = Crcen<Urt>`

`type SSpiCr1Crcen = Crcen<Srt>`

`type CSpiCr1Crcen = Crcen<Crt>`

`impl SpiCr1Crcnext<Spi3> for Spi3`[src]

`type USpiCr1Crcnext = Crcnext<Urt>`

`type SSpiCr1Crcnext = Crcnext<Srt>`

`type CSpiCr1Crcnext = Crcnext<Crt>`

`impl SpiCr1Dff<Spi3> for Spi3`[src]

`type USpiCr1Dff = Dff<Urt>`

`type SSpiCr1Dff = Dff<Srt>`

`type CSpiCr1Dff = Dff<Crt>`

`impl SpiCr1Lsbfirst<Spi3> for Spi3`[src]

`type USpiCr1Lsbfirst = Lsbfirst<Urt>`

`type SSpiCr1Lsbfirst = Lsbfirst<Srt>`

`type CSpiCr1Lsbfirst = Lsbfirst<Crt>`

`impl SpiCr1Mstr<Spi3> for Spi3`[src]

`type USpiCr1Mstr = Mstr<Urt>`

`type SSpiCr1Mstr = Mstr<Srt>`

`type CSpiCr1Mstr = Mstr<Crt>`

`impl SpiCr1Rxonly<Spi3> for Spi3`[src]

`type USpiCr1Rxonly = Rxonly<Urt>`

`type SSpiCr1Rxonly = Rxonly<Srt>`

`type CSpiCr1Rxonly = Rxonly<Crt>`

`impl SpiCr1Spe<Spi3> for Spi3`[src]

`type USpiCr1Spe = Spe<Urt>`

`type SSpiCr1Spe = Spe<Srt>`

`type CSpiCr1Spe = Spe<Crt>`

`impl SpiCr1Ssi<Spi3> for Spi3`[src]

`type USpiCr1Ssi = Ssi<Urt>`

`type SSpiCr1Ssi = Ssi<Srt>`

`type CSpiCr1Ssi = Ssi<Crt>`

`impl SpiCr1Ssm<Spi3> for Spi3`[src]