Antenne Patch 2.4GHz (de la simulation à la réalisation) Part 1

L’objectif est de réaliser une antenne patch rectangulaire pour la bande de fréquence 2.4 GHz sur un PCB FR4.
La bande de fréquence 2.4 GHz est utilisée par le WiFi, Le Bluetooth et d’autres protocoles. La fréquence va de 2400 à 2484 MHz avec la fréquence centrale à 2442 MHz.

1. Choix du PCB

Par simplicité, je sélectionne le fabricant JLCPCB (cf 1).
Leur matériau FR4 2 couches a les caractéristiques suivantes :

1. Calcul des dimensions

On peut retrouver les formules de calcul d’une antenne patch rectangulaire dans le livre « Antenna Theory: Analysis and Design 3rd Edition » de Constantine A. Balanis à la page 817.
Avec une constante diélectrique de 4.5, une hauteur de substrat de 1.5 mm, et une fréquence de 2.442 GHz on trouve les valeurs suivantes :
W=37 mm
L=28.6 mm
Ces valeurs correspondent à celles fournies par le « Microstrip Patch Antenna Calculator » du site Em-talk (cf 2)

Le site dispose aussi d’un calculateur de ligne microstrip :

On prendra donc w=2.8 mm pour la largeur de ligne.
Pour la longueur de « inset_fed » d’après les équations du livre, on trouve 10mm.
Les largeurs des « slots » de part et d’autre de l’inset_fed sont choisies de 1.4 mm.
Pour les dimensions du PCB on prend le double des dimensions du patch, soit :
Ws=74 mm
Ls=57mm

3. Simulation avec CAPITOLE-RF

On créé tout d’abord un modèle géométrique avec FreeCAD (cf 3).
On va concevoir 2 modèles, l’un avec « Inset-fed » et l’autre sans, pour voir la différence.

Modèle antenne patch sous CAPITOLE-RF
Modèle Antenne patch avec inset-fed sous CAPITOLE-RF

Avec le logiciel CAPITOLE-RF (cf 4), on calcule le S11 entre 2.3 et 2.6Ghz et aussi le diagramme de rayonnement.

Le modèle sans inset-fed n’est pas du tout adapté. Il n’y a pas de résonance et le S11 ne descend pas au dessous de -3dB ce qui n’est pas bon. Pour le modèle avec inset-fed, on peut observer une résonance mais avec un décalage d’environ 20 MHz par rapport à la fréquence centrale utilisée pour les calculs analytiques.

Diagramme de rayonnement 3D de l’antenne patch avec inset-fed à 2.44 GHz

On peut constater que la forme du diagramme de rayonnement est typique d’une antenne patch avec une directivité de 6.9 dBi.

4. Réalisation du PCB avec EasyEDA

Pour faire réaliser un PCB, il faut d’abord réaliser un fichier de fabrication. Le format le plus connu est le Gerber. Pour cela on va utiliser le logiciel gratuit EasyEDA (cf 5).
J’ai rajouté un connecteur SMA (modèle HJ-SMA023) pour faciliter la mesure.

Ensuite, on génère le fichier Gerber, puis on commande la fabrication sur JLCPCB (cf 1) directement depuis le logiciel.
Quelques semaines plus tard (en fonction du mode de livraison) on reçoit les cartes.

Carte PCB antenne patch
Carte PCB antenne patch inset-fed

5. Mesure du S11 avec un VNA

On réalise une mesure du S11 de l’antenne patch inset-fed à l’aide d’un analyseur de réseau vectoriel (VNA). La calibration est faite en bout de câble coaxial avec un kit de calibration SMA. La mesure va inclure donc le connecteur et la ligne microstrip. Cela n’est pas gênant pour une mesure rapide mais pourrait être amélioré par la suite pour être plus précis.

Comparaison S11 mesure/simulation antenne patch inset-fed

On constate un décalage des fréquences de résonance des 2 courbes.
Nous supposons ici que ce décalage est dû à la valeur de constante diélectrique du PCB qui a été pris pour la simulation. En effet, le fabricant donne une valeur de 4.5, mais par expérience, cette valeur peut ne pas être précise. De plus on ne connaît pas le tan δ qui représente les pertes.

6. Conclusion

Nous avons pu voir dans cet article comment réaliser une antenne Patch rectangulaire. Nous avons pu constater que l’antenne réalisée ne fonctionne pas à la bonne fréquence. Dans une seconde partie, nous verrons comment estimer la valeur de constante diélectrique et ajuster notre design.

Liens vers les sites cités en référence dans cet article :

  1. JLCPCB Fabricant de PCB
    https://jlcpcb.com/
  2. Site EM-TALK
    http://www.emtalk.com
  3. Logiciel FreeCAD
    https://www.freecadweb.org/
  4. Logiciel de simulation CAPITOLE-RF
    https://simulation-software.nexiogroup.com/
  5. Logiciel Easy-EDA
    https://easyeda.com/

Création d’un Kit de calibration pour NanoVNA

1.Introduction

