De PSoC 6 Pioneer Board met IoT Add-On Shield Beheersen: Een Ontwikkelaarsgids

Inleiding

De PSoC 6 is de nieuwste toevoeging aan Cypress’ krachtige PSoC-serie processoren. De PSoC 6 Pioneer IoT Add-On Shield is het ontwikkelplatform bij deze processorlijn, uitgerust met een onboard 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+ lage-energie processor en een Cortex-M4 hoge-energie processor, verbonden via gedeelde peripherieën en geheugenruimte.

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

Benodigde Materialen

De voorbeelden in deze tutorial zijn bedoeld voor gebruik met de PSoC 6 Pioneer Kit, verkrijgbaar direct via Cypress of Digi-Key.

Je hebt ook een Pioneer Add-on Shield nodig. Je hebt ook een XBee WiFi-module nodig. Er zijn een paar XBee WiFi-opties afhankelijk van je setup: Trace, RP-SMA-connector met externe 2,4 GHz antenne, of Wire. De makkelijkste is een XBee met draadantenne.

Je hebt ook de Raspberry Pi 3 Starter Kit nodig. Dit wordt je communicatiedoel vanaf de PSoC 6 Pioneer Board. Je kunt natuurlijk de Pi 3 los kopen met een breadboard, jumper-draden, weerstanden en LEDs, maar we vinden de starter kit een uitzonderlijk goedkope deal en het is de moeite waard.

Hardware-overzicht

Laten we de functies van de Pioneer Kit IoT Add-on Board in detail bekijken.

• MicroSD-kaartslot – De pinnen voor deze slot mappen op de SPI-periferie op de meeste Arduino-compatibele boards, inclusief de PSoC 6 BLE Pioneer Board.
• XBee-header – Deze header is gespatieerd om de standaard XBee-footprint te accepteren. Compatibel met alle officiële XBee-modules.
• Qwiic-connector – Deze connector voegt ondersteuning toe voor alle SparkFun Qwiic-modules. Het levert 3,3 V.
• MicroB USB-voedingsconnector – Datapinnen op deze connector zijn met niets verbonden. Het levert 5 V aan de 3,3 V-regulator voor de XBee-module, wat de 5 V van de Arduino-header overruilt en hoogvermogen XBee-modules (zoals cellulair, wifi, of Pro-modellen) correct laat functioneren.
• D7 en D9-knoppen – Twee gebruikersknoppen verbonden met pinnen D7 en D9 (P0.2 en P13.1 op de PSoC 6, of P1.0 en P0.4 op PSoC 4 BLE).
• 3,3 V-regulator – Schakelmodus 3,3 V-spanningsregulator goed voor maximaal 1,5 A, afhankelijk van de capaciteit van de upstream-voeding. Haalt stroom van 5 V-voorziening op Arduino-pinnen of MicroB-voedingsconnector. Voedt alleen de XBee-header.
• Level Shift Buffer – Zet 5 V-signalen om naar 3,3 V-signalen. Laat het bord toe in 3,3 V of 5 V-systemen te worden gebruikt.
• I2C Level Shift Schakeling – Converteert I2C-signalen van 3,3 V naar 5 V, indien nodig.
• Spanningsvoorziening Selectie Jumper – Selecteert het niveau waartoe de I2C-level-shift-circuitry vertaalt. Standaard ingesteld op 3,3 V. Zet op 5 V voor gebruik met 5 V-systemen. Zowel de PSoC 4 als PSoC 6 Pioneer BLE-boards zijn 3,3 V-systemen.
• XBee DIO5 LED – DIO5 heeft standaard enkele nuttige functies, vooral op de WiFi-module, waar het connectiviteit met het geconfigureerde WiFi-netwerk toont.

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

Dit voorbeeld demonstreert hoe je een signaal naar een Raspberry Pi stuurt via WiFi. Het laat zien hoe je toegang krijgt tot een XBee WiFi-module, interprocescommunicatie tussen de twee kernen van de PSoC 6, en hoe je commando's ontvangt en parseert met een Raspberry Pi.

Volgen van dit voorbeeld vereist enige setup, dus laten we nu doorlopen.

PSoC 6 Pioneer Kit Setup: Hardware

De Pioneer Kit-zijde is triviaal: steek de XBee WiFi-module in de Pioneer IoT Add-on Shield en steek de shield in de Arduino-header van de Pioneer Kit Board.

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

PSoC 6 Pioneer Kit Setup: Software

Let op: PSoC 6-ondersteuning is alleen beschikbaar in Creator 4.2 of later!

Het softwareproject voor de Pioneer Kit is beschikbaar op GitHub.

PSOC 6 PIONEER KIT SOFTWARE DOWNLOAD

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

Voordat je iets anders doet, moet je het bestand “main_cm4.c” openen en een paar wijzigingen aanbrengen. Je vindt een codesectie die er zo 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 duidelijk wat je moet doen: wijzig deze instellingen zodat ze overeenkomen met je netwerksetup. De encrypt_mode-waarde kan WPA, WEP, WPA2, of (hopelijk niet!) NO_SECURITY zijn. rpi_ip is een dotted quad (bijv. “10.8.253.193”) die je verkrijgt door “ifconfig” in te typen in een opdrachtvenster op je Raspberry Pi (zie hieronder voor instructies over het openen van een opdrachtvenster) en te kijken naar de “wlan0”-sectie.

