Electronique Fonctions Numeriques - Semestre 6

Annee Universitaire : 2022-2023
Semestre : 6
Credits : 2 ECTS
Specialite : Electronique et Systemes Embarques

---

PART A - Presentation Generale du Cours

Vue d'ensemble

Ce cours se concentre sur les interfaces de communication numeriques et leur implementation dans les systemes embarques. L'accent est mis sur les bus de communication serie (I2C, SPI, UART) et les aspects pratiques de programmation des microcontroleurs (horloges, gestion de la consommation, DMA). Le cours utilise des cartes Nordic nRF52832 (Bluetooth Low Energy) pour les travaux pratiques.

Objectifs pedagogiques :

• Maitriser les protocoles de communication serie (I2C, SPI)
• Programmer des microcontroleurs ARM Cortex-M4 en C
• Comprendre les mecanismes d'horloge et de gestion de puissance
• Interfacer des capteurs via bus numeriques
• Optimiser la consommation energetique

Position dans le cursus

Ce cours fait suite et complete :

• Fondements Electronique Numerique (S5) : logique combinatoire et sequentielle
• Langage C (S5) : programmation systeme en C
• Microcontroleur (S6) : architecture ARM et peripheriques

Il prepare aux applications :

• Embedded IA for IoT (S9) : objets connectes et edge computing
• Energy for Connected Objects (S9) : optimisation energetique
• Projets embarques : conception de systemes complets

---

PART B - Experience Personnelle et Contexte d'Apprentissage

Organisation et ressources

Le module etait organise en deux volets complementaires :

1. Cours magistraux :

• Comparaison des bus de communication (I2C, SPI, UART, CAN, USB)
• Architecture des microcontroleurs (horloges, DMA, modes basse consommation)
• Protocoles de communication serie (timing, signalisation, adressage)
• Adaptation de niveaux logiques et WiFi

2. Travaux pratiques :

• Carte INSA-BLE basee sur Nordic nRF52832 (ARM Cortex-M4F + BLE)
• Programmation en C avec SDK Nordic
• TP I2C : lecture d'un capteur de temperature MCP9804
• TP SPI : interfacage avec capteur TC72

Materiel utilise

Carte INSA-BLE (Nordic nRF52832) :

Composant	Specification
MCU	ARM Cortex-M4F 64 MHz
Memoire Flash	512 KB
RAM	64 KB
Connectivite	Bluetooth Low Energy 5.0
Capteurs embarques	LIS2DH12 (accelerometre I2C), MPU-9250 (IMU 9 axes SPI)
Alimentation	3,3V (regulateur integre)

Peripheriques externes :

• MCP9804 : capteur de temperature I2C haute precision (+/-0,25 deg C)
• TC72 : capteur de temperature SPI

Deroulement des TPs

TP I2C : Communication avec MCP9804

L'objectif etait de lire la temperature d'un capteur I2C et l'afficher en temps reel.

Etapes de mise en oeuvre :

1. Initialisation du bus I2C :
   • Configuration des broches SCL (P0.27) et SDA (P0.26)
   • Frequence : 100 kHz (mode standard)
   • Activation du peripherique TWI (Two-Wire Interface)
2. Adressage du capteur :
   • Adresse I2C du MCP9804 : 0x1F (7 bits)
   • Registre de temperature : 0x05
3. Lecture de la temperature :
   • Envoi de la commande pour acceder au registre 0x05
   • Lecture de 2 octets (temperature sur 13 bits)
   • Conversion : bits de donnees / 16 = temperature en deg C

Extrait de code I2C :

#define TWI_INSTANCE_ID 0
#define MCP9804_ADDRESS 0x1F

static const nrf_drv_twi_t twi_instance = NRF_DRV_TWI_INSTANCE(TWI_INSTANCE_ID);

void twi_init(void) {
    ret_code_t err_code;
    const nrf_drv_twi_config_t twi_config = {
        .scl = NRF_GPIO_PIN_MAP(0, 27),
        .sda = NRF_GPIO_PIN_MAP(0, 26),
        .frequency = NRF_TWI_FREQ_100K,
        .interrupt_priority = APP_IRQ_PRIORITY_LOWEST,
        .clear_bus_init = false
    };
    err_code = nrf_drv_twi_init(&twi_instance, &twi_config, NULL, NULL);
    APP_ERROR_CHECK(err_code);
    nrf_drv_twi_enable(&twi_instance);
}