Le NanoVNA est un analyseur de réseau low-cost. La dernière version V2 Plus4 (cf 1) à une plage de mesure de 100kHz à 4.4 GHz avec une dynamique de 70 à 90dB pour un prix inférieur à 200€.
Un kit de calibration est nécessaire pour faire une mesure correcte. Pour une calibration d’un seul port, il faut 3 bouchons.

  • Un bouchon court-circuit (Short)
  • Un bouchon circuit ouvert (Open)
  • Une charge de 50 Ohms (Load)

Un kit de précision peut coûter plusieurs milliers d’euros. A l’achat du NanoVNA, un kit de calibration SMA est fourni, cependant aucune indication n’est donnée sur les caractéristiques de ce kit.
Un kit de calibration même de qualité, sans description des caractéristiques ou fichier de donnée ne permet pas de faire des mesures précises.
Nous allons voir, dans cet article comment créer des fichiers de calibration pour un kit à un prix raisonnable.

2. Le Kit de calibration

Le site SDR-KIT (cf 2) propose des kits « Premium » utilisable jusqu’à 12 Ghz en connecteur mâle ou femelle pour 66€.

Premium 12 GHz Calibration Kits de SDR-KIT

Un élément important, c’est qu’ils sont fournis avec une mesure pour chaque kit de la charge 50 Ohms et une description des caractéristiques sous forme de PDF.
https://sdr-kits.net/documents/Rosenberger_Female_Cal_Standards_rev5.pdf

Rosenberger Female Cal Standards

3. Récupération des caractéristiques

Pour le bouchon court-circuit, il est indiqué une valeur de 26.91 ps. C’est le temps que va mettre l’onde pour arriver au court-circuit. Mais comme l’onde fait l’aller-retour, le délai est de -53.82 ps.
Le signe «-»  indique que le court-circuit est après le plan de référence.
On peut calculer la distance entre le plan de référence et le court-circuit. Dans le document, il est précisé que le Velocity Factor=0.7

l=Delay(s)*VelocityFactor*c

avec c=299 792 458 m/s
On trouve une longueur du court-circuit de 5.657 mm
Pour le bouchon circuit ouvert, on va utiliser l’adaptateur femelle-femelle. Le délai est de 42.35 ps soit un délai total de -84.70 ps et une longueur de 8.887 mm.
La valeur de la charge est notée sur le boitier et a été mesurée avec 4 points par rapport à une référence 50 ohm à 0.01%.
De plus il est indiqué qu’il faut prévoir une capacité parallèle de 2 fF.
On peut convertir le Velocity Factor en permittivité : ε =1/VF² soit ε=2.04081

4. Modélisation avec le logiciel QucsStudio

L’objectif ici est de créer des fichiers de paramètres S correspondants à chaque bouchon. Nous allons pour cela utiliser le logiciel de simulation circuit QucsStudio, créer les 3 schémas suivants et les simuler.

1. Modélisation du circuit ouvert
Simulation bouchon circuit ouvert dans QucsStudio

On obtient le résultat suivant pour le S11 :

S11 du bouchon circuit ouvert
2.Modélisation du court-circuit
Modélisation du bouchon court-circuit dans QucsStudio
S11 du bouchon court-circuit
3.Modélisation de la charge
Modélisation de la charge dans QucsStudio
S11 de la charge

Ensuite, il faut exporter en fichiers paramètre-S au format touchstone. (cf 5)

5. Calibration avec le logiciel NanoVNA-QT

Aller dans le menu « Calibration » puis « Kit settings » ensuite sélectionner les fichiers s1p.

Faire une calibration SOL.

6. Vérification de la calibration

Une fois que la calibration a été faite, rebrancher le bouchon Open

Le S11 est à 0dB. Sur l’abaque de Smith, la courbe forme un arc de cercle en partant du point gauche.
Ceci est tout à fait normal, et montre que le circuit-ouvert est à une certaine distance du plan de référence.
Faire une mesure de vérification du bouchon Short :

Le S11 est aussi à 0dB mais l’arc de cercle sur l’abaque de Smith est cette fois vers le haut.
Faire une mesure de vérification du bouchon 50 ohm :

Cette fois, le S11 est inférieur à -40dB, ce qui est classique pour une charge 50 ohms.

7. Conclusion

Cet article vous a montré comment générer des fichiers de configuration pour un kit de calibration à prix abordable afin de les utiliser dans le logiciel NanoVNA-QT.
Une vérification simple a été faite. Cependant une vérification plus précise pourrait être faite en utilisant une référence. Par exemple, en mesurant un atténuateur dont on a les fichiers de mesure du fabricant en amplitude et en phase.

Liens vers les sites cités en référence dans cet article :

  1. Le site officiel du NanoVNA v2
    https://nanorfe.com/fr/nanovna-v2.html
  2. Kit de calibration
    https://www.sdr-kits.net/calibration-information-for-DG8SAQ-VNWA-3-3EC
  3. Téléchargement du logiciel NanoVNA-QT
    https://nanorfe.com/nanovna-v2-software.html
  4. Le site du logiciel QucsStudio
    http://qucsstudio.de/
  5. Exportation de fichiers SnP dans QucsStudio
    https://csc-rf-electronics.blogspot.com/2021/09/simple-way-of-getting-s2p-file-from.html

