Tuesday, October 13, 2026

SPI — 🔌

SPI — Protocoles série — I²C, SPI, USART et CAN bus en un seul document

Black Pill STM32F411 · Bus synchrone full duplex

SPI : une horloge, deux sens, un fil de sélection par esclave.

Le SPI est la liaison la plus rapide du cours : mémoires flash, écrans, DAC, cartes SD. Principe, animation des quatre modes, registres et HAL du STM32F411.

1. Comment ça marche

SignalSensRôle
SCKmaître → esclaveHorloge
MOSImaître → esclaveDonnées du maître
MISOesclave → maîtreDonnées de l’esclave
CS (NSS)maître → esclaveSélection, actif bas

Maître et esclave contiennent chacun un registre à décalage : à chaque coup d’horloge un bit sort du maître et un bit sort de l’esclave, ils forment un anneau. Un transfert est donc toujours un échange. Pour lire, le maître envoie un octet sans importance (0xFF ou 0x00).

ModeCPOLCPHAHorloge au reposÉchantillonnage
000BasFront montant
101BasFront descendant
210HautFront descendant
311HautFront montant

Le mode est imposé par l’esclave (datasheet). Modes 0 et 3 les plus fréquents. Durée : Toctet = 8 / fSCK ; à 1 MHz, 8 µs par octet.

AvantagesLimites
Très rapide (dizaines de MHz), full duplex, simpleUn CS par esclave, 4 fils minimum
Pas de pull-upAucun adressage ni ACK : le maître ne sait pas si l’esclave est là

2. Animation : une transaction, quatre fils

SPI

Quatre fils, une horloge, et aucune conversation.

SPI n'a ni adresse ni accusé de réception : le maître fabrique l'horloge, met le chip select à l'état bas, et les deux côtés décalent leurs bits en même temps. La seule chose à convenir à l'avance est quand un bit est échantillonné — et c'est précisément ce que décrivent CPOL et CPHA.

Horloge
Produite par le maître — SCLK au repos à CPOL
Trame
CS bas sélectionne un esclave pour toute la rafale
Direction
Full duplex — MOSI et MISO défilent ensemble
Ordre des bits
MSB d'abord, 8 bits par octet

Forme d'onde en direct

Une transaction : 16 bits, quatre fils

REPOS

Le chip select est à l'état haut, l'esclave ignore le bus et SCLK reste à son niveau de repos.

front d'échantillonnage — le bit est verrouillé ici front de décalage — la donnée change ici frontière d'octet
t 0.00
Chip selectHAUT — inactif
Repos de l'horlogeBAS
Front d'échantillonnagemontant (1er)
SCLK1 MHz
MOSI capturé—
MISO capturé—
CS

Actif à l'état bas. Une impulsion basse sélectionne un esclave et encadre toute la rafale d'octets.

SCLK

Produite par le maître. Elle reste au niveau CPOL et bascule deux fois par bit.

MOSI

Du maître vers l'esclave. Les bits sortent MSB d'abord et changent au front de décalage.

MISO

De l'esclave vers le maître. Elle bouge sur les mêmes fronts, les deux sens avancent ensemble.

ModeCPOLCPHANiveau de reposFront d'échantillonnageLa donnée change
Mode 000BASmontant (1er)descendant
Mode 101BASdescendant (2e)montant
Mode 210HAUTdescendant (1er)montant
Mode 311HAUTmontant (2e)descendant

Le SPI est en push-pull sur les quatre fils : le transmetteur pilote activement les deux niveaux, donc pas de résistance de pull-up, pas de ligne open-drain à relâcher, et pas d'accusé de réception. Le maître choisit la vitesse de l'horloge, et l'esclave n'écoute que tant que CS est bas.

3. Le SPI du STM32F411

SPISCKMISOMOSINSSAFBus
SPI1PA5PA6PA7PA4AF5APB2 (≤ 100 MHz)
SPI2PB13PB14PB15PB12AF5APB1
SPI3PB3PB4PB5PA15AF6APB1

fSCK = fPCLK / prédiviseur (2 à 256). Exemple : 16 MHz / 16 = 1 MHz.

BR[2:0]Div.BR[2:0]Div.
000210032
001410164
0108110128
01116111256
Dans ce cours CS est une GPIO ordinaire (logicielle) : cela permet plusieurs esclaves et de garder CS à 0 pendant plusieurs octets.

4. Les registres (sans HAL)

SPI1 : base 0x40013000, horloge bit 12 de RCC_APB2ENR.

RegistreOffsetRôle
SPI_CR10x00Configuration
SPI_CR20x04Interruptions, DMA
SPI_SR0x08État
SPI_DR0x0CDonnée

SPI_CR1

BitNomSignification
0CPHAPhase
1CPOLPolarité
2MSTR1 : maître
5:3BRPrédiviseur
6SPEActive le SPI
7LSBFIRST0 : MSB d’abord
8SSINiveau interne de NSS
9SSMNSS logiciel
11DFF0 : 8 bits ; 1 : 16 bits

SPI_SR

