O Arduino Due foi o primeiro Arduino oficial a usar um microcontrolador fora da linha ATmega. O escolhido foi o AT91SAM3X8E,também da Atmel. Com um núcleo ARM Cortex M3 de 32 bits rodando a 84MHz, 96K de Ram e 512K de Flash, ele possui uma capacidade de processamento muito maior que o ATmega328 do Uno. Em termos de periféricos, ele também possui muitos recursos adicionais, como o DMA que veremos aqui. Infelizmente, o Due não alcançou muita popularidade, talvez por trabalhar a 3,3 V ao invés dos 5 V usados no Uno.
O DMA – Direct Memory Access – é um recurso que permite executar tarefas de movimentação de dados entre a memória e periféricos sem intervenção direta do processador. Para entender melhor, vejamos um exemplo, considerando um display ligado via I2C.
Material necessário
Para montar o nosso exemplo, vamos precisar de:
Como funciona o DMA
Na operação sem DMA (única forma disponível no Arduino UNO), o programa escreve os bytes a serem enviados ao display um a um no periférico de I2C. Antes de enviar um byte é preciso garantir que o byte anterior já foi enviado, o que é feito monitorando um registrador de status ou aguardando uma interrupção. O resultado é uma grande atividade do processador (se não usarmos interrupção ele ficará o tempo todo ocupado com esta atividade).
No Due, podemos programar o DMA para copiar os bytes de uma região da memória para o dispositivo de I2C. Uma vez feito o disparo, o processador só precisa intervir quando a transferência foi concluída. Durante a transferência em si o processador está livre. Isto pode fazer uma grande diferença quando desejamos atualizar continuamente o display todo. Sem DMA, o processador alterna entre gerar a próximo imagem e enviá-la ao display; com DMA a próxima imagem pode ser gerada enquanto a anterior está sendo enviada.
Um detalhe interessante é que o SAM3X possui vários DMAs. Vou usar aqui o Peripheral DMA (PDC) que é específico para uso com os periféricos seriais. A programação do PDC é mais simples e ele está integrado aos registradores dos periféricos seriais. O periférico que implementa o I2C é o TWI (Two Wire Interface).
Na figura acima podemos ver:
- Os registradores TWI_RPR e TWI_RCR indicam o endereço e tamanho do buffer usado na recepção.
- Os registradores TWI_TPR e TWI_TCR indicam o endereço e tamanho do buffer usado na transmissão.
- Os status RX_READY e TX_READY (no periférico TWI) indicam para o PDC quando um byte foi recebido ou o TWI está pronto para transmitir um byte, Estes sinais são o que disparam a transferência de um byte entre o periférico e a memória.
- Os status END_RX e END_TX no TWI são atualizados pelo PDC para indicar que todo o buffer foi recebido ou transmitido.
A biblioteca do Arduino não possui funções para manipulação do DMA, é necessário usar bibliotecas de mais baixo nível e acessar diretamente o hardware. A documentação básica para escrever o código é o datasheet do microcontrolador. A programação (sem DMA) do TWI pode ser vistas nos fontes da biblioteca do Arduino, que são instalados no seu micro quando você instala do suporte ao Arduino Due. São também instalados os fontes da Atmel com as definições das estruturas e rotinas de baixo nível.
Programa para a comunicação usando DMA
Juntando tudo isso com um pouco de experimentação, cheguei ao exemplo abaixo:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 |
/* * Teste da comunicação do Arduino Due com display I2C usando DMA * O display deve estar conectado a SDA/SCL (pinos 20 e 21) que correspondem a * WIRE_INTERFACE (Arduino) / TWI1 (Atmel) */ // Inclui o driver da Atmel #include <include/twi.h> // Endereço I2C do display #define DISP_ADDR 0x3C // Controle da comunicação com o display typedef enum { DISP_INATIVO, DISP_INIT, DISP_CMDTELA, DISP_TELA } STATUS_DISP; volatile STATUS_DISP stDisplay = DISP_INATIVO; // Comandos do controlador do display #define SSD1306_SETCONTRAST 0x81 #define SSD1306_DISPLAYALLON_RESUME 0xA4 #define SSD1306_DISPLAYALLON 0xA5 #define SSD1306_NORMALDISPLAY 0xA6 #define SSD1306_INVERTDISPLAY 0xA7 #define SSD1306_DISPLAYOFF 0xAE #define SSD1306_DISPLAYON 0xAF #define SSD1306_SETDISPLAYOFFSET 0xD3 #define SSD1306_SETCOMPINS 0xDA #define SSD1306_SETVCOMDETECT 0xDB #define SSD1306_SETDISPLAYCLOCKDIV 0xD5 #define SSD1306_SETPRECHARGE 0xD9 #define SSD1306_SETMULTIPLEX 0xA8 #define SSD1306_SETLOWCOLUMN 0x00 #define SSD1306_SETHIGHCOLUMN 0x10 #define SSD1306_SETSTARTLINE 0x40 #define SSD1306_MEMORYMODE 0x20 #define SSD1306_COLUMNADDR 0x21 #define SSD1306_PAGEADDR 0x22 #define SSD1306_COMSCANINC 0xC0 #define SSD1306_COMSCANDEC 0xC8 #define SSD1306_SEGREMAP 0xA0 #define SSD1306_CHARGEPUMP 0x8D #define SSD1306_EXTERNALVCC 0x1 #define SSD1306_SWITCHCAPVCC 0x2 // Tamanho da tela #define SSD1306_LCDWIDTH 128 #define SSD1306_LCDHEIGHT 64 #define TAM_TELA (SSD1306_LCDWIDTH*SSD1306_LCDHEIGHT/8) // Buffers para atualização da tela uint8_t tela0[TAM_TELA+1]; uint8_t tela1[TAM_TELA+1]; // itela indica o buffer onde deve ser montada a próxima tela uint8_t itela = 0; // tabela de senos uint8_t seno[SSD1306_LCDWIDTH]; // Iniciação void setup() { // Inicia o display Twi_init(); Display_init(); // Pré-calcula senos for (int i = 0; i < SSD1306_LCDWIDTH; i++) { seno[i] = (uint8_t) ((sin(i/20.0)+1)*30.0); } } // Loop eterno void loop() { // Descomentar o trecho abaixo para não desenhar em paralelo ao envio //while (!Twi_FimTfa()) { //} // Determina buffer a usar uint8_t *tela = (itela == 0) ? tela0 : tela1; tela++; // Apaga desenho anterior static int inicio = 0; for (int i = 0; i < SSD1306_LCDWIDTH; i++) { int y = seno[(i+inicio) % SSD1306_LCDWIDTH]; int pos = (y/8)*SSD1306_LCDWIDTH + i; tela[pos] &= ~ (1 << (y % 8)); } // Faz o novo desenho inicio = (inicio + 1) % SSD1306_LCDWIDTH; for (int i = 0; i < SSD1306_LCDWIDTH; i++) { int y = seno[(i+inicio) % SSD1306_LCDWIDTH]; int pos = (y/8)*SSD1306_LCDWIDTH + i; tela[pos] |= 1 << (y % 8); } // Atualiza o display (espera acabar a apresentação da tela anterior se necessário) Display_refresh(); } // Sequência de iniciação do display uint8_t cmdInit[] = { 0, // Co= 0, DC = 0 SSD1306_DISPLAYOFF, SSD1306_SETDISPLAYCLOCKDIV, 0x80, SSD1306_SETMULTIPLEX, 0x3F, SSD1306_SETDISPLAYOFFSET, 0x00, SSD1306_SETSTARTLINE | 0x0, SSD1306_CHARGEPUMP, 0x14, SSD1306_MEMORYMODE, 0x00, SSD1306_SEGREMAP | 0x1, SSD1306_COMSCANDEC, SSD1306_SETCOMPINS, 0x12, SSD1306_SETCONTRAST, 0xCF, SSD1306_SETPRECHARGE, 0xF1, SSD1306_SETVCOMDETECT, 0x40, SSD1306_DISPLAYALLON_RESUME, SSD1306_NORMALDISPLAY }; // Inicia a apresentação do display uint8_t cmdStart[] = { 0, // Co= 0, DC = 0 SSD1306_DISPLAYON }; // Sequência para atualização do display uint8_t cmdTela[] = { // Indica comando 0, // Co= 0, DC = 0 // Define endereços iniciais e finais de colunas e páginas SSD1306_COLUMNADDR, 0, SSD1306_LCDWIDTH-1, SSD1306_PAGEADDR, 0, 7 }; // Iniciação do display void Display_init() { Twi_send (DISP_ADDR, cmdInit, sizeof(cmdInit), DISP_INIT); delay(10); // Precisa dar um tempo antes de iniciar a apresentação Twi_send (DISP_ADDR, cmdStart, sizeof(cmdStart), DISP_INIT); tela0[0] = tela1[0] = 0x40; // Co=0, DC = 1 itela = 0; Display_clear(); } // Limpa o display void Display_clear() { uint8_t *tela; tela = (itela == 0) ? tela0 : tela1; memset (tela+1, 0, TAM_TELA); Display_refresh(); } // Envia a tela atual para o display e chaveia para o outro buffer void Display_refresh () { // copia o conteudo atual if (itela == 0) { memcpy (tela1, tela0, sizeof(tela0)); } else { memcpy (tela0, tela1, sizeof(tela0)); } // Garante que o refresh anterior terminou while (!Twi_FimTfa()) { } //chaveia a tela itela ^= 1; // dispara o envio do comando de atualização Twi_send (DISP_ADDR, cmdTela, sizeof(cmdTela), DISP_CMDTELA); } /* Parte de Baixo Nível */ Twi *twi = WIRE_INTERFACE; // Lembrando que WIRE_INTERFACE = TWI1 static const uint32_t TWI_CLOCK = 400000; // Fast I2C, para normal usar 100000 // Iniciação do TWI1 void Twi_init() { // Desabilita o DMA twi->TWI_PTCR = TWI_PTCR_RXTDIS | TWI_PTCR_TXTDIS; // Habilita clock pmc_enable_periph_clk(WIRE_INTERFACE_ID); // Configura os pinos PIO_Configure(g_APinDescription[PIN_WIRE_SDA].pPort, g_APinDescription[PIN_WIRE_SDA].ulPinType, g_APinDescription[PIN_WIRE_SDA].ulPin, g_APinDescription[PIN_WIRE_SDA].ulPinConfiguration); PIO_Configure(g_APinDescription[PIN_WIRE_SCL].pPort, g_APinDescription[PIN_WIRE_SCL].ulPinType, g_APinDescription[PIN_WIRE_SCL].ulPin, g_APinDescription[PIN_WIRE_SCL].ulPinConfiguration); // Desabilita interrupção NVIC_DisableIRQ(WIRE_ISR_ID); // Configura TWI1 para mestre TWI_ConfigureMaster(twi, TWI_CLOCK, VARIANT_MCK); } // Dispara o envio de um buffer por DMA void Twi_send (uint8_t addrSlave, uint8_t *addrBuffer, uint16_t tamBuffer, STATUS_DISP novoStatus) { // Configura o endereço I2C para o qual será feita a transmissão twi->TWI_MMR = 0; twi->TWI_MMR = addrSlave << 16; // Configurar a transferência no DMA twi->TWI_TPR = (uint32_t) addrBuffer; twi->TWI_TCR = tamBuffer; // Interromper quando DMA finalizar de enviar os bytes (para enviarmos o stop) stDisplay = novoStatus; //TWI_EnableIt(twi, TWI_IER_ENDTX); // ERRO NO ASSERT twi->TWI_IER = TWI_IER_ENDTX | TWI_IER_TXCOMP; // Dispara a transferência NVIC_ClearPendingIRQ(WIRE_ISR_ID); NVIC_EnableIRQ(WIRE_ISR_ID); twi->TWI_PTCR = TWI_PTCR_TXTEN; } // Interrupção do TWI1 - enviar stop e disparar buffer seguinte se for o caso void WIRE_ISR_HANDLER(void) { // Le o status uint32_t sr = TWI_GetStatus(twi); if (sr & TWI_SR_TXCOMP) { // Terminou de enviar o STOP if (stDisplay == DISP_CMDTELA) { // Disparar o envio dos dados da tela uint8_t *tela = (itela == 0) ? tela1 : tela0; Twi_send (DISP_ADDR, tela, sizeof(tela0), DISP_TELA); } else { // Encerrado NVIC_DisableIRQ(WIRE_ISR_ID); stDisplay = DISP_INATIVO; } } else if (sr & TWI_SR_ENDTX) { // Terminou de enviar os dados // Desliga o DMA twi->TWI_PTCR = TWI_PTCR_RXTDIS | TWI_PTCR_TXTDIS; // Envia Stop TWI_Stop(twi); } } // Verifica se acabou a transmissão (stop da ultima parte foi enviado) uint8_t Twi_FimTfa() { return stDisplay == DISP_INATIVO; } |
Qualquer problema que você pode ter ao programar a placa Due, você pode checar o nosso post explicando como utilizá-la.
E aí, curtiu comunicar com o display usando DMA? Você pode nos ajudar a melhorar o blog comentando abaixo.
Very interesting tutorial! Do you have an example of how also use the DMA read of I2C interface?
No, so far I’ve only used DMA for I2C and SPI writing.