Programmer en CircuitPython sur une carte Adafruit Feather nRF52840

La carte Adafruit Feather nRF52840 est une carte de prototypage au format Feather qui gère le protocole Bluetooth Low Energy grace au composant nRF52840. Il existe deux versions « express » et « sense », c’est presque les mêmes, la différence est que la « sense » embarque plusieurs capteurs (Température, mouvement, etc…)
On peut la programmer en Arduino ou en CircuitPython. Dans cet article nous allons montrer comment la programmer en CircuitPython.
Le langage CircuitPython est un dérivé du MicroPython qui est une version du Python pour microcontrôleur.
Le CircuitPython est idéal pour faire du prototypage. Il y a juste besoin de copier le code dans un fichier et de le copier sur le lecteur USB.

Télécharger la dernière version du CircuitPython (fichier .UF2) pour votre carte.
Pour la Feather nRF52840 Sense :
https://circuitpython.org/board/feather_bluefruit_sense/
Pour la Feather nRF52840 Express :
https://circuitpython.org/board/feather_nrf52840_express/
Brancher la carte avec un câble USB sur le PC.
Attention à ne pas utiliser un câble de charge, mais un vrai câble qui permet de transmettre des données !
Double-cliquer sur le bouton Reset de la carte.

Bouton Reset

La grosse LED NeoPixel RGB doit s’allumer en vert. Si elle s’allume en rouge, vérifier le câble USB ou essayer un autre port USB du PC. La petite LED à côté du connecteur USB doit clignoter en rouge.
Si le double-click ne marche pas la première fois, essayer une autre fois.
Un disque USB va apparaitre sous Windows.

Copier le fichier adafruit-circuitpython-feather_bluefruit_sense-fr-7.0.0.uf2 téléchargé précédemment sur le lecteur USB.
La LED va clignoter, puis the disque FTHRSNSBOOT va disparaître et un nouveau disque va apparaître avec comme nom CIRCUITPY.

On peut voir qu’il y a un fichier en Python code.py, c’est le programme principal de notre carte.
La première fois que l’on installe le CircuitPython, le fichier code.py contient l’instruction :

print("Hello World!")

Vous pouvez écrire du code dans ce fichier, et tout changement dans le contenu du disque CIRCUITPY va initier un reset sur la carte.
Pour observer l’affichage du programme, il faut se connecter avec un programme terminal.
Par exemple Putty https://www.chiark.greenend.org.uk/~sgtatham/putty/latest.html
Identifier le numéro du port COM de la carte sur le PC.
Aller dans « Gestionnaire périphérique » et noter le numéro.

Ensuite lancer Putty et renseigner « Serial line » et « Speed », puis cliquer sur Open

Le terminal s’affiche, et on peut voir que « Hello world ! » a bien été affiché.

En appuyant sur une touche, le mode REPL va se lancer, et vous pourrez taper directement des commandes Python ou alors appuyer sur CTRL+D pour relancer le programme code.py
Pour finir, on peut remplacer le contenu du fichier code.py sur la carte par ce code, cela va faire clignoter la LED rouge sur la carte.

import board
import digitalio
import time

led = digitalio.DigitalInOut(board.LED)
led.direction = digitalio.Direction.OUTPUT

while True:
    led.value = True
    time.sleep(0.5)
    led.value = False
    time.sleep(0.5)

Voilà, c’est fini pour cette introduction à l’utilisation de CircuitPython sur carte Feather nRF52840. Plus d’info et des exemples de programmes sont disponibles sur les liens suivants :
https://learn.adafruit.com/welcome-to-circuitpython/overview
https://learn.adafruit.com/adafruit-feather-sense/getting-started-with-ble-and-circuitpython
https://learn.adafruit.com/adafruit-feather-sense/circuitpython-on-feather-sense

Le BLE simplement avec la carte Adafruit Feather nRF52840 Sense

Dans cet article, je vais décrire comment faire un montage utilisant le protocole Bluetooth Low Energy (BLE) très simplement.
Je me suis inspiré du livre « Bluetooth Low Energy Projets pour Arduino, Raspberry Pi et smartphones » (traduit en Français) et disponible chez Dunod :
https://www.dunod.com/sciences-techniques/bluetooth-low-energy-projets-pour-arduino-raspberry-pi-et-smartphones
Copyright 2016 Alasdair Allan et Don Coleman, Dunod 978-2-10-076085-5

