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

Introduction

Le PSoC 6 est le dernier ajout à la puissante série de processeurs PSoC de Cypress. Le PSoC 6 Pioneer IoT Add-On Shield 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, etc., tous liés à un processeur PSoC 6. Le processeur est un appareil à double cœur, avec un processeur basse consommation Cortex-M0+ et un processeur haute puissance Cortex-M4 reliés ensemble via des périphériques partagés et un espace mémoire.

Ce didacticiel vous montrera comment utiliser la Pioneer Board, en utilisant le Pioneer Add-on Shield pour étendre les capacités de l'appareil PSoC 6. Nous allons vous montrer comment communiquer avec un Raspberry Pi via BLE et WiFi (à l'aide d'un module WiFi XBee), ainsi que comment communiquer entre une carte Pioneer PSoC 4 BLE et la carte Pioneer PSoC 6 via BLE.

Matériel requis

Les exemples de ce didacticiel sont destinés à être utilisés avec le kit PSoC 6 Pioneer, qui peut être acheté directement auprès de Cypress ou de Digi-Key.

Évidemment, vous aurez également besoin d'un bouclier complémentaire Pioneer. Vous aurez également besoin d'un module WiFi XBee. Il existe quelques options Wi-Fi XBee en fonction de votre configuration : Trace, Connecteur RP-SMA avec antenne externe 2,4 GHz ou Wire . Le plus simple serait d'obtenir XBee avec l'antenne filaire.

Vous aurez également besoin du kit de démarrage Raspberry Pi 3. Cela deviendra votre cible pour la communication de la PSoC6 Pioneer Board. Vous pouvez, bien sûr, simplement acheter le Pi 3 séparément avec une maquette, des câbles de connexion, des résistances et des LED, mais nous pensons que le kit de démarrage est une offre exceptionnelle et vaut la peine d'être acheté.

Présentation du matériel

Examinons en détail les fonctionnalités de la carte d'extension IoT Pioneer Kit.

Fente pour carte MicroSD – Les broches de cet emplacement correspondent au 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,3V.

Connecteur d'alimentation USB MicroB – Les lignes de données sur ce connecteur ne sont connectées à rien. Il fournit 5V au régulateur 3,3V pour le module XBee, remplaçant le 5V 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 lié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.3V – Régulateur de puissance à découpage 3,3 V capable de fournir jusqu'à 1,5 A, en fonction de la capacité d'approvisionnement en amont. Tire l'alimentation de l'alimentation 5V sur les broches Arduino ou le connecteur d'alimentation MicroB. Alimente uniquement l'en-tête XBee.

Tampon de changement de niveau – Down convertit les signaux 5V en signaux 3,3V. Permet d'utiliser la carte dans des systèmes 3,3 V ou 5 V.

Circuit de changement de niveau I2C – Convertit les signaux I2C de 3,3 V à 5 V, si nécessaire.

Cavalier de sélection d'alimentation en tension – Sélectionne le niveau auquel les circuits de décalage de niveau I2C se traduisent. La valeur par défaut est 3,3 V . Réglez sur 5V pour une utilisation avec des systèmes 5V. Les cartes Pioneer BLE PSoC 4 et PSoC 6 sont toutes les deux 3,3 V systèmes.

LED XBee DIO5 – DIO5 utilise par défaut certaines fonctions utiles, en particulier sur le module WiFi, où il affiche la connectivité au réseau WiFi configuré.

Exemple :WiFi vers Raspberry Pi à l'aide du kit PSoC 6 Pioneer

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

Suivre cet exemple va nécessiter une certaine configuration, alors allons-y maintenant.

Configuration du kit PSoC 6 Pioneer :matériel

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

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

Configuration du kit PSoC 6 Pioneer :logiciel

Remarque :  La prise en charge de 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 LOGICIEL PSOC 6 PIONEER KIT

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