float read_temperature(void) {
    uint8_t reg[2] = {0x05, 0x00};
    uint8_t temp_data[2] = {0};

    nrf_drv_twi_tx(&twi_instance, MCP9804_ADDRESS, reg, sizeof(reg), true);
    nrf_delay_ms(10);
    nrf_drv_twi_rx(&twi_instance, MCP9804_ADDRESS, temp_data, sizeof(temp_data));

    int16_t temp_raw = (temp_data[0] << 8) | temp_data[1];
    temp_raw &= 0x0FFF;  // Masque 12 bits utiles
    float temperature = temp_raw / 16.0;

    return temperature;
}

TP SPI : Communication avec TC72

Le second TP consistait a interfacer un capteur de temperature SPI.

Configuration SPI :

• Mode 1 (CPOL=0, CPHA=1)
• Frequence : 125 kHz
• CS (Chip Select) : P0.31, gere manuellement
• MOSI : P0.28, MISO : P0.29, SCK : P0.30

Protocole de communication :

1. Initialisation : ecrire 0x80, 0x04 pour mode conversion continue
2. Lecture : envoyer commande 0x02, recevoir 3 octets
3. Traitement des donnees de temperature

Extrait de code SPI :

#define SPI_CS_PIN    NRF_GPIO_PIN_MAP(0,31)
#define SPI_MISO_PIN  NRF_GPIO_PIN_MAP(0,29)
#define SPI_MOSI_PIN  NRF_GPIO_PIN_MAP(0,28)
#define SPI_SCK_PIN   NRF_GPIO_PIN_MAP(0,30)

void spi_init(void) {
    nrf_drv_spi_config_t spi_config = NRF_DRV_SPI_DEFAULT_CONFIG;
    spi_config.ss_pin   = NRF_DRV_SPI_PIN_NOT_USED;
    spi_config.miso_pin = SPI_MISO_PIN;
    spi_config.mosi_pin = SPI_MOSI_PIN;
    spi_config.sck_pin  = SPI_SCK_PIN;
    spi_config.mode     = NRF_DRV_SPI_MODE_1;
    spi_config.frequency = NRF_DRV_SPI_FREQ_125K;
    APP_ERROR_CHECK(nrf_drv_spi_init(&spi, &spi_config, spi_event_handler, NULL));
}

void tc_init(void) {
    nrf_gpio_cfg_output(SPI_CS_PIN);
    nrf_gpio_pin_clear(SPI_CS_PIN);
    spi_init();
    uint8_t data_to_send[2] = {0x80, 0x04}; // Conversion continue
    nrf_gpio_pin_set(SPI_CS_PIN);
    spi_send(data_to_send, 2, NULL, 0);
    nrf_gpio_pin_clear(SPI_CS_PIN);
}

Difficultes rencontrees

Gestion du Chip Select en SPI : Le CS doit etre manipule manuellement (pas gere automatiquement par le driver). Oubli de basculer le CS provoquait l'absence de communication.

Timing I2C : Les delais entre transmission et reception sont critiques. Un delai trop court entrainait des donnees corrompues.

Debogage : Utilisation de printf via UART pour afficher les valeurs lues. Configuration du port serie necessaire dans sdk_config.h.

---

PART C - Aspects Techniques Detailles

1. Bus de Communication Serie

Comparaison des principaux bus :

Caracteristique	I2C	SPI	UART
Fils	2 (SDA, SCL)	4 (MOSI, MISO, SCK, CS)	2 (TX, RX)
Vitesse max	400 kHz (Fast), 3,4 MHz (High-Speed)	Plusieurs MHz	115200 bauds typique
Maitre/Esclave	Multi-maitre possible	Un maitre, plusieurs esclaves	Point a point
Adressage	Adresse 7 ou 10 bits	Chip Select physique	Pas d'adresse
Complexite	Moyenne	Simple	Tres simple
Distance	Courte (< 1 m)	Tres courte	Moyenne (quelques metres)

