LOCODUINO

Le Raspberry Pi Pico

Un remplacement pour l’Arduino Nano ?

.
Par : Jean-Luc

DIFFICULTÉ :

La fondation Raspberry Pi s’est rendue célèbre avec ses nano-ordinateurs monocarte puissants et bon marchés. Ces machines, dont le premier avatar, le Raspberry Pi 1A, a bientôt 10 ans, fonctionnent avec un système d’exploitation dérivé de la distribution Linux Debian : Raspbian. Mais plus récemment, la fondation a mis sur le marché une carte basée sur un micro-contrôleur ARM Cortex M0+.

Les illustrations de cet article proviennent en partie des documentations mises à disposition par la Fondation Raspberry Pi et diffusées sous licence Creative Commons Attribution-NoDerivatives 4.0
International (CC BY-ND). Elles sont donc Copyright © 2020 Raspberry Pi (Trading) Ltd. Les documentations originales sont :

Aucun changement n’a été effectué.

La Raspberry Pi Pico se démarque des productions habituelles de la fondation. En effet, cette petite carte s’inscrit dans la même catégorie que nos Arduino. Notamment, elle n’est pas conçue pour fonctionner avec Linux. En ce qui concerne le format, elle se rapproche d’un Arduino Nano. Elle possède une largeur légèrement supérieure (21mm au lieu de 18mm) et également une longueur un peu plus importante (51mm au lieu de 45mm). La figure 1 ci dessous montre la carte recto et verso.

Figure 1 : La Raspberry Pi Pico.
Figure 1 : La Raspberry Pi Pico.

En ce qui concerne le prix, on trouve la Pico en France, chez Kubii par exemple, pour à peine plus de 4€ alors qu’un clone chinois d’Arduino Nano est aujourd’hui à environ 7€, voire plus. On est donc dans le même format de carte que l’Arduino Nano, pour un prix plus faible qu’un clone et pour une qualité de fabrication meilleure !

On trouve également des contrefaçons de la Pico sur AliExpress pour 2 fois moins cher. Et je parle de contrefaçon et non de clone car quand on recopie le marquage © Raspberry Pi 2020 mais qu’on a pas eu le cran d’y mettre la framboise et qu’on annonce « Carte officielle Raspberry Pi Pico RP2040 », c’est clairement de la contrefaçon.

Le jeu n’en vaut pas la chandelle pour 2 raisons :

  • Étant donné le prix du Pico sur un site français (chez Kubii il est à 4€60 au moment où j’écris ces lignes) vous économiserez peu. La fondation Raspberry fait vraiment du bon boulot et n’entend visiblement pas se remplir les poches ;
  • Il faut rendre à césar ce qui est à césar. Le Pico, ce n’est pas juste un micro-contrôleur, c’est une quantité de logiciels qui ont été développés par la fondation et sur lesquels la paquet Arduino s’appuie. Ce ne sont pas les contrefacteurs chinois qui les ont faits.

La figure 2 montre la différence de taille entre l’Arduino Nano et la Raspberry Pi Pico. Notez également que la carte est livrée sans broches soudées, il faudra donc sortir le fer pour la placer sur une breadboard.

Figure 2 : Comparaison Arduino Nano et Raspberry Pi Pico
Figure 2 : Comparaison Arduino Nano et Raspberry Pi Pico

Les caractéristiques de la Raspberry Pi Pico

Le micro-contrôleur

Le micro-contrôleur embarqué sur la carte, le RP2040, est également une création de la fondation Raspberry Pi et est disponible séparément. Ce micro-contrôleur intègre 2 cœurs de calcul ARM Cortex M0+ fonctionnant à 133MHz [1] et possède 264ko de RAM ainsi que les périphériques suivants :

  • 2 interfaces série (UART) ;
  • 2 interfaces SPI ;
  • 2 interfaces I2C ;
  • 16 canaux PWM 16 bits ;
  • 1 contrôleur USB ;
  • 8 machines à état PIO (nous verrons plus loin de quoi il s’agit) ;
  • 4 canaux ADC 12 bits dont l’un est utilisé pour le capteur de température interne ;
  • 1 timer 64 bits auquel sont adjointes 4 alarmes 32 bits ;
  • 30 broches d’entrées sorties ;

Un DMA [2] est également disponible.

En revanche il ne contient pas de mémoire flash pour le stockage du programme, ni d’EEPROM, et une mémoire flash externe doit être adjointe pour stocker le programme. Le RP2040 accède à cette flash externe via une interface SPI quadruple dédiée.

Mon regret est l’absence de bus CAN. Il faudra, le cas échéant, ajouter un MCP2515.

Côté capacité électrique, on est en deçà des AVR (voir à ce propos Que peut-on alimenter avec un Arduino). En effet, la somme des courants fournis par les sorties ne doit pas dépasser 50mA et la somme des courants drainés ne doit, également, pas dépasser 50mA. Ceci est à comparer aux 200 mA de l’AVR 328P qui équipe l’Arduino Nano. De même, alors que pour l’Arduino Nano, nous avons 20 mA par broche autorisé, pour le Pico, 12 mA est un maximum. On constate d’ailleurs que le courant des amplificateurs de sortie est réglable : 2mA, 4mA, 8mA et 12mA sont possibles. En réglant à 12 mA et en fournissant 10mA, la tension de sortie s’établit à 3,1V. En drainant 10mA, la tension de sortie s’établit à 0,15V.