Ce livre propose de réaliser plusieurs montages pour se familiariser avec le protocole BLE. Le premier montage est un « commutateur d’éclairage intelligent » mais le module BLE utilisé dans le livre n’est plus commercialisé. https://www.adafruit.com/product/1697
C’est le grand problème de ce livre dont la publication date de 2017. Une éternité dans le domaine de l’électronique, l’IoT, les objets connectés, etc..
Donc je propose ici d’utiliser la carte Adafruit Feather nrf52840 Sense. Elle embarque le nRF52840 de chez Nordic Semiconductors. Un chip très populaire actuellement.
https://www.adafruit.com/product/4516
Vous pouvez aussi prendre l’Adafruit Feather nRF5240 Express :
https://www.adafruit.com/product/4062 C’est presque la même chose, la seule différence est que la « Sense » intègre des capteurs qui permettrons de faire d’autres montages rapidement sans rajouter d’autre module.

1. Installer l’IDE Arduino

La procédure se trouve sur le site Adafruit en Anglais : https://learn.adafruit.com/adafruit-feather-sense
Installer Arduino IDE (Au minimum la version 1.8.6)
Ensuite il faut rajouter la prise en charge de la carte Feather.
Aller dans « Préférences » et ajouter dans « URL de gestionnaire de cartes supplémentaires » https://www.adafruit.com/package_adafruit_index.json

Redémarrer Arduino IDE.
Dans « Boards Manager » rechercher Adafruit nRF52.

Le packet Adafruit nRF52 va s’afficher, cliquer sur « Installer ». Quand le package est installé, aller dans le menu « Outils » « Type de carte » et sélectionner la carte « Adafruit Bluefruit nRF52840 Feather Bluefruit Sense »

Installer le driver Adafruit pour Windows (uniquement si la carte n’est pas détectée au branchement sur le port USB) https://learn.adafruit.com/adafruit-arduino-ide-setup/windows-driver-installation%C2%A0

2. Exécuter son premier sketch

Depuis l’IDE Arduino, aller dans « File » puis « Examples » « 01.Basics » puis « Blink »
C’est le sketch (programme) de base en Arduino.
Il fait juste clignoter une LED présente sur la carte.
Dans le menu « sketch » cliquer sur «  Upload » Le sketch va être compilé et transféré sur la carte.
Puis la LED rouge sur la carte va clignoter.

3. Faire clignoter une LED externe

Nous allons maintenant faire un montage avec une LED comme si c’était une ampoule.
Prendre une LED et une résistance d’environ 100 Ω.
Attention : dans le livre, la résistance est de 220 Ω car la carte est sur 5V, alors que la Feather est sur 3,3V. Relier la patte 3V de la carte à la barre d’alimentation positive de la plaque. Idem pour la patte GND à la barre négative commune. Relier la résistance 100Ω à la patte 5 de la carte, puis à la patte la plus longue de la LED. Relier l’autre patte de la LED à la masse (GND).

Montage carte Feather avec LED

Modifier le sketch « Blink » pour utiliser la sortie 5 :

#define LED_PIN 5
void setup() {
  pinMode(LED_PIN, OUTPUT);
}
void loop() {
  digitalWrite(LED_PIN, HIGH);
  delay(1000);
  digitalWrite(LED_PIN, LOW);
  delay(1000);
}

4. Ajouter un bouton-poussoir

Rajouter un bouton sur la carte d’expérimentation. Brancher l’une des pattes à la broche 6 de la carte, puis l’autre au +3V. Rajouter une résistance de rappel de 10k Ω depuis la broche 6 pour éviter des faux appuis. Voir la page 30 figure 3.7 du livre pour le schéma du montage.

Montage carte Feather avec LED et bouton poussoir

Le sketch Arduino est le suivant :

#define LED_PIN 5
#define BUTTON_PIN 6
int val;
void setup() {
  pinMode(LED_PIN, OUTPUT);
  pinMode(BUTTON_PIN, INPUT);

}
void loop() {
  val = digitalRead(BUTTON_PIN);
  if (val == HIGH) {
    digitalWrite(LED_PIN, HIGH);
  }
   if (val == LOW) {
    digitalWrite(LED_PIN, LOW);
  }
}

Amélioration avec un Anti-Rebond logiciel.

#define LED_PIN 5
#define BUTTON_PIN 6
int currentState;
int debounceState;

void setup() {
  pinMode(LED_PIN, OUTPUT);
  pinMode(BUTTON_PIN, INPUT);

}

void loop() {
  currentState = digitalRead(BUTTON_PIN);
  delay(10) ;
  debounceState = digitalRead(BUTTON_PIN);

  if (currentState == debounceState) {
   if (currentState == HIGH) {
     digitalWrite(LED_PIN, HIGH);
   }
   if (currentState == LOW) {
     digitalWrite(LED_PIN, LOW);
   }
  }
}

Pour finir, nous allons rajouter la prise en charge du BLE. Le but est de pouvoir lire le status de la LED depuis un smartphone connecté en BLE à la carte, mais aussi de pouvoir allumer la LED à distance. La carte Adafruit Feather nRF52840 Sense intègre déjà un module BLE, il n’y a donc pas de modification du montage à faire.
Le sketch ci-dessous est basé sur celui du livre Exemple 3.1 page 39. Il reprend exactement le même fonctionnement mais a été adapté pour la carte Feather :

#include <bluefruit.h> ❶