2. Protocole I2C (Inter-Integrated Circuit)

Principe de fonctionnement :

I2C utilise deux lignes bidirectionnelles :

• SDA (Serial Data) : transmission des donnees
• SCL (Serial Clock) : horloge generee par le maitre

Conditions de START et STOP :

• START : SDA passe de HIGH a LOW alors que SCL est HIGH
• STOP : SDA passe de LOW a HIGH alors que SCL est HIGH

Trame de communication :

1. Condition START
2. Adresse esclave (7 bits) + bit R/W
3. Bit ACK (acknowledgement) de l'esclave
4. Donnees (8 bits)
5. Bit ACK
6. Condition STOP

Avantages :

• Seulement 2 fils pour plusieurs peripheriques
• Adressage logiciel (pas de CS supplementaire)
• Detection des collisions en multi-maitre

Inconvenients :

• Vitesse limitee
• Resistances de pull-up necessaires
• Capacite parasite limite la longueur des cables

3. Protocole SPI (Serial Peripheral Interface)

Signaux SPI :

• MOSI (Master Out Slave In) : donnees du maitre vers l'esclave
• MISO (Master In Slave Out) : donnees de l'esclave vers le maitre
• SCK (Serial Clock) : horloge generee par le maitre
• CS (Chip Select) : selection de l'esclave (actif bas)

Modes SPI (4 modes selon CPOL et CPHA) :

Mode	CPOL	CPHA	Description
0	0	0	Clock repos a 0, echantillonnage front montant
1	0	1	Clock repos a 0, echantillonnage front descendant
2	1	0	Clock repos a 1, echantillonnage front descendant
3	1	1	Clock repos a 1, echantillonnage front montant

Avantages :