Par conséquent, pour piloter un grand nombre de LED, il faudra passer par une amplification, par exemple avec un ULN.
Ce micro-contrôleur étant disponible séparément, une multitude de cartes l’utilisant est apparue. Nous n’allons pas les lister et nous concentrer sur la carte proposée par la Fondation Raspberry Pi.

La Raspberry Pi Pico

La Raspberry Pi Pico comprend donc un micro-contrôler RP2040 équipé d’un quartz 12MHz, dont la fréquence est multipliée en interne, un régulateur de tension buck-boost [3] 3,3V, une flash externe de 2Mo, une LED et une prise micro-USB. La petite carte possède 2 rangées de 20 broches, sur lesquelles sont disponibles les alimentations et les entrées/sorties, plus 3 broches pour connecter un debugger (voir figure 3).

Figure 3 : Brochage de la Raspberry Pi Pico.
Figure 3 : Brochage de la Raspberry Pi Pico.

On constate que les positionnements des interfaces série, des SPI ou des I2C sont programmables. Ces 3 bus ont une allocation par défaut (GP0 et 1 pour l’UART, GP16 à 19 pour le SPI et GP4 et 5 pour l’I2C) mais peuvent être déplacés ailleurs au besoin. Sur les 30 broches du GPIO (General Purpose I/O), 4 ne sont pas disponible en sortie de la carte, ce qui laisse tout de même 26 broches à l’utilisateur.

On note la présence de 3 broches colorées en rouge : VBUS, VSYS et 3V3(OUT), et de 2 broches colorées en rose : 3V3_EN et RUN.

  • VBUS est la tension venant de l’ordinateur hôte via l’USB. Donc normalement 5V ;
  • VSYS est la tension d’entrée du régulateur, de 1,8V à 5,5V. VSYS reçoit VBUS via une diode Schottky. Pour alimenter en même temps le Pico via l’USB et une alimentation séparée, il faudra ajouter un peu d’électronique. C’est indiqué à la section 4.5, pages 19 à 21 de la documentation ;
  • 3V3(OUT) est, comme son nom l’indique, la sortie 3,3V du régulateur. Elle peut être utilisée pour alimenter de l’électronique extérieure dans les limites du raisonnable ;
  • 3V3_EN est une entrée du régulateur qui peut, en tirant ce signal à 0, être coupé ;
  • RUN est tout simplement le RESET. Il est tiré à l’état haut par une résistance interne du micro-contrôleur. Pour faire un reset du Pico, il suffit de mettre cette entrée à 0.

Le régulateur en lui même fournit jusqu’à 800 mA, c’est à dire presque autant que le régulateur linéaire qui équipe l’Arduino Nano. Toutefois, comme il ne s’agit pas d’un régulateur linéaire mais d’un régulateur à découpage, il a un bien meilleur rendement, environ 90%. Par conséquent il y a fort à parier, qu’en pratique, il soit capable de délivrer plus de courant sans chauffer que le régulateur linéaire d’un Arduino Nano.

Le support Arduino

Le portage du logiciel Arduino sur Raspberry Pi Pico nous est offert par un citoyen états-unien, Earle F. Philhower, III, que je remercie chaleureusement au passage, comme tout ceux qui contribuent à l’Arduino. Le développement est très actif puisque Earl publie une mise à jour tous les 10 jours environ. Le support est classique : on ouvre les préférences de l’IDE, on clique sur l’icône de fenêtre à droite du champ intitulé « URL de gestionnaire de cartes supplémentaires » et on ajoute dans la liste, l’URL suivante :

https://github.com/earlephilhower/arduino-pico/releases/download/global/package_rp2040_index.json

Après avoir validé, on déroule le menu « Outils », on va sur « Type de carte » puis on sélectionne le sous-item « Gestionnaire de carte ». Dans la case de recherche, on tape « pico ». 3 items s’affichent, le bon est celui intitulé « Raspberry Pi Pico/RP2040 », le nom de l’auteur susnommé est affiché juste en dessous.

Il est temps d’essayer de téléverser Blink.

Le processus défini par la Fondation Raspberry Pi pour téléverser un programme dans la mémoire flash de la Raspberry Pi Pico n’est pas celui qui prévaut avec l’IDE Arduino. Ici, lorsque l’on branche la Pico sur l’USB, aucun port série n’apparaît dans le menu de l’IDE. En revanche, la Pico s’identifie comme un disque USB. Le téléversement consiste donc à déposer le fichier exécutable dans un format ad-hoc sur ce disque et le Pico le copie ensuite dans la flash. Bien évidemment, c’est l’IDE qui va se charger de cette copie. Il reste que disposer d’un connexion série permet à l’IDE d’effectuer un reset.

Pour le premier téléversement, l’opération est particulière. Il faut brancher le Raspberry Pi Pico sur l’USB en maintenant le bouton poussoir blanc de la carte enfoncé puis relâcher le bouton. Aucun port n’apparaît encore mais le téléversement est possible comme en atteste la capture d’écran de la figure 4 et Blink fonctionne. Une fois qu’une sketch a été téléversé, l’infrastructure logicielle qui y est incluse fait apparaître un port série dans le menu de l’IDE. À partir de là, il ne sera plus nécessaire de maintenir le bouton enfoncé quand on connecte la Pico à l’USB et le comportement sera conforme à l’habitude.

Figure 4 : Téléversement de {Blink} sur la Pico
Figure 4 : Téléversement de {Blink} sur la Pico

Quelques essais

Servomoteur

