Maîtriser la Carte PSoC 6 Pioneer avec le Shield IoT Add-On : Guide du Développeur

Introduction

Le PSoC 6 est le dernier ajout à la puissante série PSoC de processeurs de Cypress. Le shield IoT Add-On Pioneer est l'outil de développement associé à cette gamme de processeurs, doté d'un débogueur intégré, d'en-têtes compatibles Arduino, de widgets CapSense, et plus encore, le tout lié à un processeur PSoC 6. Le processeur est un dispositif à double cœur, avec un Cortex-M0+ à faible consommation et un Cortex-M4 haute performance reliés via des périphériques et un espace mémoire partagés.

Ce tutoriel vous montrera comment démarrer avec la carte Pioneer, en utilisant le shield Pioneer Add-on pour étendre les capacités du dispositif PSoC 6. Nous vous montrerons comment communiquer avec un Raspberry Pi via BLE et WiFi (en utilisant un module XBee WiFi), ainsi que comment communiquer entre une carte PSoC 4 BLE Pioneer et la carte PSoC 6 Pioneer via BLE.

Matériel Requis

Les exemples de ce tutoriel sont destinés à être utilisés avec le kit PSoC 6 Pioneer, disponible directement chez Cypress ou chez Digi-Key.

Vous aurez également besoin d'un shield Pioneer Add-on. Vous aurez aussi besoin d'un module XBee WiFi. Il existe quelques options XBee WiFi selon votre configuration : Trace, connecteur RP-SMA avec antenne externe 2,4 GHz, ou Wire. Le plus simple serait d'obtenir un XBee avec antenne filaire.

Vous aurez également besoin du kit de démarrage Raspberry Pi 3. Ce sera votre cible pour la communication depuis la carte PSoC 6 Pioneer. Vous pouvez bien sûr acheter le Pi 3 séparément avec une plaque d'essai, des fils de liaison, des résistances et des LED, mais nous pensons que le kit de démarrage est une excellente affaire et vaut vraiment le coup.

Vue d'ensemble du Matériel

Passons en revue en détail les fonctionnalités de la carte Pioneer Kit IoT Add-on.

• Emplacement pour carte MicroSD — Les broches de cet emplacement sont mappées sur le périphérique SPI sur la plupart des cartes compatibles Arduino, y compris la carte PSoC 6 BLE Pioneer.
• En-tête XBee — Cet en-tête est espacé pour accepter l'empreinte XBee standard. Il est compatible avec tous les modules XBee officiels.
• Connecteur Qwiic — Ce connecteur ajoute la prise en charge de tous les modules Qwiic de SparkFun. Il fournit 3,3 V.
• Connecteur d'Alimentation MicroB USB — Les lignes de données sur ce connecteur ne sont connectées à rien. Il fournit 5 V au régulateur 3,3 V pour le module XBee, remplaçant le 5 V provenant de l'en-tête Arduino et permettant aux modules XBee à haute puissance (tels que les modèles cellulaires, WiFi ou Pro) de fonctionner correctement.
• Boutons D7 et D9 — Deux boutons utilisateur reliés aux broches D7 et D9 (P0.2 et P13.1 sur le PSoC 6, ou P1.0 et P0.4 sur PSoC 4 BLE).
• Régulateur 3,3 V — Régulateur à découpage 3,3 V capable de fournir jusqu'à 1,5 A, selon la capacité de la source d'alimentation en amont. Puise l'énergie de l'alimentation 5 V sur les broches Arduino ou du connecteur d'alimentation MicroB. Alimente uniquement l'en-tête XBee.
• Tampon de Décalage de Niveau — Convertit les signaux 5 V en signaux 3,3 V. Permet à la carte d'être utilisée dans des systèmes 3,3 V ou 5 V.
• Circuit de Décalage de Niveau I2C — Convertit les signaux I2C de 3,3 V à 5 V, si nécessaire.
• Jumper de Sélection de Tension d'Alimentation — Sélectionne le niveau auquel le circuit de décalage de niveau I2C traduit. Par défaut réglé sur 3,3 V. Réglez sur 5 V pour une utilisation avec des systèmes 5 V. Les cartes Pioneer BLE PSoC 4 et PSoC 6 sont toutes deux des systèmes 3,3 V.
• LED XBee DIO5 — DIO5 prend par défaut des fonctions utiles, surtout sur le module WiFi, où elle indique la connectivité au réseau WiFi configuré.

