← Back to Academic Project

Introduction

This comprehensive synthesis project involved designing and implementing a complete RF wireless communication system from scratch. The system featured separate transmitter and receiver modules, integrating analog sensor conditioning, microcontroller data processing, digital modulation (FSK/ASK), RF amplification, and custom antennas to achieve reliable wireless data transmission over 50-100 meters.

Project Overview

Working in pairs over 60 hours, we developed a full duplex or half-duplex wireless link operating in the ISM band (433 or 868 MHz). The project synthesized knowledge from analog electronics, digital systems, RF circuits, telecommunications, and embedded programming.

System Architecture

Transmitter Chain

  1. Data Acquisition: Sensors (temperature, pressure, accelerometer) with analog conditioning
  2. Processing: STM32 microcontroller for data framing (preamble + data + CRC)
  3. Modulation: FSK (Frequency Shift Keying) or ASK (Amplitude Shift Keying) implementation
  4. RF Amplification: Power amplifier delivering +10 to +20 dBm
  5. Antenna: Matched monopole or patch antenna (50Ω)

Receiver Chain

  1. Antenna: Receiving antenna with 50Ω impedance matching
  2. LNA: Low Noise Amplifier (15-20 dB gain, NF < 3 dB)
  3. Demodulation: FSK/ASK detector with threshold comparator
  4. Processing: STM32 for frame synchronization and CRC validation
  5. Display: LCD/OLED or UART output to PC

Design and Implementation

Calculated using Friis transmission formula:

Modulation Schemes

FSK (Frequency Shift Keying):

ASK (Amplitude Shift Keying):

PCB Design

Fabricated two separate PCBs:

Transmitter PCB:

Receiver PCB:

Software Implementation

Transmitter Firmware:

// Data frame structure
struct Packet {
    uint8_t preamble[4];    // Sync pattern
    uint8_t data[32];       // Payload
    uint16_t crc;           // Error detection
};

// Transmit function
void transmit_packet(uint8_t *data, uint8_t length) {
    prepare_frame(data, length);
    modulate_and_send();
    wait_for_ack();
}

Receiver Firmware:

Testing and Validation

Unit Testing

System Integration

Results

Successfully achieved:

Conclusion

This project provided invaluable hands-on experience in designing complete RF communication systems. We successfully integrated multiple engineering disciplines to create a functional wireless link, demonstrating the importance of systematic design, careful testing, and iterative optimization in complex electronic systems.

PART B: EXPÉRIENCE, CONTEXTE ET FONCTION (Architecture système)

Chaîne d’émission

Bloc 1 : Acquisition :

Bloc 2 : Traitement et codage :

Bloc 3 : Modulation :

Bloc 4 : Amplification RF :

Bloc 5 : Antenne TX :

Chaîne de réception

Bloc 1 : Antenne RX

Bloc 2 : Préamplification :

Bloc 3 : Démodulation :

Bloc 4 : Traitement numérique :

Bloc 5 : Affichage :

PART C: ASPECTS TECHNIQUES (Réalisation)

Phase 1 : Conception (20h)

Spécifications :

Schéma fonctionnel :

Phase 2 : Simulation (10h)

Analogique (LTSpice) :

Numérique (MATLAB) :

Phase 3 : Réalisation PCB (15h)

2 cartes :

Conception :

Phase 4 : Tests et validation (15h)

Tests unitaires :

Tests système :

PART D: ANALYSE ET RÉFLEXION

Livrables

Évaluation

Compétences acquises

Applications professionnelles

📚 Contexte du projet

Chaîne de communication complète

Architecture générale :

[Capteur] → [Conditionnement] → [MCU] → [Modulation] 
    → [Amplification RF] → [Antenne TX]
    
        ~~~ Canal radio ~~~
        
[Antenne RX] → [Amplification RF] → [Démodulation] 
    → [MCU] → [Traitement] → [Affichage/Transmission]

Projets types

Liaison audio sans fil

Télémétrie capteurs

Commande à distance

🛠️ Exemple détaillé : Système de communication RF

Cahier des charges

Spécifications système

Fréquence :

Modulation :

Puissance :

Communication :

Conception émetteur

Architecture émetteur

Blocs fonctionnels :

  1. Acquisition données :
    • Microcontrôleur (STM32)
    • Interface capteurs ou audio
    • Échantillonnage et conversion A/N
  2. Codage et mise en forme :
    • Codage source (compression optionnelle)
    • Codage canal (détection erreurs)
    • Mise en paquet
    • Ajout CRC
  3. Modulation :
    • Génération FSK
    • VCO (Voltage Controlled Oscillator)
    • Ou module RF intégré
  4. Émission RF :
    • Amplification PA (Power Amplifier)
    • Filtrage passe-bande
    • Adaptation d’impédance
    • Antenne

Schémas émetteur