Pour motoriser mes signaux mécaniques, j’ai acheté des servos ultra-micro chez Hobbyking. Il s’agit de ce modèle. Conçus pour les modèles réduits d’avions ultra-légers, ils possèdent des dimensions très réduites : 13 x 20 x 6mm et une masse de 1,9g seulement. Le moteur étant très petit, la tension d’alimentation doit être comprise entre 2,8V et 4,2V. C’est l’occasion de tester avec l’alimentation 3,3V du Pico. L’exemple utilisé est Sweep qui est disponible dans le menu « Exemples > Servo(rp2040) ». Il compile avec succès et fonctionne de manière satisfaisante comme en atteste la vidéo ci-dessous.

Raspberry PI Pico et servomoteur

Contrôleur CAN MCP2515 et bibliothèque ACAN

Cette bibliothèque et ce composant ont été présentés dans « La bibliothèque ACAN (1) ». Le branchement se fait, par exemple, sur les broches par défaut du SPI0. À noter que le Chip Select (CS) peut être géré automatiquement par le matériel au lieu de l’abaisser et de le remonter à coups de digitalWrite. Toutefois, si la bibliothèque SPI du Pico permet de choisir si le CS est géré automatiquement ou à la main, ce n’est pas pris en compte par ACAN2515 qui effectue une gestion manuelle. Le sketch d’essai est LoopBackDemo dans les exemples de ACAN2515. La broche du CS est changée en 17. L’interruption est laissée sur 3, sachant que chaque broche numérique peut servir d’entrée d’interruption externe sur le Pico. Ici aussi le test est un succès.

Figure 5 : Essai du Raspberry PI Pico avec le module CAN Locoduino
Figure 5 : Essai du Raspberry PI Pico avec le module CAN Locoduino

Deux caractéristiques originales

Le microcontrôleur RP2040 présente au moins deux caractéristiques originales que nous allons évoquer.

L’exécution parallèle

La première est de disposer de deux cœurs de calcul. Par défaut, le cœur 1 n’est pas démarré et le code tournera sur le cœur 0. Mais Earle a prévu de pouvoir utiliser les deux cœurs et donc d’exécuter deux programmes en parallèle. Pour cela, il suffit de définir deux fonctions, setup1 et loop1 qui s’exécuteront sur le cœur 1 tandis que setup et loop s’exécutent sur le cœur 0.

Il est également possible, a partir d’un cœur, de suspendre l’exécution de l’autre cœur en utilisant la fonction rp2040.idleOtherCore() et de la reprendre avec rp2040.resumeOtherCore(). Notez que suspendre trop longtemps le cœur 0 peut causer le gel de l’USB car c’est le cœur 0 qui sert les interruptions de l’USB.