Om het bord te programmeren, verbind het met je PC via de meegeleverde USB-A naar USB-C-kabel. Klik vervolgens op de knop “Program” in de werkbalk (zoals hieronder getoond) om het project automatisch te bouwen en te programmeren.

Je kunt een venster krijgen zoals hieronder waarin je wordt gevraagd een te programmeren doel te kiezen. Het maakt niet uit welke entry je kiest onder het “KitProg2”-lijstitem, beide zullen de flash correct programmeren.

Raspberry Pi Setup: Hardware

Eerst kijken we naar hoe de hardware is verbonden:

Zoals je ziet, hebben we een LED (met 330 ohm weerstand) aangesloten op pinnen 3 (GPIO 2) en 6 (ground) van de Raspberry Pi. Hiermee kunnen we GPIO2 toggelen en het resultaat op de LED zien.

Raspberry Pi Setup: 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) draait, en dat het verbonden is met een toetsenbord, muis, monitor en lokaal WiFi-netwerk. Als dit niet 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:

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

Dat opent een opdrachtregelvenster. Hiermee kun je de Raspberry Pi direct commando's laten uitvoeren.

We beginnen met het uitvoeren van het commando om Flask te installeren. Flask is een web-framework voor Python dat je in staat stelt een web-frontend te maken die Python-scripts op de server-backend draait. Typ het volgende commando en druk op “Enter”.
sudo pip install flask
Er zal een heel boel gebeuren in het opdrachtregelvenster en aan het einde zal Flask geïnstalleerd zijn op je Raspberry Pi.

De volgende stap is het installeren van de software die we voor dit project geschreven hebben vanaf GitHub. Het commando daarvoor is:
git clone https://github.com/sparkfun/Flask_Tutorial
Opnieuw zul je tekst zien scrollen over de opdrachtregel, en wanneer de prompt terugkeert, is dat je indicatie dat het installatieproces voltooid is. Eenmaal voltooid, voer dit commando in:
sudo python Flask_Tutorial/Python/app.py
Dat lanceert de app en begint te luisteren naar invoer via TCP/IP van de Pioneer-board. Je zou nu de LED die aan de Raspberry Pi is aangesloten aan en uit moeten kunnen zetten door de D7- en D9-knoppen op de IoT Shield in te druiken. Gaaf!

Wat gebeurt er hier? Deel 1: De Pioneer Kit

Laten we eens kijken wat er precies gebeurt, te beginnen met een hoog-niveau overzicht van het PSoC 6-softwareproject. Kijk naar de Workspace Explorer-frame aan de linkerkant van het scherm. We lopen door die frame heen, met highlighten van de belangrijke bestanden en hoe ze zich verhouden tot het Gesamtproject.

Moet je de Workspace Explorer moeilijk zien? Klik op de afbeelding voor een nader kijkje.

Het topniveau van het project heeft zes entries: het schema (“TopDesign.sch”), de Design Wide Resources (“XBee_WiFi_Example.cydwr”), de bronbestanden geassocieerd met de Cortex-M0+ kern (“CM0p (Core 0)”), de bronbestanden geassocieerd met de Cortex-M4 kern (“CM4 (Core 1)”), bestanden die gedeeld worden tussen de twee (“Shared Files”), en ondersteuningsbestanden gegenereerd door de IDE (“Generated_Source”).

Het schema voor dit project is erg simpel, met een paar LEDs, een paar schakelaars, en de UART die gebruikt wordt om data naar en van de XBee WiFi-module te sturen. De LEDs zijn in de huidige implementatie van het project niet gebruikt.

We gaan de inhoud van het .cydwr-bestand over. Dit bestand bevat de pin-toewijzingen voor de signalen die in het schema gebruikt worden, de klokgeneratie, en kernconfiguratieconstanten. Als je het dieper wilt onderzoeken, voel je vrij om erin te duiken. Veel ervan is zelfverklarend.

Verderop in de lijst bereiken we de Cortex-M0+ bronbestanden. Je zult merken dat het topniveau in dit subdomein vijf entries heeft: “Header Files”, “Source Files”, en drie andere bestanden. We hoeven ons alleen te richten op de inhoud van de “Header Files” en “Source Files” subdomeinen, en in feite op slechts één bestand in die: het “main_cm0p.c” bestand. Dit is waar de main()-functie voor de code die op de Cortex-M0+ processor draait, leeft.

Zoals je misschien geraden hebt uit de structuur van de workspace, zijn er twee volledig losse codebases die draaien voor de twee verschillende kernen. “main_cm0p.c” is het entrypoint voor de Cortex-M0+ kern’s code, en dan start die kern de Cortex-M4 kern. Er bestaat een vergelijkbaar subdomein voor de Cortex-M4 kern met vergelijkbare bestanden en weer, hoeven we ons alleen te richten op de “Header Files” en “Source Files” subdomeinen.