Avant de faire quoi que ce soit d'autre, vous devez ouvrir le "main_cm4.c " et apportez quelques modifications. Vous trouverez une section de code qui ressemble à ceci :
char ssid[] =« your_ssid_here » ;
char rpi_ip[] =« raspi_ip_here » ;
char ssid_pw[] =« wifi_pw_here ”;
int dest_port =5000;
char encrypt_mode =WPA2;
J'espère que ce que vous devez faire est évident :modifiez ces paramètres pour qu'ils correspondent à votre configuration réseau. La valeur encrypt_mode peut être WPA, WEP, WPA2 ou (espérons-le pas !) NO_SECURITY. rpi_ip est un carré en pointillé (par exemple, "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 des instructions sur l'ouverture d'une fenêtre de commande) et en regardant le "wlan0 rubrique ".

Pour programmer la carte, connectez-la à votre PC via le câble USB-A vers USB-C fourni. Ensuite, cliquez sur le bouton "Programmer" dans la barre d'outils (comme indiqué ci-dessous) pour générer 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 dans l'élément de liste "KitProg2", l'une ou l'autre programmera correctement le flash.

Configuration Raspberry Pi :Matériel

Voyons 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 Raspberry Pi :Logiciel

Nous allons supposer que vous avez un Raspberry Pi configuré avec la dernière version de Raspbian (l'installation complète, pas la version allégée) 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, veuillez prendre quelques instants pour le configurer. Vous pouvez consulter notre tutoriel sur la configuration du Pi ici.

Commençons par 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 (illustré ci-dessous) pour ouvrir une ligne de commande. Le reste de ce didacticiel supposera que cette ligne de commande est 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 allons commencer par exécuter la commande pour installer Flask. Flask est un framework Web pour Python qui vous permet de créer une interface Web qui exécute des scripts Python sur le serveur principal de manière assez triviale. Tapez la commande suivante, puis appuyez sur "Entrée".
sudo pip install flask
Tout un tas de choses vont se passer 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 prendre en charge ce projet à partir de GitHub. La commande pour le faire est
git clone https://github.com/sparkfun/Flask_Tutorial
Encore une fois, vous verrez du texte défiler sur la ligne de commande, et lorsque l'invite revient, cela va être votre indication que le processus d'installation est terminé. Une fois cette opération terminée, entrez cette commande :
sudo python Flask_Tutorial/Python/app.py
Cela lancera l'application et commencera à écouter les entrées via TCP/IP de 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 de l'IoT Shield. Super !

Alors, que se passe-t-il ici ? pt. 1 : Le Kit Pionnier

Jetons un coup d'œil à ce qui se passe exactement, à partir d'une vue de haut niveau du projet logiciel PSoC 6. Regardez le cadre Explorateur d'espace de travail sur le côté gauche de l'écran. Nous allons parcourir ce cadre, en soulignant les fichiers importants et leur lien avec l'ensemble du projet.

Vous avez du mal à voir l'explorateur de l'espace de travail ? Cliquez sur l'image pour voir de plus près.

Le niveau supérieur du projet comporte six entrées :le schéma (« TopDesign.sch "), les ressources de conception ("XBee_WiFi_Example.cydwr "), les fichiers sources associés au noyau Cortex-M0+ ("CM0p (Core 0) "), les fichiers sources associés au noyau Cortex-M4 ("CM4 (Core 1) "), fichiers à partager entre les deux ("Fichiers partagés "), et les fichiers de support générés par l'IDE ("Generated_Source ”).

Le schéma de ce projet est très simple, avec quelques LED, quelques commutateurs et l'UART utilisé pour transférer des données vers et depuis le module WiFi XBee. Les LED sont en fait inutilisées dans la mise en œuvre actuelle du projet.

Nous allons sauter le contenu du .cydwr déposer. 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 de base. Si vous voulez en savoir plus, n'hésitez pas à creuser un peu. Une grande partie devrait être explicite.

En descendant dans la liste, nous atteignons nos fichiers source Cortex-M0+. Vous remarquerez que le niveau supérieur de ce sous-domaine comporte cinq entrées :"Fichiers d'en-tête", "Fichiers sources" et trois autres fichiers. Nous n'avons qu'à nous préoccuper du contenu des sous-domaines « Fichiers d'en-tête » et « Fichiers sources », et en fait, d'un seul fichier dans ceux-ci :le « main_cm0p.c " déposer. C'est là que réside la fonction main() du code qui s'exécute sur le processeur Cortex-M0+.

Comme vous l'avez peut-être deviné à partir de la structure de l'espace de travail, il existe deux bases de code entièrement distinctes en cours d'exécution pour les deux cœurs différents. « main_cm0p.c ” est le point d'entrée du code du noyau Cortex-M0+, puis ce noyau démarre le noyau Cortex-M4. Il existe un sous-domaine similaire pour le noyau Cortex-M4 avec des fichiers similaires et encore une fois, nous n'avons qu'à nous soucier des sous-domaines "Fichiers d'en-tête" et "Fichiers sources".

Enfin, nous avons la section « Fichiers partagés ». La plupart de ces fichiers sont générés automatiquement, enregistrez le "ipc_common.c » et « ipc_common.h " des dossiers. Ces fichiers sont des aides pour la communication interprocessus développées pour ce projet.

Le fichier principal Cortex-M0+

Maintenant que nous avons mis en évidence le contenu important, examinons les éléments importants du code, un fichier à la fois, en commençant par le "main_cm0p.c " déposer. Ce fichier gère toute l'activité que le noyau 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 d'entre eux est enfoncé.

Cependant, ce n'est pas aussi simple qu'il 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 plusieurs processus travaillent sur le même ensemble de données, vous devez prendre en compte 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 faire face à cela, nous utilisons un système de lecture et d'écriture protégé, configuré dans le "ipc_common " fichiers.

Pour comprendre comment cela fonctionne, il faut d'abord comprendre le concept d'un 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 struct 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 7 du système. Nous utilisons le canal 7 car les canaux 0-6 sont réservés à l'utilisation du système.

Ensuite, il faut bien entendu dire à l'autre core quelle adresse mémoire est associée à ce canal IPC. C'est ce que fait cet appel de fonction.
tandis que(Cy_IPC_Drv_SendMsgPtr(D9IpcHandle, CY_IPC_NO_NOTIFICATION, &D9Button) !=CY_IPC_DRV_SUCCESS);
D9Button est une variable configurée plus tôt dans le code. L'appel de fonction est entouré d'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'est-à-dire le code exécuté sur le noyau Cortex-M4) a reçu ces informations. Nous voulons également attendre que le verrou sur la variable soit relâché, indiquant que le Cortex-M4 a fini de lire la valeur du pointeur.
while(Cy_IPC_Drv_IsLockAcquired(D9IpcHandle));
Enfin, nous tombons dans notre infini boucle pour l'application, où les fonctions personnalisées ReadSharedVar() et WriteSharedVar() gèrent la mise à jour des variables partagées qui communiquent l'état du bouton avec l'autre noyau. Nous approfondirons ces fonctions plus tard.

Le fichier principal Cortex-M4

Dans la fonction Cortex-M4 main() , nous répétons certaines des mêmes opérations que dans la fonction Cortex-M0+ main() vis-à-vis de la configuration 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 envoyé par le processus Cortex-M0+, contenant l'adresse de la variable partagée à laquelle 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() afin qu'il soit continuellement appelé jusqu'à ce que le message soit envoyé depuis le Cortex-M0+. Ensuite, nous devons libérer le verrou sur ce canal IPC afin que le processus Cortex-M0+ sache qu'il peut continuer à fonctionner et utiliser le canal IPC à l'avenir. Il n'est pas nécessaire d'enfermer cette boucle dans un while() car elle est ouverte :l'appel ne doit être émis qu'une seule fois pour libérer le verrou, au lieu de vérifier que le verrou a été libéré, ce qui doit être répété jusqu'à ce que le le verrou est libéré.
Cy_IPC_Drv_LockRelease(D9IpcHandle, CY_IPC_NO_NOTIFICATION) ;
Une fois tout cela terminé, nous devons configurer le bouclier WiFi XBee 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 du bouton, qui sont partagées avec le noyau Cortex-M0+. Examinons de plus près ce que font ces fonctions.

Lire plus d'informations……

Utilisation de la carte Pioneer PSoC 6 avec le bouclier d'extension Pioneer IoT