Enfin, des fonctions permettent la communication entre les deux cœurs via une file d’attente bloquante : rp2040.fifo.push (bloque si la file est pleine), et rp2040.fifo.pop (bloque si la file est vide) ou non bloquante rp2040.fifo.push_nb (retourne false si la file est pleine, true si l’écriture est un succès), et rp2040.fifo.pop_nb (retourne false si la file est vide, true si la lecture est un succès. De plus, rp2040.fifo.available retourne le nombre d’éléments dans la file.

Pour l’instant, il n’y a pas de fonctions de gestion de sémaphores, par exemple, pour permettre la mise en œuvre de sections critiques. Pour plus d’informations, voir la documentation en ligne.

Les PIO (Programmable Input Output)

Le RP2040 dispose de 2 PIO comprenant chacun 4 machines à états programmables pour un total de 8. On peut voir ces machines à états comme des processeurs très simples qui interagissent avec les interruptions et les entrées/sortie. On peut donc écrire un programme pour chacun de ces processeurs.

C’est bien évidemment technique, ça nécessite de programmer dans un assembleur comprenant 9 instructions. Je ne vais pas entrer plus dans les détails mais ces PIO permettent d’écrire des programmes, certes rudimentaires (32 instructions, en tout, pour les 4 machines à état d’un PIO), mais qui s’exécutent en parallèles des cœurs Cortex M0+. Ceci permet de respecter des timings extrêmement fins pour, par exemple, mettre en œuvre des interfaces dont le micro-contrôleur ne dispose pas nativement, ou bien des détections de séquences de signaux sophistiquées.

Par exemple, la bibliothèque Servo sur la Pico utilisent les PIO (on peut donc connecter 8 servos). Par conséquent, la génération de l’impulsion de commande n’est jamais perturbées par les interruptions du micro-contrôleur.

Les performances

Pour évaluer les performances relatives à celles de l’Arduino Nano, j’ai utilisé, comme je l’avais fait pour les cartes Teensy, l’Arduino Speed Test Benchmarking Program. Je ne vais pas faire un compte rendu détaillé sous forme de graphique. Il faut retenir que les performances se situent, à 125MHz, entre la Teensy 3.2 overclockée à 72 MHz et la Teensy 3.6 à 180MHz, ce qui n’est pas inattendu. L’Arduino Nano est donc battu dans toutes les catégories avec des gains allant d’un facteur 3 à un facteur 173 !

En ce qui concerne la mémoire disponible, on a également un avantage certain puisque le Pico dispose de 132 fois plus de mémoire SRAM et de 64 fois plus de mémoire Flash pour le programme. À titre d’exemple j’ai compilé quelques programmes pour Arduino Nano et pour Raspberry Pi Pico afin de voir comment les empreintes mémoire augmentent avec la taille du sketch.

Empreinte mémoire en octets pour quelques sketchs
ProgrammeFlash Arduino NanoSRAM Arduino NanoFlash Raspberry Pi PicoSRAM Raspberry Pi Pico
Sketch vide 444 (1%) 9 ( 0%) 57808 (2%) 11120 (4%)
Blink 924 (3%) 9 ( 0%) 58488 (2%) 11148 (4%)
RightLeft 6014 (19%) 452 (22%) 64040 (3%) 11864 (4%)
Arduino_Speed_Tests 20710 (67%) 238 (11%) 71152 (3%) 11176 (4%)

Concernant la taille de flash nécessaire, on constate sur les exemples testés que le passage d’un sketch vide à Blink nécessite 480 octets sur le Nano et 680 octets sur le Pico. Pour RightLeft on a respectivement 5570 et 6232 et pour Arduino_Speed_tests 20266 et 13344 (les calculs sur des nombres flottants et des nombres 32 bits nécessitent plus d’instructions sur un AVR que sur un ARM). On voit que, hormis le ticket d’entrée du sketch vide, les occupations mémoire programme se valent et que les 2Mo de flash ne seront pas sacrifiées par des instructions machines plus gourmandes en taille. Concernant la taille de SRAM, Blink nécessite 0 octets supplémentaires pour le Nano et 28 pour le Pico, RightLeft nécessite 443 octets sur le Nano et 744 sur le Pico et Arduino_Speed_tests, 229 et 56 respectivement. Ici aussi on est dans les mêmes ordres de grandeur.

Conclusion

Difficile de trouver des défauts à cette carte étant donné son prix, inférieur à celui d’un clone de Nano, comparable à celui d’un clone de Pro Mini, alors que la qualité de la fabrication est supérieure. Ses performances sont, de plus, supérieures en tous points. Sur les tests effectués, le fonctionnement est très satisfaisant.

[1] Le micro-contrôleur peut être également overclocké jusqu’à 300MHz.

[2] Pour Direct Memory Access. Un DMA est un automate permettant de programmer des transferts de bloc mémoire sans intervention ultérieure du programme. Les transferts sont effectués en parallèle de l’exécution du programme et beaucoup plus rapidement.

[3] C’est à dire qui est à la fois capable d’abaisser et d’élever la tension d’entrée.

19 Messages

  • Le Raspberry Pi Pico 13 avril 2022 15:09, par Christian

    Cet article est intéressant car il existe de plus en plus de solutions appartenant à l’écosystème d’Arduino (tout ce qui est programmable avec l’IDE) mais de marques différentes.
    Raspberry nous avait habitué à des microsystèmes avec distribution allégée de Linux et le voici qui se lance aujourd’hui dans les nanosystèmes avec cette carte.
    Il peut paraître bizarre de comparer les performances d’une carte à base de µC 8 bits avec une autre équipée d’un µC 32 bits ; on peut s’attendre dès le départ au résultat.
    La carte est intéressante pour son prix, mais quitte à utiliser le µC RP2040, on peut aussi choisir une carte Nano RP2040 Connect, certes plus chère, mais qui est équipée de 16 MB de flash (pas 2 MB), et d’une puce WiFi BLE Nina W102 Ublox pour le WiFi et le BlueTooth. D’après les images du site Arduino, tout laisse à penser qu’elle est livrée avec les connecteurs déjà soudés, mais je préfère rester prudent sur ce point (voir photo de la carte à la sortie de la boite et comparer avec la carte Nano 33 IoT qui a des connecteurs non soudés).
    De plus, cette carte respecte le standard NANO donc une dimension et un brochage identique, ce qui peut être un atout pour upgrader un montage en remplaçant la carte Nano par cette dernière.
    Bien évidemment, pour un projet plus basique sans connectivité, la carte Raspberry est intéressante car son prix est très bas et la fabrication est de bonne qualité. Merci à Jean-Luc pour avoir indiqué comment faire pour la programmer. ;-)

    Répondre

    • Le Raspberry Pi Pico 17 avril 2022 20:41, par Jean-Luc

      Bonjour Christian,
       
      Effectivement, il existe d’autres cartes à base de RP2040, dont la Nano RP2040 Connect. Toutefois, le prix est de 5 à 7 fois plus élevé, le WiFi ou le Bluetooth n’est pas toujours nécessaire et le gyroscope/accéléromètre est inutile pour nos applications. Certes elle est compatible broche à broche mais comme elle en en 3,3V, il ne faut pas espérer la voir remplacer un Nano dans un design existant. Par ailleurs, les modules additionnels de cette carte (WiFi/Bluetooth et gyroscope/accéléromètre) monopolisent un SPI et un I2C si j’en crois la schématique. Je comprends bien la nécessité d’une flash de 16Mo pour loger la pile TCP/IP qui est un gros module logiciel et pour des fichiers si on veut mettre un serveur Web mais en dehors de ce domaine, 2 Mo suffisent largement.
       
      L’article se place du point de vue d’un déploiement en plusieurs exemplaire d’une carte de pilotages de dispositifs en remplacement d’un simple clone Arduino Nano. Le coût est donc important. Je compte utiliser des Raspberry Pi Pico pour piloter des servos 3,3V (signaux mécaniques / portes de remises) et des WS2811. Je n’ai pas besoin de WiFi/Bluetooth car les communications sont en CAN. Au total, j’ai 5 cartes, soit 20€ avec des Pico et 120€ avec des Nano RP2040 Connect. Le choix est vite fait.

      Répondre

      • Le Raspberry Pi Pico 18 avril 2022 11:58, par Christian

        Bonjour Jean-Luc,
        C’est exactement ce que j’ai dit : pour utiliser la carte Arduino Nano RP2040, il faut en avoir le besoin et la connectivité peut en faire partie.
        Pour le reste, à ce prix là, la carte Raspberry Pi Pico est imbattable.

        Répondre

    • Le Raspberry Pi Pico 18 avril 2022 08:41, par Jean-Luc

      Concernant les performances, on peut effectivement s’attendre à ce que le µC 32 bits soit plus véloce que le µC 8 bits mais ce n’est pas aussi simple :

      • Quel ordre de grandeur exactement ?
      • Les tests incluent des appels aux fonctions de l’API Arduino. Ces fonctions sont implémentées de manières différentes. Par exemple, PJRC (Teensy) utilise directement les registres des périphériques sans couche d’abstraction. ST (Nucleo) utilise la bibliothèque STM Cube (les fcts Arduino sont implémentées au dessus de STM Cube) et Earle (Pico) utilise la bibliothèque fournie par la Fondation Raspberry Pi. Le niveau d’optimisation de ces logiciels Arduino ne sont donc pas identiques.
      • Les calculs 8 bits sont moins couteux sur un µC 8 bits que sur un µC 32 bits car sur ces derniers le compilateur doit engendrer des instructions d’extension de signe supplémentaires.

      Répondre

      • Le Raspberry Pi Pico 18 avril 2022 12:08, par Christian

        Effectivement, ce n’est pas si simple : une carte 32 bits ne travaille pas quatre fois plus rapidement qu’une carte 8 bits. Ce que je voulais dire, c’est que je ne connais pas de domaine où une carte 32 bits serait plus lente qu’une 8 bits.
        Encore une fois, le choix doit se faire en fonction des besoins. Le µC AVR utilise un seul cycle d’horloge par instruction (sauf exception) alors qu’un µC ARM en utilise beaucoup plus. Pour une utilisation simple, le 32 bits ne sera pas beaucoup plus rapide qu’un 8 bits, malgré une horloge plus rapide. Mais dans d’autres cas, le gain sera phénoménal.
        Pour nos petits trains, une carte 8 bits est sans doute suffisante, mais les constructeurs arrêteront peut-être d’en produire un jour. C’est le progrès ! Raison de plus pour découvrir les cartes 32 bits dès maintenant.

        Répondre

        • Le Raspberry Pi Pico 18 avril 2022 17:26, par Jean-Luc

          Les Cortex M0/M0+/M3/M4 exécutent les instructions en 1 cycle ou 2 pour la plupart. Les instructions plus longues correspondent à des instructions qui n’existent pas en AVR (push et pop multiple, multiplication).

          Répondre

  • Le Raspberry Pi Pico 15 avril 2022 14:58, par Thomas

    Merci pour cet article. Je partais du principe que la RP2040 était encore un n-ième RPI à mon goût sans trop d’intérêt. Le petit encadré sur le PIO m’a fait sauter sur deux petites cartes pour réaliser quelques petits développements. Et en grattant un peu, on s’aperçoit qu’on peut le coupler au DMA du RP2040 ! C’est vraiment excellent !

    Répondre

  • Le Raspberry Pi Pico 19 août 2022 11:37, par Marcel

    Bonjour à tous

    Faire un comparatif entre micros 8bits (PIC ou AVR) et 32bits (ESP,STM ou Pico) n’est pas facile d’autant plus que les compilateurs ont une grande importance. Il suffit de regarder un programme faisant les mêmes fonctions. J’ai testé un simple clignotant entre Arduino et GCbasic (uniquement 8bits), la diffence d’occupation mémoire est très importante, aussi bien PIC que AVR.

    L’augentation de puissance des controleurs 32 bits, ainsi que la capacité mémoire et le vitesse d’horloge permettent d’utiliset les nouveaux microcontrolleurs avec un language interprété.
    MicroPython (et son dérivé CircuitPython) ainsi que MMBasic(Picomite) en sont des exemples. Ce qui permet de faire des tests rapidement. Je trouve que la compilation des micros 32 bits est très longue (ceci est valable pour ESP32, STM32F411 et aussi la carte PICO).
    Votre site est très interressant dans son approche différente de Arduino, par rapport aux sites généraliste, qui en fin de compte disent tous la même chose sans approfondir.
    Cordialemnt

    Répondre

  • Le Raspberry Pi Pico 5 décembre 2022 20:20, par trimarco232

    Bonjour à tous
    j’avais écrit en son temps que je ne voyais aucun avantage du pi pico par rapport à l’esp32, + puissant, + complet (CAN), bluetooth, et moins cher ...
    j’ai acquis un clone de pi pico (le purple), et fait quelques tests en vue de le réhabiliter :
    1) un des défauts (important à mon sens), de l’esp32, c’est la latence des interruptions, c’est à dire le temps qui s’écoule entre le moment où l’interruption est provoquée, et le moment où l’ISR (traitement de l’interruption) démarre : j’ai mesuré 4us, certains parlent de 7us : c’est à la fois très peu, mais aussi beaucoup trop long pour certaines applis, où le timing est serré et critique
    avec le pi pico, j’ai pu mesurer 160ns ; il a toutefois fallu que je n’utilise pas pour cette interruption les fonctions arduinos, mais celles du sdk ; il suffit d’écrire le code du sdk tel quel, dans le sketch arduino, et ça compile et s’execute
    on peut aussi placer l’ISR en RAM, pour augmenter sa vitesse, et également augmenter la priorité de l’ISR (parmi 4), pour qu’elle puisse interrompre les ISR moins prioritaires, et ne pas se faire interrompre par celles-ci
    je n’ai toutefois pas fait de test pour mesurer les avantages de ces 2 dernières possibilités
    .
    2) les périphériques programmables PIO sont très intéressants : si on n’a pas l’âme de se lancer dans le mini assembleur pour les programmer, on peut se contenter d’utiliser les fonctions ou librairies écrites par des bienfaiteurs
    j’ai réalisé le montage suivant : broche tx d’un des 2 uarts, reliée à 8 broches d’io quelconques ; j’ai affecté un PIO programmé en réception uart (ça existe tout fait dans le portage d’Earle) à chacune des 8 broches : ben ça marche , on a un réception simultanée de messages série sur 8 broches différentes, et ce, à 250kb/s ! on pourrait en avoir 10 en utilisant les 2 uart
    j’espère qu’on verra apparaitre d’autres fonctions, notamment dédiées à notre loisir
    .
    à noter l’apparition de la version wifi du pi pico, + cher que l’esp32, mais raisonnable, et qui a donc les 2 avantages que je viens de décrire brièvement

    Répondre

  • Le Raspberry Pi Pico 19 octobre 2023 22:55, par Simon

    Bonjour tardif...
    mais pour ajouter une information qui pourrait peut-être encore être utile, notamment à Jean-Luc vis qui regrettait l’absence de CAN

    Dédié au(x) pico, ceci : (lien) sur base de MCP2515, donc compatible ACAN j’imagine (je n’ai pas testé)

    Mon avis personnel sur ces PICO (W) : oui pour tout, dont le prix bien sûr, et l’impression de qualité... un véritable bijou.
    Surpris aussi, favorablement, par le portage sur Arduino, les librairies que j’ai testées passent comme une lettre à la poste.

    ... mais une énorme déception pour ce qui est de leur utilisation "real-life" (oui oui, j’évoque du non-locoduino !) : je n’ai pas trouvé comment implémenter un deep-sleep avec réveil par interruption externe (sauf peut-être par un RTC DS3231, mais alors pfff sous python et au prix d’une sacrée galère d’après ce que j’ai vu...)

    Voir en ligne : https://learn.adafruit.com/adafruit...

    Répondre

  • Le Raspberry Pi Pico 13 août 00:01, par bobyAndCo

    Je me suis battu pendant plus de 10 heures à essayer de faire fonctionner ce code avec un module Niren (8Mhz).

    Je suis absolument certain de mes câblages, j’ai changé mon module pour un neuf sorti de son emballage.

    La vitesse sur mon bus est bien de 250Kb/s

    Le package est :
    https://github.com/earlephilhower/a...

    Ca compile !

    Mais ça ne voit pas les messages sur le bus CAN

    //——————————————————————————————————————————————————————————————————————————————