BitNomSignification
0RXNEOctet reçu disponible
1TXERegistre d’émission vide
6OVRÉcrasement
7BSYSPI occupé
void spi_init(void){
  RCC_AHB1ENR |= (1UL<<0);  RCC_APB2ENR |= (1UL<<12);
  GPIOA_MODER &= ~((3UL<<10)|(3UL<<12)|(3UL<<14));
  GPIOA_MODER |=  ((2UL<<10)|(2UL<<12)|(2UL<<14));      // PA5/6/7 en AF
  GPIOA_AFRL  &= ~((0xFUL<<20)|(0xFUL<<24)|(0xFUL<<28));
  GPIOA_AFRL  |=  ((5UL<<20)|(5UL<<24)|(5UL<<28));      // AF5
  GPIOA_BSRR = (1UL<<4); GPIOA_MODER &= ~(3UL<<8); GPIOA_MODER |= (1UL<<8); // PA4 = CS
  SPI1_CR1 = (1UL<<2)|(3UL<<3)|(1UL<<9)|(1UL<<8);        // maître, /16, SSM, SSI
  SPI1_CR1 |= (1UL<<6);                                   // SPE
}
uint8_t spi_echange(uint8_t o){
  while(!(SPI1_SR&(1UL<<1))); SPI1_DR=o;   // TXE
  while(!(SPI1_SR&(1UL<<0))); return (uint8_t)SPI1_DR; // RXNE
}

5. La bibliothèque HAL

hspi1.Instance = SPI1;
hspi1.Init.Mode = SPI_MODE_MASTER;
hspi1.Init.Direction = SPI_DIRECTION_2LINES;
hspi1.Init.DataSize = SPI_DATASIZE_8BIT;
hspi1.Init.CLKPolarity = SPI_POLARITY_LOW;       // CPOL = 0
hspi1.Init.CLKPhase = SPI_PHASE_1EDGE;           // CPHA = 0 : mode 0
hspi1.Init.NSS = SPI_NSS_SOFT;
hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_16;
hspi1.Init.FirstBit = SPI_FIRSTBIT_MSB;
HAL_SPI_Init(&hspi1);
ModeCLKPolarityCLKPhase
0SPI_POLARITY_LOWSPI_PHASE_1EDGE
1SPI_POLARITY_LOWSPI_PHASE_2EDGE
2SPI_POLARITY_HIGHSPI_PHASE_1EDGE
3SPI_POLARITY_HIGHSPI_PHASE_2EDGE
FonctionRôle
HAL_SPI_Transmit(&hspi,buf,len,to)Envoie (ignore le retour)
HAL_SPI_Receive(&hspi,buf,len,to)Reçoit (le maître envoie des octets factices)
HAL_SPI_TransmitReceive(&hspi,tx,rx,len,to)Échange dans les deux sens
…_IT / …_DMAInterruption / DMA
HAL_SPI_TxCpltCallbackFin d’émission IT/DMA

Broches en GPIO_MODE_AF_PP, GPIO_AF5_SPI1, vitesse très haute, dans HAL_SPI_MspInit ; CS = sortie push-pull au repos à 1.

6. Exemples d’implémentation

DAC MCP4921 (12 bits)

Mot de 16 bits : 0x3000 | (valeur & 0x0FFF) (A/B=0, BUF=0, GA=1, SHDN=1). Vout = Vref × valeur / 4096.

void dac_ecrire(uint16_t v){
  uint16_t mot = 0x3000 | (v & 0x0FFF);
  uint8_t t[2] = { mot>>8, mot&0xFF };
  CS_BAS(); HAL_SPI_Transmit(&hspi1,t,2,10); CS_HAUT();  // sortie change quand CS remonte
}

Identifiant d’une flash W25Q (commande 0x9F)

uint8_t cmd=0x9F, id[3];
CS_BAS();
HAL_SPI_Transmit(&hspi1,&cmd,1,10);
HAL_SPI_Receive(&hspi1,id,3,10);
CS_HAUT();            // W25Q64 : EF 40 17

Loopback

uint8_t tx=0xA5, rx=0;           // relier PA7 (MOSI) à PA6 (MISO)
CS_BAS(); HAL_SPI_TransmitReceive(&hspi1,&tx,&rx,1,100); CS_HAUT();
if(rx==tx) HAL_GPIO_WritePin(GPIOC,GPIO_PIN_13,GPIO_PIN_RESET);
Avec le DMA, remonter CS dans HAL_SPI_TxCpltCallback, pas juste après l’appel.

7. Diagnostic

SymptômeCause probable
Tout à 0xFFCS non actif, esclave non alimenté, MISO non câblé
Tout à 0x00MISO à la masse ou esclave bloqué
Données décalées d’un bitMauvais mode CPOL/CPHA
OK lentement, KO viteFils trop longs, horloge trop rapide
Données reçues mais pas d’effetCS remonté trop tôt, trame incomplète

8. Exercices

Mode d’un capteur : « SCK au repos haut, lecture sur front montant »

CPOL = 1 (repos haut). Front montant = second front : CPHA = 1. C’est le mode 3.

Mot DAC pour 1,0 V (Vref 3,3 V)

valeur = 1,0 × 4096 / 3,3 ≈ 1241 = 0x4D9, donc mot = 0x34D9. Pour 0x37FF : valeur = 0x7FF = 2047, Vout ≈ 1,65 V.

SPI_CR1 en mode 3, /8, NSS logiciel, MSB d’abord

CPHA(bit0)+CPOL(bit1)+MSTR(bit2)+BR=010 (bits 5:3 → 0x10)+SSM+SSI = 0x0003+0x0004+0x0010+0x0200+0x0100 = 0x0317 (SPE s’active ensuite).

À faire en TP : chronogramme de 0x3C en modes 0 et 3, sinus 50 points sur le DAC, deux esclaves (CS PA4 et PB0, jamais les deux à 0), chenille avec un 74HC595.

Autres protocoles : USART · I²C · CAN. Carte : Black Pill STM32F411 (BTS EII).