can you send me perticular pdf of that question?hi Dilse,
Welcome to AAC.
Your question covers a lot of ground.
Have a look thru this PDF.
E
http://www.kelm.ftn.uns.ac.rs/literatura/mrv/Real-Time Systems Development.pdf
They are all related in the process of moving data from A to B. DMA normally uses interrupts to notify the cpu the block transfer is done or needs more data. In a single low-level driver you might use all three methods depending on conditions.I kinda fail to see what direct memory access has to do with polling and interrupt.
/* spi interrupt in single vector sw0 */
static void spi_rx_irq(spi_t bus)
{
uint8_t rdata __attribute__((unused));
while (!((SPIxSTAT(pic_spi[bus]) & _SPI1STAT_SPIRBE_MASK))) {
if (pic_spi[bus].in) {
*pic_spi[bus].in++ = SPIxBUF(pic_spi[bus]);
}
else {
/* dump the received data with no callback */
rdata = SPIxBUF(pic_spi[bus]);
}
if (!--pic_spi[bus].len) {
pic_spi[bus].complete = true;
}
}
}
static inline void _spi_transfer_bytes_async(spi_t bus, spi_cs_t cs, bool cont,
const void *out, void *in, size_t len)
{
const uint8_t *out_buffer = (const uint8_t *) out;
uint8_t dma_able = 8; /* default to NO DMA to trigger default method */
(void) cs;
(void) cont;
/* set input buffer params for the non-dma isr mode */
pic_spi[bus].in = in;
pic_spi[bus].len = len;
pic_spi[bus].complete = false;
/* check if we have both buffers */
if (out && in) {
dma_able = 0;
}
/* Translate a kernel (KSEG) virtual address to a physical address. */
switch (bus + dma_able) {
case 1:
trigger_bus_dma_rx(SPI1_DMA_RX, len, KVA_TO_PA(in));
trigger_bus_dma_tx(SPI1_DMA_TX, len, KVA_TO_PA(out_buffer));
break;
case 2:
trigger_bus_dma_rx(SPI2_DMA_RX, len, KVA_TO_PA(in));
trigger_bus_dma_tx(SPI2_DMA_TX, len, KVA_TO_PA(out_buffer));
break;
default: /* non-dma mode */
while (len--) {
if (out_buffer) {
SPIxBUF(pic_spi[bus]) = *out_buffer++;
/* Wait until TX FIFO is empty */
while ((SPIxSTAT(pic_spi[bus]) & _SPI1STAT_SPITBF_MASK)) {}
}
else {
SPIxBUF(pic_spi[bus]) = 0;
/* Wait until TX FIFO is empty */
while ((SPIxSTAT(pic_spi[bus]) & _SPI1STAT_SPITBF_MASK)) {}
}
}
}
}
void spi_transfer_bytes(spi_t bus, spi_cs_t cs, bool cont,
const void *out, void *in, size_t len)
{
assert(bus != 0 && bus <= SPI_NUMOF_USED);
/* make sure at least one input or one output buffer is given */
assert(out || in);
if (cs != SPI_CS_UNDEF) {
gpio_clear((gpio_t) cs);
}
_spi_transfer_bytes_async(bus, cs, cont, out, in, len);
while (!spi_complete(bus)) {}
if (!cont && cs != SPI_CS_UNDEF) {
gpio_set((gpio_t) cs);
}
}
void spi_1_isr_rx(void)
{
spi_rx_irq(1);
}
void spi_2_isr_rx(void)
{
spi_rx_irq(2);
}
void spi_3_isr_rx(void)
{
spi_rx_irq(3);
}
/* set transfer complete flag */
void dma_spi_1_isr_rx(void)
{
pic_spi[1].complete = true;
}
void dma_spi_2_isr_rx(void)
{
pic_spi[2].complete = true;
}
/* not currently used */
void dma_spi_3_isr_rx(void)
{
pic_spi[3].complete = true;
}
int32_t spi_complete(spi_t bus)
{
assert(bus != 0 && bus <= SPI_NUMOF);
return pic_spi[bus].complete;
}
There is an _amazing_ resource. It's called: ..... GOOGLE!i am currently working on STM32F4 boards and i want to know the Difference Between polling,DMA and Interrupt?and which is the best way to use communication in UART,SPI,I2C? please provide me with example codes for each.