#define LED_PIN 5
#define BUTTON_PIN 6

int currentState;
int debounceState;
int switchState = 0;   
int ledState = 0;

BLEService    lightswitch = BLEService(0xFF10); ❷

BLECharacteristic switchCharacteristic = BLECharacteristic(0xFF11);  ❸
BLECharacteristic stateCharacteristic = BLECharacteristic(0xFF12);

void setup() {
  Serial.begin(115200);
  pinMode(LED_PIN, OUTPUT);
  pinMode(BUTTON_PIN, INPUT);
  Bluefruit.begin();
  Bluefruit.setName("Light Switch"); ❹
  lightswitch.begin();
  
  switchCharacteristic.setProperties(CHR_PROPS_READ | CHR_PROPS_WRITE); ❺
  switchCharacteristic.setPermission(SECMODE_OPEN, SECMODE_OPEN);
  switchCharacteristic.setFixedLen(1);
  switchCharacteristic.setUserDescriptor("Switch");
  switchCharacteristic.begin();
 
  stateCharacteristic.setProperties(CHR_PROPS_NOTIFY);
  stateCharacteristic.setFixedLen(1);
  stateCharacteristic.setUserDescriptor("State");
  stateCharacteristic.begin(); 
  
  startAdv(); 
  Serial.println("Smart Light Switch");
}

void startAdv(void) ❻
{
  // Advertising packet
  Bluefruit.Advertising.addFlags(BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE);
  Bluefruit.Advertising.addTxPower();
  Bluefruit.Advertising.addService(lightswitch);
  Bluefruit.Advertising.addName();
  
  /* Start Advertising
   * - Enable auto advertising if disconnected
   * - Interval:  fast mode = 20 ms, slow mode = 152.5 ms
   * - Timeout for fast mode is 30 seconds
   * - Start(timeout) with timeout = 0 will advertise forever (until connected)
   * 
   * For recommended advertising interval
   * https://developer.apple.com/library/content/qa/qa1931/_index.html   
   */
  Bluefruit.Advertising.restartOnDisconnect(true);
  Bluefruit.Advertising.setInterval(32, 244);    // in unit of 0.625 ms
  Bluefruit.Advertising.setFastTimeout(30);      // number of seconds in fast mode
  Bluefruit.Advertising.start(0);                // 0 = Don't stop advertising after n seconds  
}

void loop() {
  
  currentState = digitalRead(BUTTON_PIN);
  delay(10);
  debounceState = digitalRead(BUTTON_PIN);
  

  if( currentState == debounceState  ) { 
    if ( currentState != switchState ) { 

      if ( currentState == LOW ) { 
        // Button just released
        
      } else { 
        Serial.print(F("Button event: "));
        if ( ledState == 0 ) {
          stateCharacteristic.notify8(1); ❼
          switchCharacteristic.write8(1);
          digitalWrite(LED_PIN, HIGH);
          ledState = 1;
           Serial.println(F("light on"));
       } else {
          stateCharacteristic.notify8(0); ❽
          switchCharacteristic.write8(0);
          digitalWrite(LED_PIN, LOW);
          ledState = 0;
           Serial.println(F("light off"));
       }
      }
      switchState = currentState;
    }
  
  }
}

❶ Inclusion de la librairie Arduino Bluefruit
❷ Création du service avec l’UUID 0xFF10
❸ Création des caractéristiques
❹ Définition du nom du périphérique BLE qui sera affiché sur le smartphone
❺ Définition des propriétés des caractéristiques
❻ Définition de la configuration pour l’ « Advertising ». C’est un élément essentiel du BLE. Le code a été repris de la documentation de la librairie Bluefruit. https://learn.adafruit.com/adafruit-feather-sense/bleadvertising
❼ Bascule les valeurs de switch et state à 1 lors d’un appui sur le bouton-poussoir
❽ Bascule les valeurs de switch et state à 0 lors d’un autre appui

Une fois le code téléversé, vous devriez pouvoir allumer et éteindre la LED comme avant avec le bouton-poussoir mais en plus vous pouvez afficher le status sur un smartphone.
Sur Iphone vous pouvez utilisez l’application LightBlue. Au lancement, l’application scanne les périphériques BLE à proximité. Le périphérique « Light Switch » devrait apparaitre dans la liste. En cliquant dessus, la connexion est établie et les deux caractéristiques « Switch » et « State » vont apparaître.

Pour le moment, il est possible de lire le status de la LED mais pas de changer l’état depuis le smartphone. Pour faire cela, il faut rajouter un gestionnaire d’événements (ou handler).
Rajouter la ligne suivante juste après switchCharacteristic.begin();

switchCharacteristic.setWriteCallback(switchCharacteristicWritten);

Puis à la fin du sketch rajouter :