//   ACAN2515 Demo in loopback mode
//——————————————————————————————————————————————————————————————————————————————

#include <ACAN2515.h>
#include <SPI.h>

//——————————————————————————————————————————————————————————————————————————————
//   MCP2515 connections:
//     - standard SPI pins for SCK, MOSI and MISO
//     - a digital output for CS
//     - interrupt input pin for INT
// ——————————————————————————————————————————————————————————————————————————————
//  If you use CAN-BUS shield (http://wiki.seeedstudio.com/CAN-BUS_Shield_V2.0/) with Arduino Uno,
//  use B connections for MISO, MOSI, SCK, #9 or #10 for CS (as you want),
//  #2 or #3 for INT (as you want).
// ——————————————————————————————————————————————————————————————————————————————
//  Error codes and possible causes:
//     In case you see "Configuration error 0x1", the Arduino doesn't communicate
//        with the 2515. You will get this error if there is no CAN shield or if
//        the CS pin is incorrect.
//     In case you see success up to "Sent: 17" and from then on "Send failure":
//        There is a problem with the interrupt. Check if correct pin is configured
// ——————————————————————————————————————————————————————————————————————————————

static const byte MCP2515_INT = 1 ; // INT output of MCP2515
static const byte MCP2515_SCK = 18 ; // SCK input of MCP2515
static const byte MCP2515_MOSI = 19 ; // SI input of MCP2515
static const byte MCP2515_MISO  = 16 ; // SO output of MCP2515
static const byte MCP2515_CS  = 17 ; // CS input of MCP2515

