Het PSoC 6 Pioneer Board gebruiken met het Pioneer IoT Add-on Shield

Inleiding

De PSoC 6 is de nieuwste toevoeging aan de krachtige PSoC-processorreeks van Cypress. Het PSoC 6 Pioneer IoT Add-On Shield is de ontwikkelingstool die is gekoppeld aan deze processorlijn, met een ingebouwde debugger, Arduino-compatibele headers, CapSense-widgets en meer, allemaal gekoppeld aan een PSoC 6-processor. De processor is een dual-core apparaat, met een Cortex-M0+ low power processor en een Cortex-M4 high power processor die met elkaar verbonden zijn via gedeelde randapparatuur en geheugenruimte.

Deze tutorial laat je zien hoe je aan de slag kunt met het Pioneer Board, met behulp van het Pioneer Add-on Shield om de mogelijkheden van het PSoC 6-apparaat uit te breiden. We laten je zien hoe je communiceert met een Raspberry Pi via BLE en WiFi (met behulp van een XBee WiFi-module), en hoe je communiceert tussen een PSoC 4 BLE Pioneer Board en het PSoC 6 Pioneer Board via BLE.

Vereiste materialen

De voorbeelden in deze tutorial zijn bedoeld voor gebruik met de PSoC 6 Pioneer Kit, die rechtstreeks bij Cypress of bij Digi-Key kan worden gekocht.

Uiteraard heb je ook een Pioneer Add-on Shield nodig. Je hebt ook een XBee WiFi-module nodig. Er zijn een paar XBee wifi-opties, afhankelijk van uw configuratie:Trace, RP-SMA Connector met externe 2,4 GHz-antenne of Wire. Het gemakkelijkst zou zijn om XBee te krijgen met de draadantenne.

Je hebt ook de Raspberry Pi 3 Starter Kit nodig. Dit wordt uw communicatiedoel van het PSoC6 Pioneer Board. Je kunt de Pi 3 natuurlijk gewoon apart kopen, samen met een breadboard, jumperdraden, weerstanden en LED's, maar we denken dat de starterkit een uitzonderlijke deal is en de moeite waard is om te krijgen.

Hardwareoverzicht

Laten we de kenmerken van het Pioneer Kit IoT Add-on Board in detail bespreken.

MicroSD-kaartsleuf - De pinnen voor deze sleuf zijn toegewezen aan de SPI-randapparatuur op de meeste Arduino-compatibele kaarten, inclusief het PSoC 6 BLE Pioneer Board.

XBee-koptekst – Deze kop is gespreid om de standaard XBee-voetafdruk te accepteren. Het is compatibel met alle officiële XBee-modules.

Qwiic-connector - Deze connector voegt ondersteuning toe voor alle Qwiic-modules van SparkFun. Hij levert 3,3V.

MicroB USB-stroomaansluiting – Datalijnen op deze connector zijn nergens op aangesloten. Het levert 5V aan de 3,3V-regelaar voor de XBee-module, overschrijft de 5V die uit de Arduino-header komt en zorgt ervoor dat krachtige XBee-modules (zoals de mobiele, wifi- of Pro-modellen) goed kunnen functioneren.

D7- en D9-knoppen – Twee gebruikersknoppen gekoppeld aan pinnen D7 en D9 (P0.2 en P13.1 op de PSoC 6, of P1.0 en P0.4 op PSoC 4 BLE).

3.3V-regelaar – Schakelmodus 3,3V-stroomregelaar die tot 1,5A kan leveren, afhankelijk van de stroomopwaartse leveringscapaciteit. Trekt stroom van 5V-voeding op Arduino-pinnen of MicroB-voedingsconnector. Levert alleen stroom aan XBee-header.

Niveauverschuivingsbuffer - Omlaag converteert van 5V-signalen naar 3,3V-signalen. Hiermee kan het bord worden gebruikt in systemen van 3,3 V of 5 V.

I2C-niveauverschuivingscircuits – Converteert I2C-signalen van 3,3V naar 5V, indien nodig.

Spanning selectiejumper – Selecteert het niveau waarnaar de I2C-niveauverschuivingscircuits worden vertaald. Standaard ingesteld op 3,3V . Stel in op 5V voor gebruik met 5V-systemen. Zowel de PSoC 4 als de PSoC 6 Pioneer BLE-kaarten zijn 3,3V systemen.

XBee DIO5 LED – DIO5 is standaard ingesteld op enkele handige functies, vooral op de WiFi-module, waar het de verbinding met het geconfigureerde WiFi-netwerk laat zien.

Voorbeeld:WiFi naar Raspberry Pi met behulp van de PSoC 6 Pioneer Kit

