ESP32 PlatformIO IDE pour VSCode - Entraide francophone

Téléchargez et installez le code officiel de Microsoft Visual Studio, PlatformIO IDE est construit dessus

Installez PlatformIO IDE.

Ouvrir le gestionnaire d’extensions VSCode

Rechercher l’extension officielle de l’IDE PlatformIO

Mise en place du projet

Tout d’abord, nous devons créer un nouveau projet en utilisant la page d’accueil de PlatformIO (pour ouvrir cette page, appuyez simplement sur l’icône Accueil dans la barre d’outils) :

Ensuite, nous devons sélectionner comme carte de développement,
Arduino comme framework et un chemin vers l’emplacement du projet (ou utiliser celui par défaut) :
Espressif ESP32 Dev Module

Le traitement du projet sélectionné peut prendre un certain temps (PlatformIO téléchargera et installera tous les packages requis). Après cela, nous avons un projet entièrement configuré qui est prêt pour le développement de code avec le framework
Arduino .

Ajout de code au projet généré

Ajoutons un peu de code réel au projet. Tout d’abord, nous ouvrons un fichier principal par défaut nommé main.cppdans le dossier src_dir et remplaçons son contenu par ce qui suit :

#include <Arduino.h>

void setup()
{
    Serial.begin(9600);
}

void loop()
{
    Serial.println("Hello world!");
    delay(1000);
}

Nous avons maintenant créé un projet de base prêt à être compilé et téléchargé.

Compilation et téléchargement du firmware

Nous pouvons maintenant construire le projet. Il existe plusieurs façons de compiler le firmware :

Option de construction dans le menu,Project Tasks
Bouton de création dans la barre d’outils PlatformIO ,
Menu des tâches : , ou dans la barre d’outils PlatformIO ,Tasks: Run Task... > PlatformIO: Build
Palette de commandes : , ouView: Command Palette > PlatformIO: Build
via des raccourcis claviercmd-alt-b / ctrl-alt-b

Marqué en rouge :

Si tout s’est bien passé, nous devrions voir un message de réussite dans la fenêtre du terminal :

Il existe également plusieurs façons de télécharger le firmware sur la carte :

Option de téléchargement dans le menu,Project Tasks
Bouton de téléchargement dans la barre d’outils PlatformIO ,
Palette de commandes : ,View: Command Palette > PlatformIO: Upload
en utilisant le menu des tâches : , ouTasks: Run Task... > PlatformIO: Upload
via les raccourcis clavier : :cmd-alt-u / ctrl-alt-u

Après le téléchargement, nous devons vérifier si le firmware est téléchargé correctement. Pour ce faire, ouvrez le moniteur série et vérifiez que le message de la carte est reçu. Pour ouvrir le moniteur série, nous pouvons utiliser les options suivantes :

Option moniteur dans le menu,Project Tasks
Bouton Moniteur série dans la barre d’outils PlatformIO ,
Palette de commandes : , ouView: Command Palette > PlatformIO: Monitor
Menu des tâches : :Tasks: Run Task... > PlatformIO: Monitor

Si le firmware fonctionne comme prévu, le message de la carte peut être observé dans la fenêtre du terminal :

Débogage du micrologiciel 

Configuration du matériel 

Afin d’utiliser une sonde JTAG avec un ESP32, nous devons connecter les broches suivantes :

Broche ESP32	Broche de sonde JTAG
`3.3V`	`Pin 1(VTref)`
`GPIO 9 (EN)`	`Pin 3 (nTRST)`
`GND`	`Pin 4 (GND)`
`GPIO 12 (TDI)`	`Pin 5 (TDI)`
`GPIO 14 (TMS)`	`Pin 7 (TMS)`
`GPIO 13 (TCK)`	`Pin 9 (TCK)`
`GPIO 15 (TDO)`	`Pin 13 (TDO)`

Le débogage est le moyen le plus simple de déboguer la carte. Tout d’abord, nous devons spécifier debug_tool dans « platformio.ini » (fichier de configuration du projet) . Dans ce tutoriel, une sonde de débogage Olimex ARM-USB-OCD-H est utilisée :