Exemple : WiFi vers Raspberry Pi avec le Kit PSoC 6 Pioneer

Cet exemple montre comment envoyer un signal à un Raspberry Pi via WiFi. Il vous montrera comment accéder à un module XBee WiFi, la communication inter-processus entre les deux cœurs du PSoC 6, et comment recevoir et analyser les commandes avec un Raspberry Pi.

Suivre cet exemple nécessite une certaine configuration, parcourons-la maintenant.

Configuration du Kit PSoC 6 Pioneer : Matériel

La configuration côté Pioneer Kit est triviale : insérez le module XBee WiFi dans le shield Pioneer IoT Add-on et insérez le shield dans l'en-tête Arduino de la carte Pioneer Kit.

Le côté Raspberry Pi nécessite plus d'explications. Vous devrez configurer à la fois du matériel et du logiciel sur le Raspberry Pi.

Configuration du Kit PSoC 6 Pioneer : Logiciel

Note : La prise en charge du PSoC 6 n'est disponible que dans Creator 4.2 ou version ultérieure !

Le projet logiciel pour le Pioneer Kit est disponible sur GitHub.

TÉLÉCHARGEMENT DU LOGICIEL PSoC 6 PIONEER KIT

Une fois téléchargé et extrait quelque part, vous pouvez ouvrir l'exemple (XBee_WiFi_Example) dans PSoC Creator.

Avant toute chose, vous devez ouvrir le fichier « main_cm4.c » et apporter quelques modifications. Vous trouverez une section de code qui ressemble à ceci :

char ssid[] = "votre_ssid_ici";
char rpi_ip[] = "ip_du_raspi_ici";
char ssid_pw[] = "mot_de_passe_wifi_ici";
int dest_port = 5000;
char encrypt_mode = WPA2;

Espérons qu'il est évident ce que vous devez faire : modifiez ces paramètres pour correspondre à votre configuration réseau. La valeur encrypt_mode peut être WPA, WEP, WPA2, ou (espérons-le pas !) NO_SECURITY. rpi_ip est un quadripoint (ex. « 10.8.253.193 ») que vous pouvez obtenir en tapant « ifconfig » dans une fenêtre de commande sur votre Raspberry Pi (voir ci-dessous pour les instructions sur l'ouverture d'une fenêtre de commande) et en regardant la section « wlan0 ».

Pour programmer la carte, connectez-la à votre PC via le câble USB-A vers USB-C inclus. Ensuite, cliquez sur le bouton « Program » dans la barre d'outils (comme indiqué ci-dessous) pour construire automatiquement le projet et programmer la carte.

Vous pouvez obtenir une fenêtre comme ci-dessous vous demandant de choisir une cible à programmer. Peu importe l'entrée que vous choisissez sous l'élément de liste « KitProg2 », les deux programmeront correctement la flash.

Configuration du Raspberry Pi : Matériel

Regardons d'abord comment le matériel est connecté :

Comme vous pouvez le voir, nous avons connecté une LED (avec une résistance de 330 ohms) aux broches 3 (GPIO 2) et 6 (masse) du Raspberry Pi. Cela nous permettra de basculer GPIO2 et de voir le résultat sur la LED.

Configuration du Raspberry Pi : Logiciel