Dit voorbeeld laat zien hoe je via wifi een signaal naar een Raspberry Pi stuurt. Het laat u zien hoe u toegang krijgt tot een XBee WiFi-module, interprocescommunicatie tussen de twee kernen van de PSoC 6 en hoe u opdrachten kunt ontvangen en ontleden met een Raspberry Pi.

Het volgen van dit voorbeeld vereist enige instelling, dus laten we dat nu doornemen.

PSoC 6 Pioneer Kit-setup:hardware

De zij-opstelling van de Pioneer Kit is triviaal:plaats de XBee WiFi-module in het Pioneer IoT Add-on Shield en steek het schild in de Arduino-header van het Pioneer Kit Board.

De Raspberry Pi-kant vereist meer uitleg. Je moet zowel wat hardware als wat software instellen op de Raspberry Pi.

PSoC 6 Pioneer Kit-setup:software

Opmerking:  PSoC 6-ondersteuning is alleen beschikbaar in Creator 4.2 of hoger!

Het softwareproject voor de Pioneer Kit is beschikbaar op GitHub.

PSOC 6 PIONEER KIT SOFTWARE DOWNLOAD

Zodra je het bestand ergens hebt gedownload en uitgepakt, kun je het voorbeeld (XBee_WiFi_Example) openen in PSoC Creator.

Voordat u iets anders doet, moet u de "main_cm4.c . openen ” bestand en breng een aantal wijzigingen aan. U vindt een gedeelte van de code dat er als volgt uitziet:
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;
Hopelijk is het duidelijk wat u moet doen:wijzig deze instellingen zodat ze overeenkomen met uw netwerkconfiguratie. De waarde voor encrypt_mode kan WPA, WEP, WPA2 of (hopelijk niet!) NO_SECURITY zijn. rpi_ip is een gestippelde quad (bijvoorbeeld '10.8.253.193') die u kunt verkrijgen door 'ifconfig te typen ” in een opdrachtvenster op je Raspberry Pi (zie hieronder voor instructies over het openen van een opdrachtvenster) en kijk naar de “wlan0 ” sectie.

Om het bord te programmeren, sluit u het aan op uw pc via de meegeleverde USB-A naar USB-C-kabel. Klik vervolgens op de knop "Programmeren" in de werkbalk (zoals hieronder weergegeven) om het project automatisch te bouwen en het bord te programmeren.

U krijgt mogelijk een venster zoals hieronder waarin u wordt gevraagd een doel te kiezen om te programmeren. Het maakt niet uit welk item u kiest onder het lijstitem "KitProg2", een van beide programmeert de flitser correct.

Raspberry Pi-configuratie:hardware

Laten we eerst eens kijken hoe de hardware is aangesloten:

Zoals je ziet hebben we een LED (met 330 ohm weerstand) aangesloten op pin 3 (GPIO 2) en 6 (massa) van de Raspberry Pi. Hierdoor kunnen we GPIO2 schakelen en het resultaat op de LED zien.

Raspberry Pi-installatie:software

We gaan ervan uit dat je een Raspberry Pi hebt ingesteld met de nieuwste versie van Raspbian (de volledige installatie, niet de lite-versie) en dat deze is verbonden met een toetsenbord, muis, monitor en lokaal wifi-netwerk. Als dit niet . is het geval is, neem dan even de tijd om dit in te stellen. Je kunt onze tutorial over het instellen van de Pi hier bekijken.

Laten we beginnen vanaf het bureaublad van de Raspberry Pi. Je zou een scherm moeten hebben dat er ongeveer zo uitziet:

U moet op het kleine logo bovenaan het scherm klikken (hieronder weergegeven) om een ​​opdrachtregel te openen. De rest van deze tutorial gaat ervan uit dat je die opdrachtregel open hebt staan.

Dat opent een opdrachtregelvenster. Hiermee kun je de Raspberry Pi vertellen om direct opdrachten uit te voeren.

We beginnen met het uitvoeren van de opdracht om Flask te installeren. Flask is een webframework voor Python waarmee je een web-frontend kunt maken die vrij triviaal Python-scripts op de server-backend uitvoert. Typ de volgende opdracht en druk vervolgens op "Enter".
sudo pip install flask
Er zal een hele reeks dingen gebeuren in het opdrachtregelvenster en aan het einde ervan wordt Flask op uw Raspberry geïnstalleerd Pi.