[env:esp32dev]
platform = espressif32
board = esp32dev
framework = arduino
debug_tool = olimex-arm-usb-ocd-h

Pour démarrer la session de débogage, nous pouvons utiliser les méthodes suivantes :

Debug: Start debuggingdans le menu du haut,
Start Debuggingoption dans le menu Accès rapide, ou
bouton de raccourci F5:

Nous devons attendre un certain temps pendant que PlatformIO initialise la session de débogage et sommes prêts à déboguer lorsque la première ligne après la fonction principale est mise en surbrillance.

Veuillez patienter lorsque la session de débogage est arrêtée à la première ligne de app_main()fonction
ATTENTION ! Veuillez définir un point d’arrêt à (ligne 13 dans la capture d’écran ci-dessous – cette ligne peut changer entre les versions)void loopTask(void *pvParameters)
Maintenant, appuyez sur le bouton CONTINUER/EXÉCUTER de la barre d’outils de débogage (icône de flèche droite)
La session de débogage doit s’arrêter à la première ligne de la fonctionvoid loopTask(void *pvParameters)
Maintenant, accédez à votre code de configuration/boucle Arduino et effectuez un débogage classique.

Nous pouvons parcourir le code à l’aide de boutons de contrôle, définir des points d’arrêt et ajouter des variables à
:
Watch window

Rédaction de tests unitaires 

Les cas de test de test unitaire peuvent être ajoutés à un seul fichier qui peut inclure plusieurs tests. Tout d’abord, dans ce fichier, nous devons ajouter quatre fonctions par défaut :setUp,et. Les fonctionsetsont utilisées pour initialiser et finaliser les conditions de test. Les implémentations de ces fonctions ne sont pas nécessaires pour exécuter des tests, mais si vous devez initialiser certaines variables avant d’exécuter un test, utilisez lafonction. De même, si vous devez nettoyer des variables, utilisezla fonction. Dans notre exemple, nous utiliserons ces fonctions pour initialiser et désinitialiser respectivement les états des LED. Leset agissent comme un simple programme Arduino dans lequel nous décrivons notre plan de test.tearDownsetuploopsetUptearDownsetUptearDownsetuploop

Créons un testdossier à la racine du projet et ajoutons un nouveau fichier, test_main.cpp, à ce dossier. Ensuite, les tests de base pour Stringla classe seront implémentés dans ce fichier :

test_string_concatteste la concaténation de deux chaînes
test_string_substringteste l’exactitude de l’extraction de la sous-chaîne
test_string_index_ofgarantit que la chaîne renvoie l’index correct du symbole spécifié
test_string_equal_ignore_caseteste la comparaison insensible à la casse de deux chaînes
test_string_to_upper_caseteste la conversion de la chaîne en majuscules
test_string_replaceteste l’exactitude de l’opération de remplacement

#include <Arduino.h>
#include <unity.h>

String STR_TO_TEST;

void setUp(void) {
    // set stuff up here
    STR_TO_TEST = "Hello, world!";
}

void tearDown(void) {
    // clean stuff up here
    STR_TO_TEST = "";
}

void test_string_concat(void) {
    String hello = "Hello, ";
    String world = "world!";
    TEST_ASSERT_EQUAL_STRING(STR_TO_TEST.c_str(), (hello + world).c_str());
}

void test_string_substring(void) {
    TEST_ASSERT_EQUAL_STRING("Hello", STR_TO_TEST.substring(0, 5).c_str());
}

void test_string_index_of(void) {
    TEST_ASSERT_EQUAL(7, STR_TO_TEST.indexOf('w'));
}

void test_string_equal_ignore_case(void) {
    TEST_ASSERT_TRUE(STR_TO_TEST.equalsIgnoreCase("HELLO, WORLD!"));
}

void test_string_to_upper_case(void) {
    STR_TO_TEST.toUpperCase();
    TEST_ASSERT_EQUAL_STRING("HELLO, WORLD!", STR_TO_TEST.c_str());
}

void test_string_replace(void) {
    STR_TO_TEST.replace('!', '?');
    TEST_ASSERT_EQUAL_STRING("Hello, world?", STR_TO_TEST.c_str());
}