void switchCharacteristicWritten(uint16_t conn_hdl, BLECharacteristic* chr, uint8_t* data, uint16_t len) {
  (void) conn_hdl;
  (void) chr;
  (void) len; // len should be 1
  
  Serial.print(F("Characteristic event: "));
  if (data[0]) {
    Serial.println(F("light on"));
    digitalWrite(LED_PIN, HIGH);
    ledState = 1;
    stateCharacteristic.notify8(1); 
    
  } else {
    Serial.println(F("light off"));
    digitalWrite(LED_PIN, LOW);
    ledState = 0;
    stateCharacteristic.notify8(0);   
    
  }
}

Voilà maintenant, dans l’application LightBlue, cliquez sur la caractéristique Switch, puis sur « Write new value », entrez la valeur « 01 », puis cliquez sur Done, la LED va s’allumer, ou entrez la valeur « 00 », la LED va s’éteindre.
Le programme complet est disponible en téléchargement ici :
https://1drv.ms/u/s!AnDlERvozWJSiH0mic39i0BAGQDF?e=QXrVsk

Découverte du protocole Bluetooth Low Energy (BLE) par la pratique

Le but de cet article est d’analyser le protocole sans fil BLE à l’aide d’un capteur de température Xiaomi Mi Home et d’une application pour smartphone puis d’un dongle USB. L’objectif étant d’arriver à récupérer des informations du capteur sans passer par l’application officielle Xiaomi.

1. Matériel nécessaire

Tout d’abord, il faut acheter au minimum dongle USB avec le composant CC2540 et avec un câble de programmation :
L’original du fabricant TI à la référence CC2540EMK-USB, mais il en existe des similaires sur des sites comme Amazon, AliExpress
https://www.amazon.fr/AILOVA-D%C3%A9bogage-dInterface-Broche1Mbps-Renifleur/dp/B07Y858TDF/
https://fr.aliexpress.com/item/1005001847937687.html

Ensuite, un programmateur CC DEBUG :
https://www.amazon.fr/gp/product/B07FP5XHPM
et le capteur Xiaomi Mi Temperature and Humidity Monitor 2
Modèle : LYWSD03MMC
Il est compatible Bluetooth Low Energy BLE 4.2
on peut le trouver chez Boulanger ou sur sur AliExpress pour moins de 10€

Il n’est pas nécessaire d’avoir une passerelle Xiaomi, le capteur peut se connecter directement à un smartphone.

2. Test avec l’application nRF Connect

Télécharger l’application nRF Connect sur un smartphone Android ou Apple

Mettre le capteur de température à proximité du smartphone et lancer un scan.

Vous allez voir apparaître une ligne avec « LYWSD03MMC ». Avec l’application, on peut se connecter au capteur et lire plusieurs informations.

2. Lecture des paquets avec le dongle USB CC2540 de TI

Installer le logiciel SmartRF Flash programmer de Texas Instruments. Ne pas utiliser la version V2 qui n’est pas compatible avec le CC DEBUGGER. Par exemple la version 1.12.8 du 31 Mai 2016.
Le logiciel est gratuit, mais il faut avoir un compte TI pour le télécharger.
https://www.ti.com/tool/FLASH-PROGRAMMER
Ensuite, il faut installer le driver pour le CC DEBUGGER :
https://www.ti.com/lit/zip/swrc212
Après avoir installé le driver, connecter le CC DEBUGGER au PC. Vérifier que le debugger est bien reconnu en ouvrant le « Gestionnaire de Périphériques » de Windows. Le debugger devrait apparaitre comme un « Cebal controlled device »

Vérification du driver du CC DEBUGGER

Si le driver, n’est pas installé correctement, vous pouvez installer le driver manuellement.
Télécharger et installer le logiciel PACKET-SNIFFER :
https://www.ti.com/tool/PACKET-SNIFFER
(Ne pas utiliser SmartRF Packet Sniffer 2, il n’est pas compatible avec le CC2540) prendre par exemple la version v2.18.1 du 30 Juin 2014)
Récupérer le fichier C:\Program Files (x86)\Texas Instruments\SmartRF Tools\Packet Sniffer\bin\general\firmware\sniffer_fw_cc2540_usb.hex

3. Connecter le CC DEBUGGER

Brancher le CC DEBUGGER à un port USB du PC puis au dongle CC2540 qui lui même doit être connecté à un autre port USB du PC, comme sur la figure ci-dessous :

Branchements

Appuyer sur le bouton RESET du CC DEBUGGER, la LED devrait s’allumer en vert.

4.Programmation

Exécuter le logiciel Flash Programmer, dans la section Flash image, sélectionnez le fichier sniffer_fw_cc2540_usb.hex
Cliquer sur « Perform actions »

TI Flash Programmer

4. Lecture des trames

Exécuter le logiciel SmartRF Packet Sniffer, sélectionner le protocole « Bluetooth Low Energy » et cliquer sur « Start »

Logicel TI SmartRF Packet Sniffer

Vérifier que le dongle est bien reconnu et cliquer sur le bouton « Play » :

SmartRF Packet Sniffer démarrage