Nous supposons que vous avez un Raspberry Pi configuré avec la dernière version de Raspbian (l'installation complète, pas la version lite) en cours d'exécution, et qu'il est connecté à un clavier, une souris, un moniteur et un réseau WiFi local. Si ce n'est pas le cas, prenez quelques instants pour configurer cela. Vous pouvez consulter notre tutoriel sur la configuration du Pi ici.

Commençons depuis le bureau du Raspberry Pi. Vous devriez avoir un écran qui ressemble à ceci :

Vous devrez cliquer sur le petit logo en haut de l'écran (montré ci-dessous) pour ouvrir une ligne de commande. Le reste de ce tutoriel supposera que vous avez cette ligne de commande ouverte.

Cela ouvrira une fenêtre de ligne de commande. Cela vous permet de dire au Raspberry Pi d'exécuter directement des commandes.

Nous commencerons par exécuter la commande pour installer Flask. Flask est un framework web pour Python qui vous permet de créer un front-end web qui exécute des scripts Python sur le backend serveur assez trivialement. Tapez la commande suivante, puis appuyez sur « Entrée ».

sudo pip install flask

Beaucoup de choses se passeront dans la fenêtre de ligne de commande et à la fin, Flask sera installé sur votre Raspberry Pi.

L'étape suivante consiste à installer le logiciel que nous avons écrit pour soutenir ce projet depuis GitHub. La commande pour cela est :

git clone https://github.com/sparkfun/Flask_Tutorial

Encore une fois, vous verrez du texte défiler dans la ligne de commande, et quand l'invite revient, ce sera votre indication que le processus d'installation est terminé. Une fois cela fait, entrez cette commande :

sudo python Flask_Tutorial/Python/app.py

Cela lancera l'application et commencera à écouter les entrées via TCP/IP depuis la carte Pioneer. Vous devriez maintenant pouvoir allumer et éteindre la LED connectée au Raspberry Pi en appuyant sur les boutons D7 et D9 sur le shield IoT. Sympa !

Que Se Passe-t-il Ici ? Partie 1 : Le Kit Pioneer

Regardons ce qui se passe exactement, en partant d'une vue d'ensemble du projet logiciel PSoC 6. Regardez le cadre Workspace Explorer sur le côté gauche de l'écran. Nous allons parcourir ce cadre, en mettant en évidence les fichiers importants et comment ils se rapportent au projet global.

Difficile de voir le Workspace Explorer ? Cliquez sur l'image pour un aperçu plus proche.

Le niveau supérieur du projet a six entrées : le schéma (« TopDesign.sch »), les Design Wide Resources (« XBee_WiFi_Example.cydwr »), les fichiers sources associés au cœur Cortex-M0+ (« CM0p (Core 0) »), les fichiers sources associés au cœur Cortex-M4 (« CM4 (Core 1) »), les fichiers partagés entre les deux (« Shared Files »), et les fichiers de support générés par l'IDE (« Generated_Source »).

Le schéma pour ce projet est très simple, ayant quelques LED, quelques interrupteurs, et l'UART utilisé pour transférer des données vers et depuis le module XBee WiFi. Les LED ne sont en fait pas utilisées dans l'implémentation actuelle du projet.

Nous allons passer sur le contenu du fichier .cydwr. Ce fichier contient les affectations de broches pour les signaux utilisés dans le schéma, la génération d'horloge et les constantes de configuration des cœurs. Si vous voulez l'examiner davantage, n'hésitez pas à creuser un peu. La plupart devrait être auto-explicatif.

En descendant la liste, nous atteignons nos fichiers sources Cortex-M0+. Vous noterez que le niveau supérieur dans ce sous-domaine a cinq entrées : « Header Files », « Source Files », et trois autres fichiers. Nous n'avons besoin de nous préoccuper que du contenu des sous-domaines « Header Files » et « Source Files », et en fait, seulement d'un fichier dans ceux-ci : le fichier « main_cm0p.c ». C'est là que vit la fonction main() pour le code qui s'exécute sur le processeur Cortex-M0+.

Comme vous l'avez deviné à partir de la structure de l'espace de travail, il y a deux bases de code entièrement distinctes qui s'exécutent pour les deux cœurs différents. « main_cm0p.c » est le point d'entrée pour le code du cœur Cortex-M0+, et ensuite ce cœur démarre le cœur Cortex-M4. Il existe un sous-domaine similaire pour le cœur Cortex-M4 avec des fichiers similaires et encore une fois, nous n'avons besoin de nous préoccuper que des sous-domaines « Header Files » et « Source Files ».

Finalement, nous avons la section « Shared Files ». La plupart de ces fichiers sont générés automatiquement, sauf les fichiers « ipc_common.c » et « ipc_common.h ». Ce sont des assistants pour la communication inter-processus développés pour ce projet.

Le Fichier Principal Cortex-M0+

Maintenant que nous avons mis en évidence les contenus importants, jetons un coup d'œil aux parties importantes du code, un fichier à la fois, en commençant par le fichier « main_cm0p.c ». Ce fichier gère toute l'activité que le cœur Cortex-M0+ fait pour le système : surveiller les deux boutons poussoirs et envoyer un signal au Cortex-M4 lorsque l'un ou l'autre est pressé.

Cependant, ce n'est pas aussi simple qu'il n'y paraît, car le Cortex-M4 doit être capable d'effacer le signal une fois qu'il l'a traité, ce qui signifie que plusieurs processus accèdent aux mêmes données. Chaque fois que vous avez plusieurs processus travaillant sur le même ensemble de données, vous devez considérer les effets d'une collision d'écriture. Que se passe-t-il si un processus tente de modifier les données au milieu de l'autre processus essayant de modifier les mêmes données ? Pour gérer cela, nous utilisons un système de lectures et d'écritures protégées, mis en place dans les fichiers « ipc_common ».

Pour comprendre comment cela fonctionne, il faut d'abord comprendre le concept de canal IPC. Les canaux IPC utilisent des sémaphores pour écrire des données d'un processus à un autre tout en garantissant qu'il n'y aura pas de collision entre les deux cœurs. Au début de l'exécution de l'application pour chaque cœur, vous devez établir des points de terminaison pour les canaux IPC à utiliser pendant l'exécution. Considérez ces deux lignes de code :

IPC_STRUCT_Type *D9IpcHandle;
D9IpcHandle = Cy_IPC_Drv_GetIpcBaseAddress(7);

La première crée un pointeur pour une structure qui définit les caractéristiques d'un canal IPC. La seconde définit en fait cette structure pour pointer vers un emplacement mémoire spécifique, celui du canal IPC système 7. Nous utilisons le canal 7 car les canaux 0-6 sont réservés pour l'utilisation système.

Ensuite, nous devons, bien sûr, dire à l'autre cœur quelle adresse mémoire est associée à ce canal IPC. C'est ce qu fait cet appel de fonction :

while(Cy_IPC_Drv_SendMsgPtr(D9IpcHandle, CY_IPC_NO_NOTIFICATION, &D9Button) != CY_IPC_DRV_SUCCESS);

D9Button est une variable définie plus tôt dans le code. L'appel de fonction est enfermé dans une boucle while() car nous voulons répéter l'appel de fonction jusqu'à ce que nous recevions la vérification que l'autre processus (c.-à-d., le code s'exécutant sur le cœur Cortex-M4) a reçu cette information. Nous voulons aussi attendre que le verrou sur la variable soit libéré, indiquant que le Cortex-M4 a fini de lire la valeur du pointeur.

while(Cy_IPC_Drv_IsLockAcquired(D9IpcHandle));

Finalement, nous entrons dans notre boucle infinie pour l'application, où les fonctions personnalisées ReadSharedVar() et WriteSharedVar() gèrent la mise à jour des variables partagées qui communiquent l'état des boutons avec l'autre cœur. Nous examinerons ces fonctions plus tard.

Le Fichier Principal Cortex-M4

Dans la fonction main() du Cortex-M4, nous répétons certaines des mêmes opérations que nous avons faites dans la fonction main() du Cortex-M0+ concernant la mise en place du canal IPC.

IPC_STRUCT_Type *D9IpcHandle;
D9IpcHandle = Cy_IPC_Drv_GetIpcBaseAddress(7);

Une fois cela terminé, nous devons ensuite appeler du code pour « attraper » le message qui a été envoyé depuis le processus Cortex-M0+, contenant l'adresse de la variable partagée à accéder.

while (Cy_IPC_Drv_ReadMsgPtr(D9IpcHandle, (void *)&D9Button) != CY_IPC_DRV_SUCCESS);

Encore une fois, nous enfermons cet appel dans une boucle while() pour qu'il soit appelé continuellement jusqu'à ce que le message soit envoyé depuis le Cortex-M0+. Ensuite, nous devons libérer le verrou sur ce canal IPC pour que le processus Cortex-M0+ sache qu'il peut continuer l'opération et utiliser le canal IPC à l'avenir. Il n'est pas nécessaire d'enfermer cela dans une boucle while() car il est ouvert : l'appel n'a besoin d'être émis qu'une fois pour libérer le verrou, contrairement à la vérification que le verrou a été libéré, qui doit être répétée jusqu'à ce que le verrou soit libéré.

Cy_IPC_Drv_LockRelease(D9IpcHandle, CY_IPC_NO_NOTIFICATION);

Une fois tout cela terminé, nous devons configurer le shield XBee WiFi pour accéder à notre réseau local. Nous ne dupliquerons pas tout ce code ici, car il est bien documenté dans l'exemple.

Dans la boucle infinie qui exécute le code de l'application, nous appelons à nouveau les fonctions personnalisées ReadSharedVar() et WriteSharedVar() pour accéder aux variables contenant l'état des boutons, qui sont partagées avec le cœur Cortex-M0+. Examinons de plus près ce que font ces fonctions.

Lire Plus d'Informations……

Utilisation de la Carte PSoC 6 Pioneer Board avec le Shield Pioneer IoT Add-on