// ——————————————————————————————————————————————————————————————————————————————
//   MCP2515 Driver object
// ——————————————————————————————————————————————————————————————————————————————

ACAN2515 can(MCP2515_CS, SPI, MCP2515_INT);

// ——————————————————————————————————————————————————————————————————————————————
//   MCP2515 Quartz: adapt to your design
// ——————————————————————————————————————————————————————————————————————————————

static const uint32_t QUARTZ_FREQUENCY = 8UL * 1000UL * 1000UL; // 8 MHz

// ——————————————————————————————————————————————————————————————————————————————
//    SETUP
// ——————————————————————————————————————————————————————————————————————————————

void setup()
{
  //--- Switch on builtin led
  pinMode(LED_BUILTIN, OUTPUT);
  digitalWrite(LED_BUILTIN, HIGH);
  //--- Start serial
  Serial.begin(115200);
  //--- Wait for serial (blink led at 10 Hz during waiting)
  while (!Serial)
  {
    delay(50);
    digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN));
  }

  SPI.setSCK (MCP2515_SCK) ;
  SPI.setTX (MCP2515_MOSI) ;
  SPI.setRX (MCP2515_MISO) ;
  SPI.setCS (MCP2515_CS) ;
//--- Configure SPI
  SPI.begin () ;