Ten slotte hebben we de “Shared Files” sectie. De meeste van deze bestanden zijn automatisch gegenereerd, behalve de “ipc_common.c” en “ipc_common.h” bestanden. Deze bestanden zijn helpers voor interprocescommunicatie ontwikkeld voor dit project.

Het Cortex-M0+ Hoofdbestand

Nu we de belangrijke inhoud hebben gehighlight, laten we eens kijken naar de belangrijke stukjes code, één bestand per keer, te beginnen met het “main_cm0p.c” bestand. Dit bestand beheert alle activiteiten die de Cortex-M0+ kern voor het systeem doet: de twee drukknoppen monitoreren en een signaal naar de Cortex-M4 sturen wanneer een van de twee wordt ingedrukt.

Echter, dit is niet zo eenvoudig als het lijkt, omdat de Cortex-M4 in staat moet zijn om het signaal te wissen zodra het ermee klaar is, en dat betekent dat meerdere processen toegang hebben tot dezelfde data. Elke keer dat je meerdere processen hebt die op dezelfde dataset werken, moet je rekening houden met de effecten van een write-collision. Wat er gebeurt als één proces probeert de data te veranderen terwijl het andere proces probeert dezelfde data te veranderen? Om hiermee om te gaan gebruiken we een systeem met beschermde reads en writes, opgezet in de “ipc_common” bestanden.

Om te begrijpen hoe dit werkt, moet men eerst het concept van een IPC-kanaal begrijpen. IPC-kanalen gebruiken semaphores om data van het ene proces naar het andere te schrijven terwijl gegarandeerd wordt dat er geen collision tussen de twee kernen is. Aan het begin van de applicatie-uitvoering voor elke kern moet je endpoints vestigen voor de IPC-kanalen die tijdens de uitvoering gebruikt zullen worden. Overweeg deze twee regels code:
IPC_STRUCT_Type *D9IpcHandle;
D9IpcHandle = Cy_IPC_Drv_GetIpcBaseAddress(7);
De eerste creëert een pointer voor een struct die de kenmerken van een IPC-kanaal definieert. De tweede zet die struct daadwerkelijk op een specifiek geheugenadres, dat van systeem IPC-kanaal 7. We gebruiken kanaal 7 omdat kanalen 0-6 gereserveerd zijn voor systeemgebruik.

Vervolgens moeten we de andere kern vertellen welk geheugenadres geassocieerd is met dit IPC-kanaal. Dat doet deze functie-aanroep.
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 opgezet. De functie-aanroep is ingesloten in een while()-lus omdat we de functie-aanroep willen herhalen tot we verificatie 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 lock op de variabele is vrijgegeven, wat aangeeft dat de Cortex-M4 klaar is met het lezen van de pointer-waarde.
while(Cy_IPC_Drv_IsLockAcquired(D9IpcHandle));
Ten slotte dalen we in onze oneindige lus voor de applicatie, waar de aangepaste functies ReadSharedVar() en WriteSharedVar() het bijwerken van de gedeelde variabelen afhandelen die de knopstatus met de andere kern communiceren. We zullen die functies later dieper ingaan.

Het Cortex-M4 Hoofdbestand

In de Cortex-M4 main()-functie herhalen we enkele van dezelfde operaties als we in de Cortex-M0+ main()-functie deden met betrekking tot het opzetten van het IPC-kanaal.
IPC_STRUCT_Type *D9IpcHandle;
D9IpcHandle = Cy_IPC_Drv_GetIpcBaseAddress(7);
Eenmaal dat voltooid is, moeten we dan enige code aanroepen om het bericht dat verstuurd werd vanuit het Cortex-M0+ proces te “vangen”, wat het adres van de gedeelde variabele bevat die moet worden benaderd.
while (Cy_IPC_Drv_ReadMsgPtr(D9IpcHandle, (void *)&D9Button) != CY_IPC_DRV_SUCCESS);
Opnieuw sluiten we deze aanroep in een while()-lus in, zodat het continu wordt aangeroepen tot het bericht wordt verstuurd vanuit de Cortex-M0+. Dan moeten we de lock op dat IPC-kanaal vrijgeven zodat het Cortex-M0+ proces weet dat het kan doorgaan met opereren en het IPC-kanaal in de toekomst kan gebruiken. Er is geen behoefte om dit in een while()-lus te sluiten omdat het open-eindig is: de aanroep hoeft maar één keer uitgegeven te worden om de lock vrij te geven, versus controleren of de lock is vrijgegeven, wat herhaald moet worden totdat de lock vrijgegeven is.
Cy_IPC_Drv_LockRelease(D9IpcHandle, CY_IPC_NO_NOTIFICATION);
Eenmaal dit allemaal voltooid is, moeten we de XBee WiFi-shield instellen om toegang te krijgen tot ons lokale netwerk. We zullen niet al die code hier dupliceren, aangezien het goed gedocumenteerd is in het voorbeeld.

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

Lees Meer Info……

Using the PSoC 6 Pioneer Board with the Pioneer IoT Add-on Shield