Débuter avec les cartes Cypress PSoC et l'EDI PSoC Creator

Le kit Pioneer PSoC 4 CYC8CKIT-042 est une carte de développement grand public et à bas coût dotée du microcontrôleur PSoC 4200 de la famille PSoC 4. Elle comprend les connecteurs compatibles pour les shields Arduino et les modules Digilent Pmod, permettant de relier un nombre important de cartes d'extension.
La carte dispose également d'une glissière CapSense à touches sensitives et à détection capacitive (une technologie de détection capacitive dont Cypress est un leader mondial), d'une LED RVB et d'un bouton-poussoir utilisateur.

La carte peut être alimentée par le connecteur Mini USB type B, l'alimentation Vin du connecteur compatible Arduino ou par une alimentation externe. La tension d'entrée est régulée à 3,3 V. On peut choisir entre la tension 5 V provenant de l'USB et 3,3 V grâce au cavalier de sélection J9.

Caractéristiques principales PSoC 4200 :

• cÅ“ur de processeur ARM Cortex-M0 32 bits à 48 MHz ;
• mémoire programme Flash 32 Ko ;
• mémoire SRAM 4 Ko ;
• alimentation 1,71 à 5 V ;
• modes basse consommation : 1,3 µA en sommeil profond, 150 nA en hibernation et 20 nA à l'arrêt ;
• jusqu'à 36 GPIO programmables ;
• amplificateurs opérationnels x 2 ;
• comparateurs x 2 ;
• convertisseur analogique-numérique par approximations successives (ADC SAR) 12 bits, 1 Msps ;
• convertisseur numérique-analogique à sortie de courant (IDAC) x 2 ;
• gestion LCD ;
• touches sensitives à détection capacitive (CapSense) ;
• communication série : blocs pour communication série X 2 avec I2C, SPI, UART configurables ;
• TCPWM (Timer/counter pulse-width modulator) x 4 ;
• blocs logiques programmables x 4 (UDB pour Universal Digital Block) : un ensemble de circuits logiques programmables (Programmable Logic Device) et d'unités fonctionnelles électroniques (datapath) permettant d'étendre les fonctionnalités de certains périphériques ou d'en créer de nouvelles.

Documentation Cypress PSoC 4200

Avec l'EDI PSoC Creator, sous Windows uniquement, il est possible de :

1. Glisser-déposer des composants et les connecter entre eux dans la fenêtre de travail (design) pour concevoir son système câblé ;
2. Gérer les fichiers sources du projet ;
3. Configurer les composants dans des boîtes de dialogue ;
4. Accéder et explorer plus d'une centaine de composants proposés dans le catalogue. Le catalogue de composants comprend dans une seule interface des fonctions logicielles, des fonctions logiques et analogiques fixes issues des périphériques du processeur (fixed-function peripherals) et des fonctions logiques avancées prédéfinies et prêtes pour implantation dans les blocs UDB ;
5. Accéder à la documentation (datasheet) de chaque composant.

La puce PSoC 5LP de la carte sert de programmeur et de débogueur. La communication entre le kit et un PC s'effectue par défaut via le connecteur USB. Il est donc possible d'exécuter un programme dans l'EDI avec des points d'arrêt ou en mode pas à pas en utilisant le débogueur intégré.

La carte du kit PsoC 4 comprend une LED RVB montée en surface. Ce premier exercice vise à faire clignoter la LED en rouge.

Les trois LED ont une anode commune reliée à l'alimentation VDD du PsoC 4. Pour allumer une LED, il faut donc mettre son port relié à la cathode au niveau logique bas.

III-A. Première méthode : de façon logicielle▲

III-A-1. Configuration et génération du projet▲

On commence par configurer la broche P1[6] reliée à la cathode de la LED rouge.

Pour cela, après avoir créé le projet 'dvp-blink1', double-cliquer dans l'explorateur sur TopDesign.cysch pour entrer en mode design.