//--- Configure ACAN2515
  Serial.println ("Configure ACAN2515") ;
  ACAN2515Settings settings (QUARTZ_FREQUENCY, 250UL * 1000UL) ; // CAN bit rate 250 kb/s
  //settings.mRequestedMode = ACAN2515Settings::LoopBackMode ; // Select loopback mode
  const uint32_t errorCode = can.begin (settings, [] { can.isr () ; }) ;
  if (errorCode == 0) {
    Serial.print ("Bit Rate prescaler: ") ;
    Serial.println (settings.mBitRatePrescaler) ;
    Serial.print ("Propagation Segment: ") ;
    Serial.println (settings.mPropagationSegment) ;
    Serial.print ("Phase segment 1: ") ;
    Serial.println (settings.mPhaseSegment1) ;
    Serial.print ("Phase segment 2: ") ;
    Serial.println (settings.mPhaseSegment2) ;
    Serial.print ("SJW:") ;
    Serial.println (settings.mSJW) ;
    Serial.print ("Triple Sampling: ") ;
    Serial.println (settings.mTripleSampling ? "yes" : "no") ;
    Serial.print ("Actual bit rate: ") ;
    Serial.print (settings.actualBitRate ()) ;
    Serial.println (" bit/s") ;
    Serial.print ("Exact bit rate ? ") ;
    Serial.println (settings.exactBitRate () ? "yes" : "no") ;
    Serial.print ("Sample point: ") ;
    Serial.print (settings.samplePointFromBitStart ()) ;
    Serial.println ("%") ;
  }else{
    Serial.print ("Configuration error 0x") ;
    Serial.println (errorCode, HEX) ;
  }
}

//----------------------------------------------------------------------------------------------------------------------

static uint32_t gBlinkLedDate = 0 ;
static uint32_t gReceivedFrameCount = 0 ;
static uint32_t gSentFrameCount = 0 ;

//——————————————————————————————————————————————————————————————————————————————

void loop () {
  CANMessage frame ;
  if (gBlinkLedDate < millis ()) {
    gBlinkLedDate += 1000 ;
    digitalWrite (LED_BUILTIN, !digitalRead (LED_BUILTIN)) ;
    const bool ok = can.tryToSend (frame) ;
    if (ok) {
      gSentFrameCount += 1 ;
      Serial.print ("Sent: ") ;
      Serial.println (gSentFrameCount) ;
    }else{
      Serial.println ("Send failure") ;
    }
  }
  if (can.available ()) {
    can.receive (frame) ;
    gReceivedFrameCount ++ ;
    Serial.print ("Received: ") ;
    Serial.println (gReceivedFrameCount) ;
  }
}

// ——————————————————————————————————————————————————————————————————————————————

    Répondre

  • Le Raspberry Pi Pico 13 août 08:50, par bobyAndCo

    Oui ça fonctionne en loopback

    Répondre

    • Le Raspberry Pi Pico 13 août 08:54, par Jean-Luc

      Donc le câblage entre le Pico et le 2515 est ok. Le problème se situe après le 2515.

      Répondre

  • Le Raspberry Pi Pico 13 août 08:58, par bobyAndCo

    J’ai deux autres cartes sur le même bus, le pico est au milieu. Les deux autres échangent tranquillement leurs messages. Elles ont toutes les deux un quartz de 16 Mhz. Le Niren n’auant qu’un quartz de 8Mhz j’ai essayé de doubler la vitesse par rapport aux autres (250 Kb/s pour les deux autres) 500 Kb/s pour le Pico. Rien ! je suis revenu à 250 Kb/s sur le Pico, rien

    Répondre

  • Le Raspberry Pi Pico 13 août 09:13, par bobyAndCo

    Bon, à priori, c’est le Pico qui a un coup dans l’aile, je viens d’en mettre un autre et cela échange maintenant !

    Répondre

  • Le Raspberry Pi Pico 13 août 09:20, par bobyAndCo

    Le quartz sur le Niren est de 8 Mhz

    static const uint32_t QUARTZ_FREQUENCY = 8UL * 1000UL * 1000UL ; // 8 MHz

    Mais je peux appliquer le même débit que programmé sur les autres cartes avec quartz à 16Mhz.

    ACAN2515Settings settings (QUARTZ_FREQUENCY, 250UL * 1000UL) ; // CAN bit rate 250 kb/s

    Je croyais qu’il fallait alors multiplier la vitesse. Mais bon ça fonctionne.

    Pour info, je suis sur plateformIO. Les paramètres sont les suivants : [env:pico]
    platform = https://github.com/maxgerhardt/plat...
    board = pico
    framework = arduino
    board_build.core = earlephilhower
    upload_protocol = picotool
    lib_deps =
    pierremolinaro/ACAN2515@^2.1.3

    Répondre

    • Le Raspberry Pi Pico 13 août 14:44, par Jean-Luc

      Il fallait bricoler parce que la bibliothèque MCP_CAN ne permet pas de spécifier la fréquence du quartz car elle est dédiée au CAN BUS shield qui a un quartz à 16MHz. Pour une autre fréquence de quartz, par exemple 8MHz, Il faut donc contourner le problème en spécifiant un débit de bus 2 fois plus élevé que celui désiré.
       
      ACAN2515 permet de spécifier la fréquence du quartz et calcule tous les paramètres à partir de cette fréquence et du débit demandé. Plus besoin de bricoler.

      Répondre

  • Le Raspberry Pi Pico 13 août 09:32, par bobyAndCo

    Voici mon code de test complet qui fonctionne :

    // ——————————————————————————————————————————————————————————————————————————————