De volgende stap is het installeren van de software die we hebben geschreven om dit project vanuit GitHub te ondersteunen. Het commando om dat te doen is
git clone https://github.com/sparkfun/Flask_Tutorial
Nogmaals, je zult wat tekst over de commandoregel zien scrollen, en wanneer de prompt terugkeert, zal dat wees uw indicatie dat het installatieproces is voltooid. Zodra dat is voltooid, voert u deze opdracht in:
sudo python Flask_Tutorial/Python/app.py
Dat zal de app starten en beginnen met luisteren naar invoer via TCP/IP vanaf het Pioneer-bord. Je zou nu in staat moeten zijn om de LED die op de Raspberry Pi is aangesloten aan en uit te zetten door op de D7- en D9-knoppen op het IoT Shield te drukken. Netjes!

Dus wat is hier aan de hand? pt. 1:De Pioneer-kit

Laten we eens kijken naar wat er precies gebeurt, beginnend met een overzicht op hoog niveau van het PSoC 6-softwareproject. Kijk naar het Workspace Explorer-frame aan de linkerkant van het scherm. We zullen door dat kader lopen en de belangrijke bestanden benadrukken en hoe ze zich verhouden tot het totale project.

Heeft u moeite met het zien van de Workspace Explorer? Klik op de afbeelding om het van dichterbij te bekijken.

Het bovenste niveau van het project heeft zes items:het schema (“TopDesign.sch "), de Design Wide Resources ("XBee_WiFi_Example.cydwr "), de bronbestanden die zijn gekoppeld aan de Cortex-M0+ core ("CM0p (Core 0) "), de bronbestanden die zijn gekoppeld aan de Cortex-M4-kern ("CM4 (Core 1) "), bestanden die tussen de twee moeten worden gedeeld ("Gedeelde bestanden ”), en ondersteuning van bestanden die zijn gegenereerd door de IDE (“Generated_Source ”).

Het schema voor dit project is heel eenvoudig, met een paar LED's, een paar schakelaars en de UART die wordt gebruikt om gegevens van en naar de XBee WiFi-module over te dragen. De LED's zijn eigenlijk ongebruikt in de huidige uitvoering van het project.

We slaan de inhoud van de .cydwr . over het dossier. Dit bestand bevat de pintoewijzingen voor de signalen die in het schema worden gebruikt, de klokgeneratie en kernconfiguratieconstanten. Als je het meer wilt onderzoeken, voel je vrij om er een beetje in te graven. Veel ervan zou voor zichzelf moeten spreken.

Als we verder gaan in de lijst, bereiken we onze Cortex-M0+ bronbestanden. U zult zien dat het hoogste niveau in dit subdomein vijf items heeft:"Headerbestanden", "Bronbestanden" en drie andere bestanden. We hoeven ons alleen bezig te houden met de inhoud van de subdomeinen "Headerbestanden" en "Bronbestanden", en in feite slechts met één bestand daarin:de "main_cm0p.c " het dossier. Dit is waar de main() functie voor de code die op de Cortex-M0+-processor draait, leeft.

Zoals je misschien al geraden hebt uit de structuur van de werkruimte, zijn er twee volledig afzonderlijke codebases die draaien voor de twee verschillende kernen. "main_cm0p.c ” is het toegangspunt voor de code van de Cortex-M0+-kern, en dan begint die kern de Cortex-M4-kern. Er bestaat een soortgelijk subdomein voor de Cortex-M4-kern met vergelijkbare bestanden en nogmaals, we hoeven ons alleen maar zorgen te maken over de subdomeinen "Headerbestanden" en "Bronbestanden".

Ten slotte hebben we de sectie "Gedeelde bestanden". De meeste van deze bestanden worden automatisch gegenereerd, bewaar de "ipc_common.c ” en “ipc_common.h ” bestanden. Deze bestanden zijn hulpmiddelen voor communicatie tussen processen die voor dit project zijn ontwikkeld.

Het Cortex-M0+ hoofdbestand

Nu we de belangrijke inhoud hebben gemarkeerd, gaan we eens kijken naar de belangrijke stukjes van de code, één bestand tegelijk, te beginnen met de "main_cm0p.c " het dossier. Dit bestand handelt alle activiteiten af ​​die de Cortex-M0+ core voor het systeem doet:het bewaken van de twee drukknoppen en het sturen van een signaal naar de Cortex-M4 wanneer op een van beide wordt gedrukt.

Dit is echter niet zo eenvoudig als het lijkt, omdat de Cortex-M4 het signaal moet kunnen wissen zodra het ermee is omgegaan, en dat betekent dat meerdere processen toegang hebben tot dezelfde gegevens. Elke keer dat meerdere processen aan dezelfde dataset werken, moet u rekening houden met de effecten van een schrijfbotsing. Wat gebeurt er als het ene proces probeert de gegevens te wijzigen terwijl het andere proces dezelfde gegevens probeert te wijzigen? Om dit aan te pakken gebruiken we een systeem beveiligd lezen en schrijven, ingesteld in de "ipc_common ” bestanden.