Depuis le catalogue des composants à droite, on fait glisser le composant Digital Output Pin dans la fenêtre graphique TopDesign. Un double-clic sur celui-ci ouvre une fenêtre permettant la configuration de la broche. À noter le bouton [Datasheet] qui ouvre un fichier PDF comprenant la documentation complète (en anglais) du composant et de son API.

Ensuite, on dirige le composant vers le port P1[6] de la puce de la carte, là où est connectée la cathode de la LED rouge :

La configuration est maintenant terminée, et si on revient dans la fenêtre TopDesign :

Lancer le Build du projet. Cette étape va déclencher toute une chaîne d'actions allant de la description de la conception graphique en langage HDL, la configuration, le routage des entrées-sorties, l'interconnexion des composants jusqu'à la génération des sources du projet.

III-A-2. Programmation▲

Le pilotage de la LED sera obtenu en complétant le fichier main.c généré :

Le programme complété devient :

 

Sélectionnez

int main()
{
    CyGlobalIntEnable; /* Enable global interrupts. */

    /* Place your initialization/startup code here (e.g. MyInst_Start()) */

    for(;;)
    {
        /* Place your application code here. */
        Pin_RedLed_Write(0);   // Allumer la led rouge
        CyDelay(500);           // Pause 500 ms
        Pin_RedLed_Write(1);   // Eteindre la led rouge
        CyDelay(500);           // Pause 500 ms
    }
}

Notez la fonction _Write de l'API du composant, générée au Build de l'application et préfixée avec le nom du composant. Le jeu de fonctions fourni par l'API du composant est largement documenté dans la datasheet :

Mise à part la configuration de la broche à la souris dans une boîte de dialogue et non par programmation, vous retrouvez sur le principe la façon de programmer de n'importe quel microcontrôleur classique (voir le Blink façon Arduino en langage C). On configure la broche reliée à la cathode et on écrit dessus. Somme toute, un blink banal (et sans saveur particulière) codé en langage C et qui monopolise tout le processeur.

III-A-3. Téléversement dans la cible▲

Il ne reste qu'à verser le programme dans la cible via le câble USB en cliquant sur le bouton Program  :

III-B. Deuxième méthode : en interconnectant des fonctionnalités de blocs logiques▲

Cette fois, le signal qui va basculer de niveau logique toutes les 500 ms va être produit par un générateur de signal modulé en largeur d'impulsion (ou PWM), un des nombreux composants logiques matériels disponibles dans la gamme des PSoC.

En mode design, il faut reconfigurer la broche et cocher la case HW Connection afin de permettre la connexion au générateur PWM :

On fait maintenant glisser les différents composants supplémentaires dont on a besoin depuis le catalogue : PWM, Clock et Logic Low '0' puis on les connecte avec l'outil ad hoc :

Le nouveau résultat dans la fenêtre TopDesign :

L'horloge locale est réglée à la fréquence de 10 kHz. Le composant peut être configuré pour sélectionner automatiquement la source de l'horloge et les diviseurs de fréquence pour approcher la fréquence voulue.

L'horloge locale étant dirigée vers l'entrée du bloc PWM, ce dernier est alors configuré avec une période d'une seconde et un rapport cyclique de 50 % :

Un petit assistant graphique dans l'onglet de configuration du composant se met à jour et redessine le chronogramme en fonction des valeurs saisies dans les champs. On y voit le décompte de 10 000 à 0 à chaque coup d'horloge sur chaque période de durée 1 s. La sortie PWM est à l'état haut tant que la valeur du compteur est supérieure à 5000.

Le schéma final en mode design :

Le fichier main.c est maintenant complété avec la seule instruction de démarrage du composant PWM :

 

Sélectionnez

#include <project.h>

int main()
{
    CyGlobalIntEnable; /* Enable global interrupts. */

    /* Place your initialization/startup code here (e.g. MyInst_Start()) */
    PWM_1_Start();
    
    for(;;)
    {
        /* Place your application code here. */
    }
}

/* [] END OF FILE */

En résumé, avec un microcontrôleur classique, les opérations suivantes doivent être réalisées :