void setup()
{
    delay(2000); // service delay
    UNITY_BEGIN();

    RUN_TEST(test_string_concat);
    RUN_TEST(test_string_substring);
    RUN_TEST(test_string_index_of);
    RUN_TEST(test_string_equal_ignore_case);
    RUN_TEST(test_string_to_upper_case);
    RUN_TEST(test_string_replace);

    UNITY_END(); // stop unit testing
}

void loop()
{
}

Nous sommes maintenant prêts à télécharger les tests sur la carte. Pour ce faire, nous pouvons utiliser les éléments suivants :

Bouton de test sur la barre d’outils PlatformIO ,
Option de test dans le menu, ouProject Tasks
Tasks: Run Task... > PlatformIO Testdans le menu du haut :

Après le traitement, nous devrions voir un rapport détaillé sur les résultats des tests :

Comme nous pouvons le constater dans le rapport, tous nos tests ont été concluants !

Ajout de fonctionnalités Bluetooth LE 

Créons maintenant une application de base qui peut interagir avec d’autres appareils BLE (par exemple des téléphones). Par exemple, le code suivant déclare une caractéristique BLE dont la valeur peut être imprimée sur le port série :

#include <Arduino.h>
#include <BLEDevice.h>
#include <BLEUtils.h>
#include <BLEServer.h>

#define SERVICE_UUID        "4fafc201-1fb5-459e-8fcc-c5c9c331914b"
#define CHARACTERISTIC_UUID "beb5483e-36e1-4688-b7f5-ea07361b26a8"

class MyCallbacks: public BLECharacteristicCallbacks {
    void onWrite(BLECharacteristic *pCharacteristic) {
      std::string value = pCharacteristic->getValue();
      if (value.length() > 0) {
        Serial.print("\r\nNew value: ");
        for (int i = 0; i < value.length(); i++)
          Serial.print(value[i]);
        Serial.println();
      }
    }
};

void setup() {
  Serial.begin(9600);

  BLEDevice::init("ESP32 BLE example");
  BLEServer *pServer = BLEDevice::createServer();
  BLEService *pService = pServer->createService(SERVICE_UUID);
  BLECharacteristic *pCharacteristic = pService->createCharacteristic(
                                         CHARACTERISTIC_UUID,
                                         BLECharacteristic::PROPERTY_READ |
                                         BLECharacteristic::PROPERTY_WRITE
                                       );

  pCharacteristic->setCallbacks(new MyCallbacks());

  pCharacteristic->setValue("Hello World");
  pService->start();

  BLEAdvertising *pAdvertising = pServer->getAdvertising();
  pAdvertising->start();
}

void loop() {
  delay(2000);
}

Nous pouvons maintenant compiler et télécharger ce programme sur la carte comme décrit dans les sections précédentes. Pour vérifier que notre application fonctionne comme prévu, nous pouvons utiliser n’importe quel smartphone Android doté de la fonction BLE et de l’outil Nordic nRF Connect .

Dans un premier temps, nous devons analyser tous les appareils BLE publicitaires et nous connecter à l’appareil appelé . Après une connexion réussie à la carte, nous devrions voir un « Service inconnu » avec un champ « Caractéristique inconnue » :ESP32 BLE example

Pour définir la valeur, nous devons envoyer un nouveau texte à la caractéristique BLE :

Le changement de valeur est imprimé sur le moniteur série :

Conclusion 

Nous disposons désormais d’un modèle de projet pour le ESP32-DevKitCtableau que nous pouvons utiliser comme modèle pour des projets ultérieurs.

Pour plus d’information, ce tutoriel à été extrait de : https://docs.platformio.org/

Ajout de code au projet généré

Compilation et téléchargement du firmware

Débogage du micrologiciel

Configuration du matériel

Rédaction de tests unitaires

Ajout de fonctionnalités Bluetooth LE

Conclusion

Laisser un commentaire Annuler la réponse

Débogage du micrologiciel 

Configuration du matériel 

Rédaction de tests unitaires 

Ajout de fonctionnalités Bluetooth LE 

Conclusion 