Om te begrijpen hoe dit werkt, moet men eerst het concept van een IPC-kanaal begrijpen. IPC-kanalen gebruiken semaforen om gegevens van het ene proces naar het andere te schrijven, terwijl ze garanderen dat er geen botsing tussen de twee kernen zal zijn. Aan het begin van de uitvoering van de toepassing voor elke kern moet u eindpunten vaststellen voor de IPC-kanalen die tijdens de uitvoering moeten worden gebruikt. Overweeg deze twee regels code:
IPC_STRUCT_Type *D9IpcHandle;
D9IpcHandle =Cy_IPC_Drv_GetIpcBaseAddress(7);
De eerste maakt een aanwijzer voor een struct die de kenmerken van een IPC-kanaal definieert. De tweede stelt die struct eigenlijk in om naar een specifieke geheugenlocatie te verwijzen, die van systeem-IPC-kanaal 7. We gebruiken kanaal 7 omdat kanalen 0-6 zijn gereserveerd voor systeemgebruik.

Vervolgens moeten we natuurlijk de andere core vertellen welk geheugenadres bij dit IPC-kanaal hoort. Dat is wat deze functieaanroep doet.
while(Cy_IPC_Drv_SendMsgPtr(D9IpcHandle, CY_IPC_NO_NOTIFICATION, &D9Button) !=CY_IPC_DRV_SUCCESS);
D9Button is een variabele die eerder in de code is ingesteld. De functieaanroep is ingesloten in een while()-lus omdat we de functieaanroep willen herhalen totdat we verificatie hebben ontvangen dat het andere proces (d.w.z. de code die op de Cortex-M4-kern draait) deze informatie heeft ontvangen. We willen ook wachten tot de vergrendeling van de variabele is vrijgegeven, wat aangeeft dat de Cortex-M4 klaar is met het lezen van de aanwijzerwaarde.
while(Cy_IPC_Drv_IsLockAcquired(D9IpcHandle));
Ten slotte vallen we in onze oneindige loop voor de app, waarbij de aangepaste functies ReadSharedVar() en WriteSharedVar() zorgen voor het bijwerken van de gedeelde variabelen die de knopstatus communiceren met de andere kern. We zullen later op die functies ingaan.

Het Cortex-M4 hoofdbestand

In de Cortex-M4 main() functie herhalen we enkele van dezelfde bewerkingen als in de Cortex-M0+ main()-functie met betrekking tot het instellen van het IPC-kanaal.
IPC_STRUCT_Type *D9IpcHandle;
D9IpcHandle =Cy_IPC_Drv_GetIpcBaseAddress(7);
Zodra dat is voltooid, moeten we een code aanroepen om het bericht op te vangen dat is verzonden vanuit het Cortex-M0+-proces, dat het adres bevat van de gedeelde variabele waartoe toegang moet worden verkregen.
while (Cy_IPC_Drv_ReadMsgPtr(D9IpcHandle, (void *)&D9Button) !=CY_IPC_DRV_SUCCESS);
Wederom sluiten we deze aanroep in een while()-lus in, zodat deze voortdurend wordt aangeroepen totdat het bericht wordt verzonden vanuit de Cortex-M0+. Dan moeten we de vergrendeling op dat IPC-kanaal vrijgeven, zodat het Cortex-M0+-proces weet dat het kan blijven werken en het IPC-kanaal in de toekomst kan gebruiken. Het is niet nodig om dit in een while()-lus in te sluiten omdat het een open einde heeft:de oproep hoeft maar één keer te worden gedaan om de vergrendeling te ontgrendelen, in plaats van te controleren of de vergrendeling is ontgrendeld, wat moet worden herhaald totdat de slot is vrijgegeven.
Cy_IPC_Drv_LockRelease(D9IpcHandle, CY_IPC_NO_NOTIFICATION);
Zodra dit alles is voltooid, moeten we het XBee WiFi-schild instellen om toegang te krijgen tot ons lokale netwerk. We zullen hier niet al die code dupliceren, omdat het goed gedocumenteerd is in het voorbeeld.

In de oneindige lus die de applicatiecode uitvoert, roepen we opnieuw de aangepaste functies ReadSharedVar() en WriteSharedVar() aan om toegang te krijgen tot de variabelen met de knopstatus, die worden gedeeld met de Cortex-M0+ core. Laten we eens nader bekijken wat deze functies doen.

Lees meer info……

Het PSoC 6 Pioneer Board gebruiken met het Pioneer IoT Add-on Shield