1. Repérer les registres du générateur PWM ;
2. Calculer les valeurs à écrire dans les registres selon la fréquence et le rapport cyclique du signal souhaité ;
3. Écrire les lignes de code nécessaires pour configurer la broche de sortie et démarrer le générateur PWM, sachant que la plupart des microcontrôleurs n'offrent pas d'alternatives sur le choix de la broche de sortie.

Avec l'architecture PSoC et son environnement de développement PSoC Creator, la conception d'un circuit avec un générateur PWM est réalisée à la souris en quelques clics. Vous disposez vos composants dans la fenêtre design, vous les paramétrez, vous interconnectez les composants et routez les entrées-sorties vers les broches GPIO de votre choix.

On se propose de pousser le concept de développement sur l'architecture PSoC en complétant le programme Blink précédent. Cette fois, la LED RVB pourra clignoter en rouge, en vert ou en bleu. Le changement de couleur s'effectuera à chaque appui sur le bouton-poussoir monté en surface de la carte PSoC : clignotement en rouge d'abord, puis en vert sur appui du bouton, puis en bleu, et on revient au rouge, etc.

La partie du circuit correspondant au pilotage des LED sera la suivante :

On configure trois broches en sortie, et on les dirige vers les cathodes des trois LED rouge (P1[6]), verte (P0[2]) et bleue (P0[3]).

Le choix de la couleur sera piloté grâce à un registre de contrôle utilisateur 3 bits et des portes logiques NAND (la négation parce que pour allumer une LED, il faut mettre sa cathode au niveau logique bas). Pour faire clignoter en rouge, on écrira 0b001 dans le registre (valeur initiale définie dans la fenêtre de configuration du composant). Pour faire clignoter en vert, on écrira 0b010 dans le registre, puis 0b100 pour faire clignoter en bleu. Les schémas des résistances, LED et alimentation en bleu ne sont là que pour agrémenter vos conceptions, et n'auront aucune influence à la génération de l'application.

La seconde partie du circuit correspond au déclenchement d'une interruption sur appui du bouton-poussoir :

La broche est configurée en entrée avec une résistance de tirage (pull up) et dirigée vers la broche P0[7] où est relié le bouton-poussoir utilisateur.

Le composant Debouncer permet de filtrer les rebonds (assemblage de bascules) :

Le composant isr (Interruption Service Routine) relié à la sortie du système antirebond va permettre sur front montant du signal de déclencher l'interruption. C'est dans le code d'interruption que sera gérée la valeur du registre de contrôle pour piloter l'alternance rouge, vert et bleu de la LED.

Le circuit final :

Après le Build du design, vous aurez à compléter les fichiers générés main.c et isr_1.c.

Le fichier main.c est complété uniquement avec les instructions nécessaires au démarrage des composants :

/* ========================================
 *
 * Copyright YOUR COMPANY, THE YEAR
 * All Rights Reserved
 * UNPUBLISHED, LICENSED SOFTWARE.
 *
 * CONFIDENTIAL AND PROPRIETARY INFORMATION
 * WHICH IS THE PROPERTY OF your company.
 *
 * ========================================
*/
#include <project.h>

int main()
{
    CyGlobalIntEnable; /* Enable global interrupts. */

    /* Place your initialization/startup code here (e.g. MyInst_Start()) */

    PWM_1_Start();
    isr_1_Start();
    
    for(;;)
    {
        /* Place your application code here. */
    }
}

/* [] END OF FILE */

Il faut compléter le fichier isr_1.c aux emplacements prévus :

/*******************************************************************************
*  Place your includes, defines and code here 
********************************************************************************/
/* `#START isr_1_intc` */
#include <Control_Reg.h>
/* `#END` */

/*******************************************************************************
* Function Name: isr_1_Interrupt
********************************************************************************
*
* Summary:
*   The default Interrupt Service Routine for isr_1.
*
*   Add custom code between the START and END comments to keep the next version
*   of this file from over-writing your code.
*
*   Note You may use either the default ISR by using this API, or you may define
*   your own separate ISR through ISR_StartEx().
*
* Parameters:  
*   None
*
* Return:
*   None
*
*******************************************************************************/
CY_ISR(isr_1_Interrupt)
{
    /*  Place your Interrupt code here. */
    /* `#START isr_1_Interrupt` */

    uint8 reg = Control_Reg_Read();
    Control_Reg_Write(reg==4 ? 1 : reg<<1);

    /* `#END` */
}