Option 1 : Module RF intégré

Utilisation module type RFM69, SX1276 (LoRa), nRF24L01, etc.

Avantages :

Exemple avec RFM69 :

Connexions :

STM32 (SPI) ↔ RFM69
    MOSI → MOSI
    MISO → MISO
    SCK  → SCK
    NSS  → NSS
    DIO0 → GPIO (interruption)

Option 2 : Conception discrète

Blocs à concevoir :

VCO (Oscillateur) :

Amplificateur de puissance :

Filtrage :

Adaptation et antenne :

Logiciel émetteur

Structure code :

void transmit_packet(uint8_t *data, uint8_t length) {
    // 1. Préparation paquet
    packet[0] = PREAMBLE;     // 0xAA (synchronisation)
    packet[1] = SYNC_WORD;    // 0x2D (identification)
    packet[2] = length;       // Longueur données
    memcpy(&packet[3], data, length);
    
    // 2. Calcul CRC
    uint16_t crc = calculate_crc16(data, length);
    packet[3 + length] = (crc >> 8) & 0xFF;
    packet[4 + length] = crc & 0xFF;
    
    // 3. Émission via module RF
    RFM69_send(packet, 5 + length);
    
    // 4. Attente acquittement (optionnel)
    wait_for_ack(TIMEOUT_MS);
}

Gestion protocole :

Conception récepteur

Architecture récepteur

Blocs fonctionnels :

  1. Réception RF :
    • Antenne
    • Filtre passe-bande
    • LNA (Low Noise Amplifier)
    • Mélangeur (down-conversion)
  2. Démodulation :
    • Discriminateur FM
    • Ou démodulateur numérique (DSP)
    • Récupération d’horloge
  3. Décodage :
    • Synchronisation (préambule)
    • Récupération des données
    • Vérification CRC
    • Détection et correction d’erreurs
  4. Traitement :
    • MCU (STM32)
    • Interprétation données
    • Actions ou affichage
    • Transmission vers PC (USB/UART)

Schémas récepteur

Option 1 : Module RF intégré

Même module que l’émetteur (RFM69, etc.) en mode RX

Configuration réception :

RFM69_setMode(RX_MODE);
RFM69_setFrequency(433.92 MHz);
RFM69_setBitrate(9600);
RFM69_setRxBandwidth(50 kHz);

Interruption sur réception :

void RFM69_IRQ_Handler(void) {
    if (packet_received) {
        uint8_t length = RFM69_read_FIFO(rx_buffer);
        process_packet(rx_buffer, length);
    }
}

Option 2 : Conception discrète

LNA (Low Noise Amplifier) :

Mélangeur et FI (Fréquence Intermédiaire) :

Démodulateur FM :

Comparateur :

Logiciel récepteur

Structure code :

void receive_handler(void) {
    uint8_t rx_buffer[MAX_PACKET_SIZE];
    
    // 1. Attente données
    if (RFM69_available()) {
        uint8_t length = RFM69_receive(rx_buffer);
        
        // 2. Vérification préambule et sync
        if (rx_buffer[0] == PREAMBLE && 
            rx_buffer[1] == SYNC_WORD) {
            
            // 3. Extraction données
            uint8_t data_length = rx_buffer[2];
            uint8_t *data = &rx_buffer[3];
            
            // 4. Vérification CRC
            uint16_t crc_received = (rx_buffer[3+data_length] << 8) | 
                                     rx_buffer[4+data_length];
            uint16_t crc_calculated = calculate_crc16(data, data_length);
            
            if (crc_received == crc_calculated) {
                // 5. Traitement données
                process_data(data, data_length);
                
                // 6. Envoi acquittement
                send_ack();
            } else {
                // Erreur CRC
                error_count++;
            }
        }
    }
}

Traitement données :

Antennes

Design antennes

Émetteur et récepteur :

Dimensionnement 433 MHz :

Dimensionnement 868 MHz :

Optimisations :

Tests et validation

Tests unitaires

Émetteur :

Récepteur :

Tests d’intégration

Liaison complète :

Mesures de performances :

Portée :

Taux d’erreur binaire (BER) : \(BER = \frac{\text{Bits erronés}}{\text{Bits totaux}}\)

Objectif : BER < 10^-3 à 10^-5

Débit effectif :

Latence :

Tests en conditions réelles

Scénarios d’usage :

Robustesse :

Améliorations possibles

Hardware

Software

Protocole

💻 Outils utilisés

Conception RF

Simulation antennes

PCB

Mesure RF

Software

📊 Livrables

Documentation

Réalisations

Présentation

🔗 Liens avec les cours

📖 Compétences développées

💡 Extensions possibles

Fonctionnalités avancées

Applications

⚠️ Conformité réglementaire

Puissance et fréquence

Homologation

Sécurité

🎯 Critères d’évaluation

📚 Ressources