//   ACAN2515 Demo
// ——————————————————————————————————————————————————————————————————————————————
#include <Arduino.h>
#include <ACAN2515.h>
//#include <SPI.h>


static const byte MCP2515_INT = 1 ; // INT output of MCP2515
static const byte MCP2515_SCK = 18 ; // SCK input of MCP2515
static const byte MCP2515_MOSI = 19 ; // SI input of MCP2515
static const byte MCP2515_MISO  = 16 ; // SO output of MCP2515
static const byte MCP2515_CS  = 17 ; // CS input of MCP2515

// ——————————————————————————————————————————————————————————————————————————————
//   MCP2515 Driver object
// ——————————————————————————————————————————————————————————————————————————————

ACAN2515 can(MCP2515_CS, SPI, MCP2515_INT);

// ——————————————————————————————————————————————————————————————————————————————
//   MCP2515 Quartz: adapt to your design
// ——————————————————————————————————————————————————————————————————————————————

static const uint32_t QUARTZ_FREQUENCY = 8UL * 1000UL * 1000UL; // 8 MHz

// ——————————————————————————————————————————————————————————————————————————————
//    SETUP
// ——————————————————————————————————————————————————————————————————————————————

void setup()
{
  //--- Switch on builtin led
  pinMode(LED_BUILTIN, OUTPUT);
  digitalWrite(LED_BUILTIN, HIGH);
  //--- Start serial
  Serial.begin(115200);
  //--- Wait for serial (blink led at 10 Hz during waiting)
  while (!Serial)
  {
    delay(50);
    digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN));
  }

  SPI.setSCK (MCP2515_SCK) ;
  SPI.setTX (MCP2515_MOSI) ;
  SPI.setRX (MCP2515_MISO) ;
  SPI.setCS (MCP2515_CS) ;
//--- Configure SPI
  SPI.begin () ;
  delay(1000);
//--- Configure ACAN2515
  Serial.println ("Configure ACAN2515") ;
  ACAN2515Settings settings (QUARTZ_FREQUENCY, 250UL * 1000UL) ; // CAN bit rate 250 kb/s
  //settings.mRequestedMode = ACAN2515Settings::LoopBackMode ; // Select loopback mode
  const uint32_t errorCode = can.begin (settings, [] { can.isr () ; }) ;
  if (errorCode == 0) {
    Serial.print ("Bit Rate prescaler: ") ;
    Serial.println (settings.mBitRatePrescaler) ;
    Serial.print ("Propagation Segment: ") ;
    Serial.println (settings.mPropagationSegment) ;
    Serial.print ("Phase segment 1: ") ;
    Serial.println (settings.mPhaseSegment1) ;
    Serial.print ("Phase segment 2: ") ;
    Serial.println (settings.mPhaseSegment2) ;
    Serial.print ("SJW:") ;
    Serial.println (settings.mSJW) ;
    Serial.print ("Triple Sampling: ") ;
    Serial.println (settings.mTripleSampling ? "yes" : "no") ;
    Serial.print ("Actual bit rate: ") ;
    Serial.print (settings.actualBitRate ()) ;
    Serial.println (" bit/s") ;
    Serial.print ("Exact bit rate ? ") ;
    Serial.println (settings.exactBitRate () ? "yes" : "no") ;
    Serial.print ("Sample point: ") ;
    Serial.print (settings.samplePointFromBitStart ()) ;
    Serial.println ("%") ;
  }else{
    Serial.print ("Configuration error 0x") ;
    Serial.println (errorCode, HEX) ;
  }
}

//----------------------------------------------------------------------------------------------------------------------

static uint32_t gBlinkLedDate = 0 ;
static uint32_t gReceivedFrameCount = 0 ;
static uint32_t gSentFrameCount = 0 ;

//——————————————————————————————————————————————————————————————————————————————

void loop () {
  CANMessage frame ;
  if (gBlinkLedDate < millis ()) {
    gBlinkLedDate += 1000 ;
    digitalWrite (LED_BUILTIN, !digitalRead (LED_BUILTIN)) ;
    const bool ok = can.tryToSend (frame) ;
    if (ok) {
      gSentFrameCount += 1 ;
      Serial.print ("Sent: ") ;
      Serial.println (gSentFrameCount) ;
    }else{
      Serial.println ("Send failure") ;
    }
  }
  if (can.available ()) {
    can.receive (frame) ;
    gReceivedFrameCount ++ ;
    Serial.print ("Received: ") ;
    Serial.println (gReceivedFrameCount) ;
  }
}

// ——————————————————————————————————————————————————————————————————————————————

    Répondre

Réagissez à « Le Raspberry Pi Pico »

Qui êtes-vous ?
Votre message

Pour créer des paragraphes, laissez simplement des lignes vides.

Lien hypertexte

(Si votre message se réfère à un article publié sur le Web, ou à une page fournissant plus d’informations, vous pouvez indiquer ci-après le titre de la page et son adresse.)

Rubrique « Matériel »

Les derniers articles

Les articles les plus lus