Dans le code d'interruption, on organise la permutation circulaire des bits du registre de contrôle.

Et c'est tout au niveau du code… En mode design, vous avez câblé un circuit à partir des blocs logiques disponibles. Mais le processeur est encore interrompu sur appui du bouton pour accéder au registre du circuit.

Encore plus loin…

La permutation circulaire des bits peut également être organisée de façon matérielle, grâce à une structure appelée registre à décalage à sorties parallèles constituée de bascules D. À chaque front montant produit par un appui sur le bouton-poussoir, la valeur d'entrée de chaque bascule est recopiée sur sa sortie. La sortie de la dernière bascule est réinjectée à l'entrée de la première pour perpétuer le cycle :

Les deux registres utilisateurs ShifIn_reg et Clock_reg permettent d'initialiser le registre à décalage au démarrage du système. Dans ce cas, le programme principal main.c devient :

main.c

Sélectionnez

int main()
{
    // CyGlobalIntEnable; /* Enable global interrupts. */

    /* Place your initialization/startup code here (e.g. MyInst_Start()) */
    ShiftIn_Reg_Write(1); // 1 à l'entrée de la bascule
    Clock_Reg_Write(1);   // front montant de l'horloge
    Clock_Reg_Write(0);   // front descendant de l'horloge
    ShiftIn_Reg_Write(0); // 0 à l'entrée de la bascule 
    
    PWM_1_Start();
    
    for(;;)
    {
        /* Place your application code here. */
    }
}

Cette fois, toute la gestion du clignotement sur appui du bouton-poussoir est confiée à un sous-système matériel qui fonctionne indépendamment du CPU, comme si vous émuliez un deuxième microcontrôleur. Dans la boucle principale, le processeur est entièrement disponible pour d'autres traitements ou calculs plus poussés.

L'extrait du fichier avec l'extension .rpt ci-dessous est obtenu à la génération du projet et récapitule les ressources matérielles consommées :

 

Sélectionnez

------------------------------------------------------------
Technology mapping summary
------------------------------------------------------------

Resource Type                 : Used : Free :  Max :  % Used
============================================================
Digital clock dividers        :    2 :    2 :    4 :  50.00%
Pins                          :    6 :   30 :   36 :  16.67%
UDB Macrocells                :   12 :   20 :   32 :  37.50%
UDB Unique Pterms             :   12 :   52 :   64 :  18.75%
UDB Total Pterms              :   12 :      :      : 
UDB Datapath Cells            :    2 :    2 :    4 :  50.00%
UDB Status Cells              :    0 :    4 :    4 :   0.00%
UDB Control Cells             :    3 :    1 :    4 :  75.00%
            Control Registers :    3 
Interrupts                    :    0 :   32 :   32 :   0.00%
Comparator/Opamp Fixed Blocks :    0 :    2 :    2 :   0.00%
SAR Fixed Blocks              :    0 :    1 :    1 :   0.00%
CSD Fixed Blocks              :    0 :    1 :    1 :   0.00%
CapSense Blocks               :    0 :    1 :    1 :   0.00%
8-bit CapSense IDACs          :    0 :    1 :    1 :   0.00%
7-bit CapSense IDACs          :    0 :    1 :    1 :   0.00%
Temperature Sensors           :    0 :    1 :    1 :   0.00%
Low Power Comparators         :    0 :    2 :    2 :   0.00%
TCPWM Blocks                  :    0 :    4 :    4 :   0.00%
Serial Communication Blocks   :    0 :    2 :    2 :   0.00%
Segment LCD Blocks            :    0 :    1 :    1 :   0.00%

