Visão Geral da Periférica SPI

A frequência de clock do SPI corresponde à frequência do sinal SCK, onde cada ciclo transporta um bit. A taxa de transferência é determinada pela divisão do clock do barramento (fPCLK) por um prescaler configurável entre 2, 4, 8, 16, 32, 64, 128 ou 256. Como o SPI1 está conectado ao APB2 (72 MHz), sua frequência máxima atinge 36 MHz com prescaler de 2. Já o SPI2, ligado ao APB1 (36 MHz), atinge no máximo 18 MHz. Comparado ao I2C, limitado a 400 kHz, o SPI é consideravelmente mais rápido.

Arquitetura Interna do SPI

O componente central é o registrador de deslocamento (shift register). Na configuração padrão (MSB first), os bits saem pela linha MOSI a partir do bit mais significativo, enquanto os dados de MISO entram pelo lado oposto. O bit LSBFIRST no registrador de controle permite inverter a ordem para LSB first.

Um bloco de comutação interno reconfigura os pinos MOSI/MISO conforme o modo de operação. Em modo mestre, MOSI funciona como saída de dados e MISO como entrada. Em modo escravo, a função dos pinos é invertida através desse circuito de cruzamento.

O projeto inclui dois buffers: o registrador de transmissão (TDR) e o de recepção (RDR), ambos mapeados no mesmo endereço (DR). Ao escrever em DR, os dados vão para o TDR; ao ler DR, os dados vêm do RDR. Essa arquitetura permite pipeline contínuo: assim que o shift register fica livre, o conteúdo do TDR é transferido automaticamente, liberando o flag TXE. O software pode então pré-carregar o próximo byte no TDR antes do término da transmissão atual, garantindo fluxo ininterrupto.

Na recepção, ao concluir o deslocamento de um byte, os dados são movidos do shift register para o RDR, ativando o flag RXNE. É essencial ler o RDR antes que o próximo byte chegue, evitando sobrescrita.

Principais bits de configuração:

• SPE: habilita o periférico SPI
• BR: define o prescaler do clock
• MSTR: seleciona modo mestre (1) ou escravo (0)
• CPOL/CPHA: definem o modo do clock (0 a 3)
• LSBFIRST: ordem de transmissão dos bits

O pino NSS (Negative Slave Select) foi projetado para suporte a multi-mestre. Quando configurado como saída (SSOE=1), sinaliza a outros dispositivos que o dispositivo atual assumiu o papel de mestre. Como entrada, impede que o dispositivo se torne mestre se outro já reivindicou o barramento. No entanto, para seleção de escravos múltiplos, é mais prático controlar o pino SS via GPIO por software, já que cada escravo requer seu próprio sinal de seleção.

Modo Mestre: Transmissão Contínua vs. Não-Contínua

Transmissão Contínua

Utilizando SPI modo 3 (CPOL=1, CPHA=1), SCK permanece em nível alto em repouso. No primeiro flanco de descida, os dados são deslocados para fora; no flanco de subida, os dados são amostrados. O fluxo ocorre da seguinte forma:

1. SS é colocado em baixo para iniciar a comunicação
2. O software escreve o primeiro byte em DR; o TDR recebe o valor e TXE vai a 0
3. O shift register, estando vazio, absorve imediatamente o byte do TDR, TXE volta a 1
4. A geração do clock começa automaticamente, emitindo os bits pela MOSI
5. Antes do término do byte atual, o software verifica TXE=1 e pré-carrega o próximo byte no TDR
6. Ao concluir a transmissão, o shift register absorve o próximo byte sem gap
7. Simultaneamente, os dados recebidos via MISO são transferidos para o RDR, ativando RXNE

Transmissão Não-Contínua

Nesta abordagem, após TXE=1, o software aguarda a conclusão completa do byte atual (RXNE=1) antes de escrever o próximo. O procedimento simplifica-se a quatro etapas repetíveis:

1. Aguardar TXE=1
2. Escrever o byte no DR
3. Aguardar RXNE=1
4. Ler o byte recebido do DR

Embora a lógica seja mais simples, surge um intervalo morto entre bytes consecutivos, pois o TDR não é pré-carregado. Em frequências baixas de SCK, esse gap é insignificante, mas em altas frequências o impacto no throughput é notável.

Comparação: SPI por Software vs. Hardware

A implementação por hardware elimina a sobrecarga de toggling manual de GPIOs para o clock, reduzindo significativamente o tempo por byte. A geração automática do SCK pelo periférico, combinada com os buffers TDR/RDR, possibilita throughput muito superior, especialmente em transferências contínuas.

Funções da Biblioteca Padrão

SPI_I2S_SendData(SPI_TypeDef* SPIx, uint16_t data) — Escreve um dado no registrador DR para transmissão.

SPI_I2S_ReceiveData(SPI_TypeDef* SPIx) — Retorna o valor mais recente recebido, lido do RDR.

SPI_I2S_GetFlagStatus(SPI_TypeDef* SPIx, uint16_t flag) — Verifica o estado de flags como TXE, RXNE, BSY, OVR, MODF, CRCERR.

SPI_I2S_ClearFlag(SPI_TypeDef* SPIx, uint16_t flag) — Limpa flags pendentes. Nota: OVR exige leitura sequencial de DR seguida de SR; MODF requer leitura de SR seguida de escrita em CR1.

Conexões de Hardware

O W25Q64 é interligado ao STM32 da segunite forma:

• PA4 (GPIO) → CS (Chip Select do W25Q64)
• PA5 (SPI1_SCK) → CLK
• PA6 (SPI1_MISO) → DO
• PA7 (SPI1_MOSI) → DI
• VCC/3.3V e GND comuns

Implementação do Driver SPI

spi_driver.c

#include "stm32f10x.h"

// Controle do pino de seleção via GPIO
static void spi_select_slave(uint8_t state)
{
    GPIO_WriteBit(GPIOA, GPIO_Pin_4, (BitAction)state);
}

void spi_hw_init(void)
{
    // Habilita clocks dos periféricos
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_SPI1, ENABLE);

    // Configuração dos pinos
    GPIO_InitTypeDef port_cfg;

    // PA4: saída push-pull para CS (controle por software)
    port_cfg.GPIO_Mode = GPIO_Mode_Out_PP;
    port_cfg.GPIO_Pin = GPIO_Pin_4;
    port_cfg.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOA, &port_cfg);

    // PA5 (SCK) e PA7 (MOSI): saída push-pull alternada
    port_cfg.GPIO_Mode = GPIO_Mode_AF_PP;
    port_cfg.GPIO_Pin = GPIO_Pin_5 | GPIO_Pin_7;
    GPIO_Init(GPIOA, &port_cfg);

    // PA6 (MISO): entrada com pull-up
    port_cfg.GPIO_Mode = GPIO_Mode_IPU;
    port_cfg.GPIO_Pin = GPIO_Pin_6;
    GPIO_Init(GPIOA, &port_cfg);

    // Configuração do periférico SPI1
    SPI_InitTypeDef spi_cfg;
    spi_cfg.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
    spi_cfg.SPI_Mode = SPI_Mode_Master;
    spi_cfg.SPI_DataSize = SPI_DataSize_8b;
    spi_cfg.SPI_CPOL = SPI_CPOL_Low;
    spi_cfg.SPI_CPHA = SPI_CPHA_1Edge;
    spi_cfg.SPI_NSS = SPI_NSS_Soft;
    spi_cfg.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_128;
    spi_cfg.SPI_FirstBit = SPI_FirstBit_MSB;
    spi_cfg.SPI_CRCPolynomial = 7;
    SPI_Init(SPI1, &spi_cfg);

    SPI_Cmd(SPI1, ENABLE);
    spi_select_slave(1);  // CS em alto (inativo)
}

void spi_begin_transaction(void)
{
    spi_select_slave(0);
}

void spi_end_transaction(void)
{
    spi_select_slave(1);
}

// Troca um byte via SPI (modo não-contínuo)
uint8_t spi_transfer_byte(uint8_t tx_data)
{
    // Aguarda o TDR ficar disponível
    while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) == RESET);
    SPI_I2S_SendData(SPI1, tx_data);

    // Aguarda chegada do dado recebido
    while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET);
    return SPI_I2S_ReceiveData(SPI1);
}

spi_driver.h

#ifndef __SPI_DRIVER_H
#define __SPI_DRIVER_H

#include <stdint.h>

void spi_hw_init(void);
void spi_begin_transaction(void);
void spi_end_transaction(void);
uint8_t spi_transfer_byte(uint8_t tx_data);

#endif

Aplicação Principal

#include "stm32f10x.h"
#include "Delay.h"
#include "OLED.h"
#include "W25Q64.h"

int main(void)
{
    uint8_t manufacturer_id = 0;
    uint16_t device_id = 0;

    uint8_t write_payload[] = {0xA1, 0xB2, 0xC3, 0xD4};
    uint8_t read_buffer[4] = {0};

    OLED_Init();
    W25Q64_Init();

    // Exibição do cabeçalho
    OLED_ShowString(1, 1, "MID:   DID:");
    OLED_ShowString(2, 1, "W:");
    OLED_ShowString(3, 1, "R:");

    // Leitura e exibição dos IDs do chip
    W25Q64_ReadID(&manufacturer_id, &device_id);
    OLED_ShowHexNum(1, 5, manufacturer_id, 2);
    OLED_ShowHexNum(1, 12, device_id, 4);

    // Teste de gravação e leitura
    W25Q64_SectorErase(0x000000);
    W25Q64_PageProgram(0x000000, write_payload, 4);
    W25Q64_ReadData(0x000000, read_buffer, 4);

    // Exibe dados gravados
    OLED_ShowHexNum(2, 3, write_payload[0], 2);
    OLED_ShowHexNum(2, 6, write_payload[1], 2);
    OLED_ShowHexNum(2, 9, write_payload[2], 2);
    OLED_ShowHexNum(2, 12, write_payload[3], 2);

    // Exibe dados lidos
    OLED_ShowHexNum(3, 3, read_buffer[0], 2);
    OLED_ShowHexNum(3, 6, read_buffer[1], 2);
    OLED_ShowHexNum(3, 9, read_buffer[2], 2);
    OLED_ShowHexNum(3, 12, read_buffer[3], 2);

    while (1)
    {
        // Loop principal
    }
}

A função spi_transfer_byte encapsula as quatro etapas da transmissão não-contínua: espera do TXE, escrita no DR, espera do RXNE e leitura do dado. Essa abordagem mantém a simlpicidade do SPI por software, mas aproveita o controlador de hardware para geração automática de clock e amostragem, resultando em temporização mais precisa e desempenho superior.