Les premières trames devraient apparaître. Il peut y en avoir beacoup car il y a de plus en plus d’émetteur Bluetooth autour de nous !
Mettre le capteur proche du dongle et observer la valeur RSSI. C’est la puissance du signal reçue. La valeur la plus élevée sera probablement celle du capteur.
Ici on voit -34dBm. Noter la valeur AdvA qui est l’adresse du capteur. Ici 0xA4C1388F4833

Affichage des trames BLE

Maintenant, on va filtrer les trames.
Dans le menu « Display filter », sélectionner le « Field Name » = ADV_IND AdvA et appuyer sur le bouton « First », puis entrer l’adresse AdvA récupéré plus haut dans le champ « Filter condition » : AA1=0xA4C1388F4833, cliquer sur Add, puis « Apply filter ».

Filtrage les trames BLE

On va chercher à retrouver le nom du capteur.
On peut constater que toutes les trames ADV_IND sont identiques, c’est des trames d' »ADVERTISEMENT ». Les données sont dans AdvData, mais on ne trouve pas le nom du capteur.
Donc cela doit être dans une autre trame. En effet, il est possible d’envoyer une trame ADV_SCAN_REQ et le capteur répondra par une trame ADV_SCAN_RSP on va donc rechercher ces trames.
Dans le menu « Display filter », sélectionner « Field Name » = « ADV_SCANRSP AdvA »
Cliquer sur le bouton « First », puis entrer l’adresse AdvA récupéré plus haut dans le champ « Filter condition » : AA5=0xA4C1388F4833
Cliquer sur Add, puis sur Apply filter.
Au bout d’un certain temps une trame va apparaitre :

Trame ADV_SCANRSP

Dans cette trame, on peut analyser les données « ScanRspData » et observer que le code hexadécimal convertit en caractères ASCII correspond bien au nom du capteur :

4C5957534430334D4D43
LYWSD03MMC
Décodage nom du capteur en ASCII

Dans un autre article, on apprendra à décoder les trames BLE et voir si il est possible de décoder les données de température et d’humidité du capteur.

Vidéo : Simulation d’une antenne PCB 2.4 GHz avec CAPITOLE-RF

Cette antenne a été conçue par Texas Instruments et est utilisable pour tous les composants radios fonctionnant à 2.4 GHz.
Application Report – 2.4-GHz Inverted F Antenna
https://www.ti.com/lit/an/swru120d/swru120d.pdf
Télécharger le logiciel gratuit FREECAD pour créer le modèle géométrique :
https://www.freecadweb.org
Télécharger la version d’évaluation 90 jours de CAPITOLE-RF :
https://nexiogroup.com/produits/produits-logiciels-de-simulation/
Cette vidéo est inspirée d’une autre vidéo qui utilise ANSYS HFSS au lieu de CAPITOLE-RF
https://www.youtube.com/watch?v=dHvuFT6N95k
Je peux vous envoyer les fichiers du projet sur demande par le formulaire contact.
Les fichiers à télécharger :

Analyse du protocole Zigbee : Sniffer CC2531

Le but de cet article est d’analyser le protocole sans fil Zigbee à l’aide d’un sniffer USB. Pour cela on va intercepter les communications entre une passerelle Xiaomi et un capteur de température et d’humidité avec un dongle USB. L’objectif étant d’arriver à lire les informations de température du capteur.
Cet article est inspiré d’un très bon article du Blog « Faire Soi-Même » (lien en bas de la page), mais en utilisant d’autre outils.

1. Achats

Tout d’abord, il faut acheter au minimum dongle USB avec le composant CC2531 et avec un câble de programmation :
L’original du fabricant TI à la référence CC2531EMK, mais il en existe des similaires sur des sites comme Amazon, AliExpress ou LeBonCoin
https://www.amazon.fr/gp/product/B07YDG4QHM
Ensuite, un programmateur CC DEBUG :
https://www.amazon.fr/gp/product/B07FP5XHPM
Et aussi un capteur avec sa passerelle qui vont communiquer avec le protocole Zigbee.
La passerelle :
https://www.amazon.fr/gp/product/B082XCWH71
Le capteur de température et d’humidité :
https://fr.aliexpress.com/item/32711728819.html

2. Installation

Installer le logiciel SmartRF Flash programmer de Texas Instruments. Ne pas utiliser la version V2 qui n’est pas compatible avec le CC DEBUGGER. Par exemple la version 1.12.8 du 31 Mai 2016.
Le logiciel est gratuit, mais il faut avoir un compte TI pour le télécharger.
https://www.ti.com/tool/FLASH-PROGRAMMER
Ensuite, il faut installer le driver pour le CC DEBUGGER :
https://www.ti.com/lit/zip/swrc212
Après avoir installer le driver, connecter le CC DEBUGGER au PC.Vérfier que le debugger est bien reconnu en ouvrant le « Gestionnaire de Périphériques » de Windows. Le debugger devrait apparaitre comme un « Cebal controlled device »

Vérification du driver du CC DEBUGGER