Avec un microcontrôleur classique, tous les périphériques et entrées-sorties (horloge, compteur, convertisseur analogique-numérique ou numérique-analogique, broches d'entrée-sortie, bus série I2C, UART, SPI…) sont reliés au CPU qui est le cœur du système. Sans le CPU pour paramétrer et échanger avec les périphériques par le biais des registres, le système à microcontrôleur ne fonctionne pas :

Comme vous avez pu le constater avec la démonstration du chapitre précédent, l'architecture des PSoC est différente. Ici, le CPU, les périphériques et les blocs de fonctionnalités logiques (Universal Digital Blocks) sont autant de ressources matérielles situées au même niveau :

Les fonctionnalités analogiques et numériques sont disposées dans une matrice entièrement configurable pour créer de nouvelles fonctionnalités selon les besoins de l'application.

Le système de routage vous permet de définir :

• les connexions entre les broches GPIO et les blocs de fonctions ;
• les connexions entre les différents blocs ;
• les chemins d'horloge.

Ainsi, vous pouvez décharger le processeur des tâches répétitives, coûteuses en temps CPU ou qui interrompent le processeur dans d'autres traitements en les déléguant à des sous-systèmes matériels de votre cru.

Si vous êtes féru d'Arduino, vous n'avez probablement jamais entendu parler des kits PSoC 4 qui ont pourtant été présentés comme des Arduino Killer à une époque. Et si on devait comparer les Arduino et les kits PSoC sur le plan des performances, il faudrait prendre en compte la variété des cartes proposées par chacun.

À voir :

• Arduino Products
• PSoC® 4 Development Kits

Après tout et pour 20 € seulement, l'Arduino M0 propose aussi un cœur de processeur ARM Cortex-M0+ 32 bits à 48 MHz, une heureuse évolution de la populaire Uno et son Atmel AVR 8 bits à 16 MHz.

Alors certes, la plateforme Arduino est open source et sa communauté d'utilisateurs et de développeurs dans les écoles, universités et hackerspaces du monde entier est infiniment plus grande, au point de lui apporter un forum qui lui est entièrement consacré sur Developpez. Mais si on veut dégager quelques avantages des kits PSoC 4 sur d'autres cartes à microcontrôleur tels les Arduino, on soulignera tout de même :

• la « configurabilité » et la flexibilité : pour la conception de circuits à signaux mixtes à partir de périphériques fixes ou de composants avancés (comme les UDB, Universal Digital Blocks). Les broches GPIO également configurables aussi bien en logique qu'en analogique (8 modes). C'est l'atout majeur des kits PSoC sur les cartes à microcontrôleurs classiques ;
• l'EDI PSoC Creator : uniquement sous Windows et on peut le regretter. Mais l'interface graphique de conception et configuration des circuits matériels est très intuitive. Si vous souhaitez par exemple activer un port de communication série UART, rien de plus simple à la souris. Les paramètres de la liaison sont accessibles dans une boîte de dialogue et vous pouvez diriger les broches de transmission TX et RX vers n'importe quelle broche GPIO. La vie du développeur est simplifiée maintenant qu'il peut se concentrer sur l'essentiel de son application et lire ou écrire sur le port série avec le jeu de fonctions fourni par l'API. C'est là aussi, un atout majeur des kits PSoC ;
• le support de l'analogique : en plus des blocs logiques, de nombreux blocs analogiques sont disponibles (ADC, DAC, amplificateurs opérationnels, comparateurs, multiplexeurs analogiques…) ;

• la faible consommation : avec quatre modes de réduction de la consommation système. Si on prend le mode « Stop », le CPU, les horloges et tous les périphériques sont arrêtés. Il n'y a pas de rétention de la configuration et de l'état des périphériques, mais l'état des GPIO est figé jusqu'au réveil par interruption externe. Dans ce mode, le courant consommé peut descendre jusqu'à 20 nA seulement.

Toutefois, si vous êtes débutant en programmation de microcontrôleurs et sans connaissance particulière de l'électronique numérique et analogique, l'apprentissage sera plus lent qu'avec une plateforme comme Arduino qui, à l'inverse des PSoC, tend à dissimuler le fonctionnement interne du microcontrôleur grâce à son fameux « langage Arduino » et ses nombreuses bibliothèques logicielles. C'est une tendance fâcheuse pour qui voudrait approfondir leur fonctionnement interne à des fins d'optimisation, mais aussi un grand avantage pour du prototypage pour le coup très rapide. Avec les kits PSoC, le compromis est trouvé avec des circuits configurables à la souris.

Comment réaliser un interrupteur à bascule pour allumer/éteindre une LED avec un bouton à appui momentané ? Avec le kit PSoC, un « Debouncer », une bascule T « toggle » et pas une ligne de code. À comparer avec l'exemple qui suit sous Arduino, avec toute la logique de détection de front et pause antirebond codée en langage C/C++ Arduino :

Switch Arduino

Sélectionnez

/* switch
 * 
 * Each time the input pin goes from LOW to HIGH (e.g. because of a push-button
 * press), the output pin is toggled from LOW to HIGH or HIGH to LOW.  There's
 * a minimum delay between toggles to debounce the circuit (i.e. to ignore
 * noise).  
 *
 * David A. Mellis
 * 21 November 2006
 */

int inPin = 2;         // the number of the input pin
int outPin = 13;       // the number of the output pin

int state = HIGH;      // the current state of the output pin
int reading;           // the current reading from the input pin
int previous = LOW;    // the previous reading from the input pin

// the follow variables are long's because the time, measured in miliseconds,
// will quickly become a bigger number than can be stored in an int.
long time = 0;         // the last time the output pin was toggled
long debounce = 200;   // the debounce time, increase if the output flickers

void setup()
{
  pinMode(inPin, INPUT);
  pinMode(outPin, OUTPUT);
}

void loop()
{
  reading = digitalRead(inPin);

  // if the input just went from LOW and HIGH and we've waited long enough
  // to ignore any noise on the circuit, toggle the output pin and remember
  // the time
  if (reading == HIGH && previous == LOW && millis() - time > debounce) {
    if (state == HIGH)
      state = LOW;
    else
      state = HIGH;

    time = millis();    
  }

  digitalWrite(outPin, state);

  previous = reading;
}

Avec l'architecture PSoC, vous disposez de circuits mixtes logiques/analogiques configurables avec un microcontrôleur embarqué. Vous pouvez configurer votre propre circuit en définissant quelles fonctionnalités logiques ou analogiques utiliser et comment les interconnecter. De plus, les circuits sont reconfigurables dynamiquement ce qui fait que vous pouvez également définir quand utiliser les fonctionnalités et mettre en œuvre sur le même circuit des configurations différentes à d'autres moments.

Si vous êtes habitué à développer sur des microcontrôleurs classiques comme AVR ou PIC (mais peut-être avez-vous déjà programmé un FPGA — Field-Programmable Gate Array — qui a beaucoup de points communs avec les PSoC), il faudra apprendre à implanter certaines fonctionnalités de votre application dans les circuits matériels afin de décharger le processeur.

L'interface graphique de conception de circuits de l'EDI PSoC Creator vous offre une grande simplicité d'utilisation et vous épargne les affres d'un langage de description de matériel (ou HDL pour Hardware Description Language). L'accès rapide aux nombreux blocs de fonctions logiques et analogiques avec leur documentation et les nombreux exemples disponibles devraient vous permettre de progresser. Bref, avec de la patience et un peu de persévérance, les kits PSoC ont tout à fait leur place dans les milieux éclairés et même dans les milieux éducatifs.

Je remercie Delias, Vincent PETIT et gaby277 pour leur aide et leurs commentaires avisés dans la préparation de cet article. Je remercie également genthial et ClaudeLELOUP pour leur relecture orthographique.

• Pioneer PSoC 4 CYC8CKIT-042 Kit
• PSoC 4: PSoC 4200 Family Datasheet Programmable System-on-Chip
• PSoC 4 Development Kits
• Getting started with PSoC 4
• PSoC Creator Integrated Design Environment (IDE)