• Communication full-duplex (simultanee dans les deux sens)
• Vitesse elevee (jusqu'a plusieurs dizaines de MHz)
• Simple a implementer (pas de protocole complexe)

Inconvenients :

• Nombre de fils augmente avec le nombre d'esclaves (un CS par esclave)
• Pas de mecanisme d'acquittement (ACK)
• Pas de detection d'erreur integree

4. Gestion des Horloges dans les Microcontroleurs

Les microcontroleurs modernes disposent de plusieurs sources d'horloge pour optimiser performances et consommation.

Sources d'horloge du nRF52832 :

Horloge	Frequence	Precision	Consommation	Usage
HFCLK interne	64 MHz	+/-5%	Elevee	CPU, peripheriques rapides
HFCLK externe (cristal)	64 MHz	+/-20 ppm	Moyenne	Bluetooth, precision
LFCLK interne	32,768 kHz	+/-5%	Faible	RTC, timers basse vitesse
LFCLK externe (cristal)	32,768 kHz	+/-20 ppm	Tres faible	RTC precis, sleep modes

Diviseurs d'horloge : Chaque peripherique peut avoir son propre diviseur pour adapter la frequence. Exemple : SPI a 125 kHz derive de HFCLK 64 MHz (diviseur 512).

Importance pour la consommation :

• Mode actif (64 MHz) : ~5 mA
• Mode sleep (32 kHz) : quelques uA
• Transition rapide entre modes pour economiser l'energie

5. DMA (Direct Memory Access)

Le DMA permet des transferts de donnees entre peripheriques et memoire sans intervention du CPU.

Avantages :

• CPU libre pour d'autres taches
• Transferts rapides et efficaces
• Reduit la consommation (CPU peut rester en sleep)

Cas d'usage typiques :

• Reception UART en continu (buffer circulaire)
• Acquisition ADC multicanaux
• Transferts SPI de grandes quantites de donnees

Configuration DMA pour SPI :

• Buffer source en memoire
• Peripherique SPI comme destination
• Generation d'interruption en fin de transfert

6. Gestion de la Consommation (Low Power)

Modes de fonctionnement du nRF52832 :

Mode	Consommation	Etat CPU	Peripheriques actifs	Reveil
Active	5-15 mA	Running	Tous	N/A
Sleep	1-2 uA	Halt	RTC, GPIO	Interruption, timer
Deep Sleep	< 1 uA	Halt	Aucun	Reset externe

Techniques d'economie d'energie :

• Utiliser les interruptions plutot que le polling
• Desactiver les peripheriques non utilises
• Reduire la frequence d'horloge quand possible
• Utiliser des timers basse frequence (LFCLK)
• Sleep entre les evenements

Exemple de cycle typique :

1. Reveil par interruption timer (toutes les secondes)
2. Lecture capteur I2C (10 ms actif)
3. Traitement donnees (5 ms actif)
4. Retour en sleep (985 ms a quelques uA)
5. Consommation moyenne : ~50 uA au lieu de 5 mA continu

7. Adaptation de Niveaux Logiques

Problematique : Les differents composants fonctionnent a des tensions differentes (5V, 3,3V, 1,8V).

Solutions :

• Diviseur resistif : simple mais ne fonctionne que pour 5V vers 3,3V
• Transistor MOSFET : bidirectionnel pour I2C
• Circuits dedies : TXS0108E (8 canaux, bidirectionnel)
• Buffer 74LVCxx : conversion avec isolation

Carte INSA-BLE : Fonctionne en 3,3V. Connexion directe a des capteurs 3,3V. Pour interfacer avec du 5V (ex : Arduino), adaptation necessaire.

---

PART D - Analyse Reflexive et Perspectives

Competences acquises

Programmation embarquee bas niveau : Ce cours a renforce la programmation en C pour systemes embarques, notamment la manipulation de registres, la gestion d'interruptions, et l'interfacage avec peripheriques materiels.

Maitrise des protocoles de communication : Comprendre les differences entre I2C et SPI, savoir choisir le bon protocole selon les contraintes (nombre de fils, vitesse, consommation), et implementer correctement les transactions.

Optimisation energetique : Les techniques de low power sont essentielles pour les objets connectes sur batterie. Savoir mesurer et reduire la consommation est une competence cle.

Points cles a retenir

1. Choix du bus de communication :

• I2C : plusieurs capteurs, peu de fils, vitesse moderee
• SPI : haute vitesse, full-duplex, plus de fils
• UART : simple, point a point, universel

2. Gestion rigoureuse du materiel : Lire attentivement les datasheets, respecter les timings, verifier les niveaux logiques, gerer correctement les CS et ACK.

3. Debogage methodique : Oscilloscope pour verifier les signaux, printf pour tracer l'execution, analyseur logique pour capturer les trames completes.

4. Consommation energetique : Concevoir des le depart avec la consommation en tete : sleep modes, reveil par interruption, choix des horloges.

Applications pratiques

Projets personnels et professionnels :

Objets connectes IoT : Les competences acquises sont directement applicables aux projets IoT : interfacer des capteurs environnementaux (temperature, humidite, pression), optimiser la duree de vie sur batterie.

Projet Embedded IA for IoT (S9) : Utilisation du nRF52832 pour des applications de machine learning embarque avec capteurs (accelerometre, gyroscope).

Instrumentation : Conception de systemes d'acquisition de donnees multi-capteurs avec communication serie vers un PC ou cloud.

Limites et ouvertures

Limites du cours :

• Peu de UART (pourtant tres utilise)
• Pas de CAN (important pour l'automobile)
• Pas d'USB (complexe mais omnipresent)
• Bluetooth uniquement mentionne, pas approfondi

Ouvertures vers :

• Protocoles industriels : Modbus, Profibus, CAN, EtherCAT
• Communication sans fil : Bluetooth, WiFi, LoRa, Zigbee
• Interfaces haute vitesse : USB 2.0/3.0, Ethernet, PCIe
• Securite des communications : chiffrement, authentification
• Reseaux de capteurs : topologies mesh, routage, economie d'energie

Evolution technologique

Tendances actuelles :

• Integration accrue : SoC avec CPU + peripheriques + radio
• Ultra-basse consommation : nW pour capteurs recoltant l'energie ambiante
• Protocoles unifies : Matter pour interoperabilite IoT
• Edge computing : traitement local avec IA embarquee

Impact des nouvelles normes :

• Bluetooth 5.0+ : portee etendue, debit augmente
• Thread et Matter : standardisation IoT
• MIPI I3C : evolution d'I2C avec vitesses jusqu'a 12,5 MHz

Conclusion

Les bus de communication numeriques sont le systeme nerveux des systemes embarques. Leur maitrise est indispensable pour interfacer capteurs, actionneurs, et modules de communication.

Ce cours a fourni une base solide en I2C et SPI, avec une approche pratique sur microcontroleur ARM. La carte nRF52832 est representative des SoC modernes : puissant, basse consommation, connectivite integree.

Complementarite avec les autres cours :

• Microcontroleur - S6 : architecture ARM Cortex-M
• Langage d'Assemblage ARM - S6 : bas niveau ARM
• Embedded IA for IoT - S9 : applications avancees
• Energy for Connected Objects - S9 : optimisation poussee

Recommandations pour aller plus loin :

• Etudier les datasheets completes (nRF52, capteurs)
• Experimenter avec d'autres bus (CAN, USB)
• Mesurer la consommation reelle avec un amperemetre de precision
• Developper des projets complets integrant plusieurs capteurs
• Explorer les stacks Bluetooth et WiFi

---

Documents de Cours

---

#define TWI_INSTANCE_ID 0
#define MCP9804_ADDRESS 0x1F

static const nrf_drv_twi_t twi_instance = NRF_DRV_TWI_INSTANCE(TWI_INSTANCE_ID);

void twi_init(void) {
    ret_code_t err_code;
    const nrf_drv_twi_config_t twi_config = {
        .scl = NRF_GPIO_PIN_MAP(0, 27),
        .sda = NRF_GPIO_PIN_MAP(0, 26),
        .frequency = NRF_TWI_FREQ_100K,
        .interrupt_priority = APP_IRQ_PRIORITY_LOWEST,
        .clear_bus_init = false
    };
    err_code = nrf_drv_twi_init(&twi_instance, &twi_config, NULL, NULL);
    APP_ERROR_CHECK(err_code);
    nrf_drv_twi_enable(&twi_instance);
}

float read_temperature(void) {
    uint8_t reg[2] = {0x05, 0x00};
    uint8_t temp_data[2] = {0};

    nrf_drv_twi_tx(&twi_instance, MCP9804_ADDRESS, reg, sizeof(reg), true);
    nrf_delay_ms(10);
    nrf_drv_twi_rx(&twi_instance, MCP9804_ADDRESS, temp_data, sizeof(temp_data));

    int16_t temp_raw = (temp_data[0] << 8) | temp_data[1];
    temp_raw &= 0x0FFF;  // Mask for useful 12 bits
    float temperature = temp_raw / 16.0;

    return temperature;
}

#define SPI_CS_PIN    NRF_GPIO_PIN_MAP(0,31)
#define SPI_MISO_PIN  NRF_GPIO_PIN_MAP(0,29)
#define SPI_MOSI_PIN  NRF_GPIO_PIN_MAP(0,28)
#define SPI_SCK_PIN   NRF_GPIO_PIN_MAP(0,30)

void spi_init(void) {
    nrf_drv_spi_config_t spi_config = NRF_DRV_SPI_DEFAULT_CONFIG;
    spi_config.ss_pin   = NRF_DRV_SPI_PIN_NOT_USED;
    spi_config.miso_pin = SPI_MISO_PIN;
    spi_config.mosi_pin = SPI_MOSI_PIN;
    spi_config.sck_pin  = SPI_SCK_PIN;
    spi_config.mode     = NRF_DRV_SPI_MODE_1;
    spi_config.frequency = NRF_DRV_SPI_FREQ_125K;
    APP_ERROR_CHECK(nrf_drv_spi_init(&spi, &spi_config, spi_event_handler, NULL));
}

void tc_init(void) {
    nrf_gpio_cfg_output(SPI_CS_PIN);
    nrf_gpio_pin_clear(SPI_CS_PIN);
    spi_init();
    uint8_t data_to_send[2] = {0x80, 0x04}; // Continuous conversion
    nrf_gpio_pin_set(SPI_CS_PIN);
    spi_send(data_to_send, 2, NULL, 0);
    nrf_gpio_pin_clear(SPI_CS_PIN);
}