Si le driver, n’est pas installé correctement, vous pouvez installer le driver manuellement.
Installer le logiciel PACKET-SNIFFER. (Pas la v2, la version v2.18.1 du 30 Juin 2014) pour récupérer un fichier dans
C:\Program Files (x86)\Texas Instruments\SmartRF Tools\Packet Sniffer\bin\general\firmware\sniffer_fw_cc2531.hex

3. Connecter le CC DEBUGGER

Brancher le CC DEBUGGER à un port USB du PC puis au dongle CC2131 qui lui même doit être connecté à un autre port USB du PC, comme sur la figure ci-dessous :

Branchements

Appuyer sur le bouton RESET du CC DEBUGGER, la LED devrait s’allumer en vert.

4.Programmation

Exécuter le logiciel Flash Programmer, dans la section Flash image, sélectionnez le fichier sniffer_fw_cc2531.hex dans le répertoire C:\Program Files (x86)\Texas Instruments\SmartRF Tools\Packet Sniffer\bin\general\firmware\
Cliquer sur « Perform actions »

TI Flash Programmer

4. Installation des logiciels

Télécharger le logiciel Wireshark et l’installer
https://www.wireshark.org/#download
Prendre une version v3.0.x et pas la dernière car elles ne sont pas toutes compatible avec les logiciels TI (Par exemple Wireshark-win64-3.0.12.exe)
Télécharger le logiciel SmartRF Packet Sniffer2, cette fois ci. (version v1.8.0 du 22 janvier 2020 par exemple) et l’installer.
https://www.ti.com/tool/PACKET-SNIFFER
Mais toujours pas pour l’utiliser mais pour récupérer certains fichiers dans C:\Program Files (x86)\Texas Instruments\SmartRF Tools\SmartRF Packet Sniffer 2\wireshark\plugins\3.0.x

Les copier dans le répertoire suivant :
C:\Program Files\Wireshark\plugins\3.0
Télécharger et installer TI Wireshark Packet Converter (TiWsPc) :
https://e2e.ti.com/cfs-file/__key/communityserver-discussions-components-files/158/TiWsPc.zip
Executer le logiciel TiWsPc.

Cliquer sur Device Configuration, sélectionner le canal et cliquer sur Start.
Le canal par défaut est le 13, mais dans certains cas, les équipements communiquent sur d’autres canaux, comme le 20 ici. Il faut les tester un par un et attendre de recevoir des « packets ».

Exécuter Wireshark :

Aller dans le menu Capture->Option

Puis cliquer sur « Gérer les interfaces… »

Puis l’onglet « Pipes », créer une entrée avec « \.\pipe\tiwspc_data »

Cliquer sur OK puis Démarrer.
Prendre la passerelle Xiaomi et le capteur de température. Faire une association entre les deux.
Les première trames Zigbee devraient apparaitre dans Wireshark. Mais elles sont cryptées. En effet, le protocole Zigbee utilise un système de cryptage AES 128.

5. Décodage des trames

Il est possible de décoder les trames.
Pour cela, il faut entrer une clé, la Trust Center Link Key dans le logiciel Wireshark.
Aller dans le menu Editer->Préférences

Rechercher « Protocols » puis « Zigbee ».

Cliquer sur Edit et entrer la clé :
5A:69:67:42:65:65:41:6C:6C:69:61:6E:63:65:30:39

Dans Wireshark, une parties des trames vont être automatiquement décryptées.

On peut voir une trame « Transport Key », qui contient la Network Key

Wireshark récupére directement cette clé et décrypte toutes les trames. La Network Key peut aussi être enregistrée dans Wireshark, comme la Trust Center Link Key (voir méthode ci-dessus) si on souhaite faire d’autres enregistrements plus tard.
Et voilà, maintenant on peut ainsi lire les informations utiles du capteur comme la température dans les trames ZCL (Zigbee Cluster Library) :


Liens utiles :
http://faire-ca-soi-meme.fr/domotique/2017/02/27/hack-xiaomi-mi-smart-temperature-and-humidity-sensor/
https://connect.ed-diamond.com/MISC/MISC-086/Tout-tout-tout-vous-saurez-tout-sur-le-ZigBee
https://lucidar.me/fr/zigbee/zigbee-sniffer/
https://www.ti.com/tool/CC2531EMK
https://www.zigbee2mqtt.io/how_tos/how_to_sniff_zigbee_traffic.html
https://sunmaysky.blogspot.com/2018/10/how-to-use-cc2531emk-and-wireshark-as.html

Vidéo : Test du xaVNA

Test complet avec :
– Test du logiciel
– Calibration
– Mesure du S11 d’une antenne Wi-Fi
Caractéristiques :
Fréquences (spécifications garanties) : 35 MHz à 2.5 GHz
Fréquences (disponibles) : 35 MHz à 3.5 GHz
Niveau de signal : -30 dBm à 9 dBm
Niveau de signal pour mesure du S11 : jusqu’à -10dBm
S11 bruit de trace : <0.1 dB
Plage dynamique pour le S11 (calibrée) : 50 dBm
Plage dynamique pour le S21 ( calibrée) :
70dB jusqu’à 800 MHz
50dB au dessus de 800 MHz