Depuis la sortie du Raspberry Pi PICO et la disponibilité du microcontrôleur RP2040, de nombreux fabricants ont utilisé cet circuit pour concevoir des cartes. Je vous ai présenté en août la carte XIAO RP2040 de Seeedstudio. Aujourd’hui c’est le tour de la carte RP2040-Zero de Waveshare. Je vous propose de commencer à la prendre en main au travers de quelques programmes simples en microPython. Pour les tests j’utiliserai un Thonny sous Windows 11 qu’une majorité de débutants utilisent. J’utilise le même programme avec un Pi 4 ou un Pi 400, référez vous à mes précédents articles pour plus d’informations.

Carte miniature Waveshare RP2040-Zero

Présentation

La carte Waveshare RP2040-Zero est une carte miniature, plus petite qu’une carte SD…

Elle embarque le puissant processeur double-cœur RP2040 qui peut fonctionner avec une horloge jusqu’à 133 MHz, et qui est un microcontrôleur à faible consommation. La RP2040-Zero dispose également de 264 Ko de SRAM et de 2 Mo de mémoire Flash embarquée, ce qui permet de sauvegarder et d’exécuter davantage de programmes.

Contrairement à la XIAO RP2040, la Waveshare RP2040-Zero ne possède pas de LED Power, ni de LED utilisateur. Ça gagne un peu de place et ça économise un peu de courant (?).

Composants de la carte RP2040-Zero

La carte RP2040-Zero supporte la programmation Arduino, MicroPython et CircuitPython. Tout ce qui est valable pour le Raspberry Pi PICO est applicable ici.

Cet article se base sur l’utilisation de microPython.

Connecteur USB Type-C
W25Q16JVUXIQ
2MB NOR-Flash
Bouton BOOT
appuyez sur ce bouton lors de la réinitialisation pour entrer en mode téléchargement
Bouton RESET
WS2812
LED RGB

ME621
Low dropout LDO, courant max 800MA
RP2040
Processeur double cœur, fréquence de fonctionnement jusqu’à 133MHz
Broches du RP2040
10 points de soudure, dont 9 pour GPIO

Dimensions de la carte RP2040-Zero

Cette petite carte présente de bonnes performances en matière de traitement et consomme peu d’énergie. Elle a une taille minuscule (23.5x18mm) et peut être utilisée pour des dispositifs portables et des petits projets.

GPIO accessibles sur la carte RP2040-Zero

La carte RP2040-Zero possède 20 broches GPIO qu’on peut configurer, mais aussi sous la carte 9 pastilles à souder donnant accès aux GPIO 17 à 25. Ce sont donc 29 broches GPIO au total qui sont accessibles.

La carte RP2040-Zero supporte la programmation Arduino, MicroPython et CircuitPython. Tout ce qui est valable pour le Raspberry Pi PICO est applicable ici.

Cet article se base sur l’utilisation de microPython.

Caractéristiques

Microcontrôleur RP2040 conçue par la Fondation Raspberry Pi au Royaume-Uni
Processeur Arm Cortex M0+ à double cœur, horloge flexible pouvant atteindre 133 MHz
264 Ko de SRAM et 2 Mo de mémoire Flash intégrée.
Connecteur USB-C, pou les mises à jour, facile à utiliser
Le module est conçu pour accepter des broches à souder ou pour être soudé directement sur une carte de circuit imprimé (PCB)
USB 1.1 avec prise en charge des périphériques et des hôtes
Modes veille et sommeil à faible consommation
Programmation par glisser-déposer à l’aide d’une mémoire de masse via USB
29 broches GPIO multifonctions (20× via les broches, 9 via les pastilles à souder) : 2 × SPI, 2 × I2C, 2 × UART, 4 × ADC 12 bits, 16 × canaux PWM contrôlables
Horloge et minuterie précises embarquées
Capteur de température
Librairies de virgule flottante accélérée sur la puce
8 × machines d’état à E/S programmables (PIO) pour le support de périphériques personnalisés

Mise à jour au démarrage

Lorsque vous connectez la carte RP2040-Zero à une prise USB, elle embarque un programme de test qui fait défiler les couleurs de la LED RGB. Cela vous permet de vérifier rapidement que la carte est opérationnelle.

Lors de la première connexion avec le PC ou le Raspbery Pi, si Thonny est lancé et que le Compilateur sélectionné est celui du Raspbery Pi PICO, vous aurez peut-être cette fenêtre :

On vous propose de mettre à jour la version de microPython présente sur la carte RP2040-Zero. Vous pouvez accepter sans problème. Après la mise à jour, la carte redémarre mais la LED RGB ne s’allume plus car le programme de test a été supprimé lors de la mise à jour de microPython.

Entrer dans le mode Bootloader

Parfois, la connexion à la carte RP2040-Zero peut disparaître lorsque la programmation par l’utilisateur échoue ou qu’un programme ne rend pas la main. On peut résoudre ce problème par l’opération suivante :

Appuyez sur le bouton « BOOT », maintenez le appuyé et connectez la carte RP2040-Zero à votre ordinateur.
L’ordinateur fera apparaître un disque USB.

À ce stade, la puce entre en mode Bootloader et le port d’accès apparaît à nouveau. Le RP2040 possède deux partitions, l’une est le Bootloader et l’autre le programme utilisateur. Le produit contient un code de bootloader dans la mémoire du système lorsqu’il quitte l’usine. Il est possible de le modifier en procédant comme ci-dessus.

Vous verrez apparaître cette fenêtre RPI-RP2. Il suffira de faire un glisser déposer d’un bootloader en .UFO pour recharger microPython ou un autre système. Certains fabricants proposent leur propre mouture de microPython avec les librairies nécessaires pour gérer certains composants déjà intégrées.

Il m’arrive aussi, quand je mets des programmes en démarrage automatique sur le RP2040, de prévoir une « porte de sortie » pour arrêter le programme et reprendre la main avec Thonny. J’utilise parfois l’appui sur un ou 2 boutons poussoir, ou une autre méthode. Le programme lorsqu’il détecte cet événement s’arrête et rend la main.

Reset – Réinitialisation

Si vous voulez réinitialiser la carte RP2040-Zero, effectuez les étapes suivantes :

Connectez la carte RP2040-Zero à votre ordinateur.
Appuyez une fois sur le bouton « RESET ».

Le programme redémarre.

Schéma de la carte

Cliquez pour agrandir

Ce schéma vos permet de repérer les éléments présents sur la carte et de voir comment les différents composants sont connectés.

Mise en œuvre de microPython

Introduction à MicroPython

MicroPython est un interpréteur Python doté d’une fonction de compilation partielle de code natif. Il fournit un sous-ensemble de fonctionnalités de Python 3.5, implémenté pour les processeurs embarqués et les systèmes contraints. Il est différent de CPython et vous pouvez lire plus sur les différences ici.

Mise en route

A son arrivée, lorsque je connecte la carte RP2040-Zero au PC via USB, un programme interne anime la LED RGB. Ce programme a été installé par Waveshare, sans doute pour tester le bon fonctionnement de la carte en production.

Ce programme tourne en boucle et ne rend pas la main. On va devoir mettre un nouveau microPython dans la carte avant de l’utiliser. Cela va la réinitialiser. En cas de carte récalcitrante, il existe une autre solution qui remet l’ensemble de la mémoire à zéro. C’est flash_nuke.uf2 qui est disponible ici. Il suffit de le télécharger et de le copier en suivant la procédure ci-dessous pour remettre le microcontrôleur RP2040 dans l’état où il était à à sa sortie d’usine.

Installer microPython

Si la mise à jour vous a été proposée au premier démarrage et que vous avez accepté, cette procédure d’installation est déjà faite. Passez à la suite.

De plus cette procédure vous sera utile si vous décidez de changer de Bootloader par la suite.

Téléchargez microPython pour RP2040 en version .UF2. J’ai choisi la dernière version.

Comme vu plus haut, appuyez sur le bouton « B » et connectez le port USB-C. Cette fois la carte démarre en mode BOOTLOADER. La LED RGB reste éteinte. Une fenêtre RPI-RP2 s’ouvre sur le bureau.

Faites glisser le microPython…uf2 que vous avez téléchargé dans la fenêtre RPI-RP2. A la fin du transfert la fenêtre RPI-RP2 disparait et la carte reboote. Débranchez et rebranchez le port USB-C. La carte RP2040-Zero démarre « normalement » et le programme d’origine n’est plus exécuté. On va pouvoir commencer à s’amuser 😉

Le matériel utilisé

Tout d’abord, il faut connecter la carte RP2040-Zero à l’ordinateur et télécharger un code simple depuis MicroPython pour vérifier si la carte fonctionne bien.

Configuration matérielle utilisée :

1 x RP2040-Zero
1 x Câble Type USB-A -USB-C
1 x PC ou Raspberry Pi

Installation de THonny

Étape 1. Téléchargez et installez la dernière version de l’éditeur Thonny en fonction de votre système d’exploitation. Sur Raspberry Pi, THonny est déjà installé si vous utilisez Raspberry Pi OS. Pour Windows la page de téléchargement de Thonny est ici pour la version 3.3 et là pour la version 4.0 (beta). Comme je fais ça pour le fun, j’ai choisi la version 4.0.

Si le programme d’origine tourne sur la carte RP2040-Zero, vous aurez cette réponse dans la console car Thonny ne peut pas accéder tant que le programme de démo tourne en boucle. Si vous avez installé la dernière version de microPython, la console sera active et affichera la version de microPython.

Étape 2. Lancez l’éditeur Thonny et Cliquez sur » Outils→Options » pour ouvrir les paramètres.

Étape 3. Choisissez l’onglet « Interpréteur » et sélectionnez « MicroPython (Raspberry Pi Pico) » et pour le port comme « Essayer de détecter le port automatiquement« .

Connexion de la carte RP2040-Zero

Connectez la carte RP2040-Zero au port USB du PC ou du Raspberry Pi. Lancez Thonny.

La partie basse (Console) montre le résultat du démarrage de microPython sur le RP2040. C’est bien la version que j’ai transférée dans la carte qui est exécutée. Dans le futur si une autre version existe, vous obtiendrez un résultat différent.

Pour tester la carte on va transférer un programme dans Thonny. Copiez et collez ce programme dans la fenêtre de Thonny (d’après https://core-electronics.com.au/guides/how-to-use-ws2812b-rgb-leds-with-raspberry-pi-pico/) :

# Exemple de programme test_LED.py pour la LED RGB.
# Le programme d'origine est adapté pour une seule LED
# et un défilé continu de couleurs

import array, time
from machine import Pin
import rp2

# Configure the number of WS2812 LEDs.
NUM_LEDS = 1
PIN_NUM = 16
brightness = 0.2

@rp2.asm_pio(sideset_init=rp2.PIO.OUT_LOW, out_shiftdir=rp2.PIO.SHIFT_LEFT, autopull=True, pull_thresh=24)
def ws2812():
    T1 = 2
    T2 = 5
    T3 = 3
    wrap_target()
    label("bitloop")
    out(x, 1)               .side(0)    [T3 - 1]
    jmp(not_x, "do_zero")   .side(1)    [T1 - 1]
    jmp("bitloop")          .side(1)    [T2 - 1]
    label("do_zero")
    nop()                   .side(0)    [T2 - 1]
    wrap()


# Create the StateMachine with the ws2812 program, outputting on pin
sm = rp2.StateMachine(0, ws2812, freq=8_000_000, sideset_base=Pin(PIN_NUM))

# Start the StateMachine, it will wait for data on its FIFO.
sm.active(1)

# Display a pattern on the LEDs via an array of LED RGB values.
ar = array.array("I", [0 for _ in range(NUM_LEDS)])

##########################################################################
def pixels_show():
    dimmer_ar = array.array("I", [0 for _ in range(NUM_LEDS)])
    for i,c in enumerate(ar):
        r = int(((c >> 8) & 0xFF) * brightness)
        g = int(((c >> 16) & 0xFF) * brightness)
        b = int((c & 0xFF) * brightness)
        dimmer_ar[i] = (g<<16) + (r<<8) + b
    sm.put(dimmer_ar, 8)
    time.sleep_ms(10)

def pixels_set(i, color):
    ar[i] = (color[1]<<16) + (color[0]<<8) + color[2]

def pixels_fill(color):
    for i in range(len(ar)):
        pixels_set(i, color)

def color_chase(color, wait):
    for i in range(NUM_LEDS):
        pixels_set(i, color)
        time.sleep(wait)
        pixels_show()
    time.sleep(0.2)
 
def wheel(pos):
    # Input a value 0 to 255 to get a color value.
    # The colours are a transition r - g - b - back to r.
    if pos < 0 or pos > 255:
        return (0, 0, 0)
    if pos < 85:
        return (255 - pos * 3, pos * 3, 0)
    if pos < 170:
        pos -= 85
        return (0, 255 - pos * 3, pos * 3)
    pos -= 170
    return (pos * 3, 0, 255 - pos * 3)
 
 
def rainbow_cycle(wait):
    for j in range(255):
        for i in range(NUM_LEDS):
            rc_index = (i * 256 // NUM_LEDS) + j
            pixels_set(i, wheel(rc_index & 255))
        pixels_show()
        time.sleep(wait)

BLACK = (0, 0, 0)
RED = (255, 0, 0)
YELLOW = (255, 150, 0)
GREEN = (0, 255, 0)
CYAN = (0, 255, 255)
BLUE = (0, 0, 255)
PURPLE = (180, 0, 255)
WHITE = (255, 255, 255)
COLORS = (BLACK, RED, YELLOW, GREEN, CYAN, BLUE, PURPLE, WHITE)

while (1):
    print("fills")
    for color in COLORS:       
        pixels_fill(color)
        pixels_show()
        time.sleep(0.2)

    print("chases")
    for color in COLORS:       
        color_chase(color, 0.01)

    print("rainbow")
    rainbow_cycle(0)
    time.sleep(0.5)

    print("éteindre")
    color=BLACK
    pixels_fill(color)
    pixels_show()

100

101

102

103

104

105

106

107

108

109

110

111

112

113

# Exemple de programme test_LED.py pour la LED RGB.

# Le programme d'origine est adapté pour une seule LED

# et un défilé continu de couleurs

import array, time

from machine import Pin

import rp2

# Configure the number of WS2812 LEDs.

NUM_LEDS = 1

PIN_NUM = 16

brightness = 0.2

@rp2.asm_pio(sideset_init=rp2.PIO.OUT_LOW, out_shiftdir=rp2.PIO.SHIFT_LEFT, autopull=True, pull_thresh=24)

def ws2812():

T1 = 2

T2 = 5

T3 = 3

wrap_target()

label("bitloop")

out(x, 1) .side(0) [T3 - 1]

jmp(not_x, "do_zero") .side(1) [T1 - 1]

jmp("bitloop") .side(1) [T2 - 1]

label("do_zero")

nop() .side(0) [T2 - 1]

wrap()

# Create the StateMachine with the ws2812 program, outputting on pin

sm = rp2.StateMachine(0, ws2812, freq=8_000_000, sideset_base=Pin(PIN_NUM))

# Start the StateMachine, it will wait for data on its FIFO.

sm.active(1)

# Display a pattern on the LEDs via an array of LED RGB values.

ar = array.array("I", [0 for _ in range(NUM_LEDS)])

##########################################################################

def pixels_show():

dimmer_ar = array.array("I", [0 for _ in range(NUM_LEDS)])

for i,c in enumerate(ar):

r = int(((c >> 8) & 0xFF) * brightness)

g = int(((c >> 16) & 0xFF) * brightness)

b = int((c & 0xFF) * brightness)

dimmer_ar[i] = (g<<16) + (r<<8) + b

sm.put(dimmer_ar, 8)

time.sleep_ms(10)

def pixels_set(i, color):

ar[i] = (color[1]<<16) + (color[0]<<8) + color[2]

def pixels_fill(color):

for i in range(len(ar)):

pixels_set(i, color)

def color_chase(color, wait):

for i in range(NUM_LEDS):

pixels_set(i, color)

time.sleep(wait)

pixels_show()

time.sleep(0.2)

def wheel(pos):

# Input a value 0 to 255 to get a color value.

# The colours are a transition r - g - b - back to r.

if pos < 0 or pos > 255:

return (0, 0, 0)

if pos < 85:

return (255 - pos * 3, pos * 3, 0)

if pos < 170:

pos -= 85

return (0, 255 - pos * 3, pos * 3)

pos -= 170

return (pos * 3, 0, 255 - pos * 3)

def rainbow_cycle(wait):

for j in range(255):

for i in range(NUM_LEDS):

rc_index = (i * 256 // NUM_LEDS) + j

pixels_set(i, wheel(rc_index & 255))

pixels_show()

time.sleep(wait)

BLACK = (0, 0, 0)

RED = (255, 0, 0)

YELLOW = (255, 150, 0)

GREEN = (0, 255, 0)

CYAN = (0, 255, 255)

BLUE = (0, 0, 255)

PURPLE = (180, 0, 255)

WHITE = (255, 255, 255)

COLORS = (BLACK, RED, YELLOW, GREEN, CYAN, BLUE, PURPLE, WHITE)

while (1):

print("fills")

for color in COLORS:

pixels_fill(color)

pixels_show()

time.sleep(0.2)

print("chases")

for color in COLORS:

color_chase(color, 0.01)

print("rainbow")

rainbow_cycle(0)

time.sleep(0.5)

print("éteindre")

color=BLACK

pixels_fill(color)

pixels_show()

Note : Si vous utilisez un Raspberry Pi, le programme est enregistré avant d’être exécuté. Ce n’est pas le cas sur Windows. Pensez bien à enregistrer le programme si vous voulez le garder.

Dans les deux cas il faut choisir si vous enregistrez le programme sur le PC ou le Raspberry Pi (Cet ordinateur) ou sur le RP2040 (Raspberry Pi Pico). Pour les programmes en essai privilégiez le PC ou le Raspberry Pi. On enregistrera sur le RP2040 les librairies pour les composants et les programmes qui s’exécuteront en automatique sur la carte XIAO RP2040.

Conclusion provisoire

Si ce programme fonctionne, c’est bon signe. Allumer et éteindre une LED c’est le « Hello World » du maker. Ça veut dire que la carte fonctionne et que toute la chaine de programmation fonctionne également. Une fois ce premier résultat obtenu, on peut passer à des choses un peu plus élaborées.

Animer la LED RGB sur la carte RP2040-Zero

Principe

Le LED RGB (Rouge-Vert-Bleu) qui se trouve sur la carte (entre les deux boutons poussoirs) est une LED « adressable » . En fait on envoie des octets les uns derrière les autres en série. Le circuit de la première LED les reçoit sur Din, il prélève les 3 premiers octets qu’il utilise pour configurer les trois couleurs. Le premier octet règle la luminosité du rouge (0 à255), Le second octet règle la luminosité du vert (0 à255), Le troisième octet règle la luminosité du bleu (0 à255). Sur certains modèles les couleurs peuvent avoir un ordre différent.

Les 3 LED sont proches et l’œil va mélanger les couleurs émises pour créer une couleur qui n’existe que dans votre tête, comme un pixel sur un écran TV.

Pour gérer la LED, on peut : soit tout écrire soi-même, soit utiliser une bibliothèque écrite par quelqu’un d’autre, qui sait gérer les LED adressables. Je vous explique un truc. Un bon informaticien, c’est un bon fainéant. Je m’explique… Si un programme existe et qu’il fonctionne bien, pourquoi le réinventer ? Il vaut mieux l’utiliser, ça permet de gagner du temps et de se consacrer à apprendre autre chose. A moins que vous vouliez apprendre à gérer ce genre de LED vous même, auquel cas ce sera à vous de lire les docs et d’écrire le programme. Si c’est le cas, faites en une bibliothèque, elle vous servira une autre fois et pourra aussi servir à d’autres si vous la partagez. C’est bien sûr juste mon avis…

Utiliser une bibliothèque ws2812

Je vous avais expliqué dans un précédent article comment installer une librairie ws2812.py. Il y en a plusieurs qui sont disponibles, j’ai choisi celle ci. On va

Télécharger la librairie sur le PC (ou le Raspberry Pi)
L’ouvrir dans Thonny
L’enregistrer dans la carte RP2040-Zero

De ce fait, la bibliothèque de gestion de la LED RGB adaptée à la carte RP2040-Zero sera présente sur notre carte Waveshare et sera donc disponible pour notre programme.

Télécharger la bibliothèque

Cliquez sur ce lien qui affiche la bibliothèque ws2812.py depuis Github. Sélectionnez tout le texte affiché sur la page web.

Collez la bibliothèque dans Thonny

Créez un nouveau fichier dans Thonny, Collez la totalité du texte copié dans la fenêtre de Thonny.

La bibliothèque est maintenant dans Thonny, on va la transférer dans le RP2040.

Enregistrer la bibliothèque dans le RP2040

Cliquez sur Enregistrer sous… et choisissez Raspberry Pi Pico, ce qui va enregistrer la bibliothèque dans le RP2040.

Thonny va enregistrer le code qui apparait dans la fenêtre mais c’est vous qui allez lui donner un nom. Tapez ws2812.py dans la zone Nom de fichier. Il faut nommer la bibliothèque de cette façon car les programmes utilisent la bibli sous ce nom ! Après vous êtes libre de changer le nom, mais il faudra adapter vos programmes…
Cliquez sur OK pour enregistrer dans le RP2040.

Utiliser la bibliothèque

Fermer l’onglet ws2812.py de Thonny et ouvrez un nouveau programme (Fichier > Nouveau)
Chargez le code suivant dans Thonny (copier/coller):

import time
import ws2812

numpix = 1
strip = ws2812.ws2812b(numpix, 0,16)

RED = (255, 0, 0)
ORANGE = (255, 165, 0)
YELLOW = (255, 150, 0)
GREEN = (0, 255, 0)
BLUE = (0, 0, 255)
INDIGO = (75, 0, 130)
VIOLET = (138, 43, 226)
COLORS = (RED, ORANGE, YELLOW, GREEN, BLUE, INDIGO, VIOLET)

while True:
    for color in COLORS:
        for i in range(numpix):
            strip.set_pixel(i, color[0], color[1], color[2])
            time.sleep(0.2)
            strip.show()

import time

import ws2812

numpix = 1

strip = ws2812.ws2812b(numpix, 0,16)

RED = (255, 0, 0)

ORANGE = (255, 165, 0)

YELLOW = (255, 150, 0)

GREEN = (0, 255, 0)

BLUE = (0, 0, 255)

INDIGO = (75, 0, 130)

VIOLET = (138, 43, 226)

COLORS = (RED, ORANGE, YELLOW, GREEN, BLUE, INDIGO, VIOLET)

while True:

for color in COLORS:

for i in range(numpix):

strip.set_pixel(i, color[0], color[1], color[2])

time.sleep(0.2)

strip.show()

Exécutez le programme, vous devriez obtenir ceci :

SI vous regardez le programme vous voyez les lignes

numpix = 1
qui correspond au nombre de LEDs à programmer… ici il y en a une !

strip = ws2812.ws2812b(numpix,0,16)
Ici on utilise la bibliothèque ws2812 qu’on vient de mettre sur le RP2040, on lui passe les informations suivantes :

numpix = le nombre de LEDs à utiliser
La machine d’état à utiliser (ici la 0)
La broche Din (Data IN de la LED est sur le GPIO 16 du RP2040 => 16

Conclusion

Dans cet article vous avez pu découvrir la facilité de mise en ouvre de cette mini carte RP2040-Zero de Waveshare. Vous savez maintenant comment charger un firmware comme microPython dans la carte, utiliser Thonny pour exécuter un programme et ajouter une bibliothèque pour un composant. Plein de projets s’ouvrent à vous, vu le prix de la carte le risque est faible et c’est un bon outil pour apprendre à utiliser un microcontrôleur.

Si vous voulez partager vos projets, n’hésitez pas à me contacter, le les ajouterai sous cet article. Profitez également des commentaires pour dire ce que vous en pensez et parler de vos projets.

Cette carte est disponible sur Aliexpress à l’unité ou par lot de 5 à 7€ environ (sans ou avec les broches soudées).

Sources

14 réflexions au sujet de « Carte WaveShare RP2040-ZERO »

Jean-Michel Bapt 19 septembre 2022 à 18 h 44 min

Bonjour,

Merci encore une fois pour vos articles très intéressants !

J’ai essayé de comparer les caractéristiques de cette carte WaveShare RP2040-ZERO avec la carte XIAO RP2040 de Seeedstudio mais j’ai cherché sans les trouver deux renseignements concernant cette carte RP2040-ZERO :

Au niveau des dimensions, qu’elle est son épaisseur puisque apparemment, et contrairement à la carte XIAO RP2040, il y a des composants des deux côtés ?
La notice technique de la carte XIAO RP2040 indique que celle-ci dispose de 11 Digital I/O Pins et de 4 Analog I/O Pins. Cette indication ne figure pas (ou pas clairement) dans la notice technique de la carte RP2040-ZERO. Utilisant toutes les deux le même processeur, elle a très probablement 4 Analog I/O Pins (où sont elles ?) mais combien a-t-elle de Digital I/O Pins ? 25 ?Jean-Michel

Répondre ↓
1. François MOCQ Auteur de l’article20 septembre 2022 à 9 h 04 min
  
  Bonjour
  Avec la prise, elle fait 6mm d’épaisseur, moins d’un mm sous la carte. A mon avis pour l’utiliser sur une carte mère il faudrait avoir les pastilles pour la souder et une découpe pour laisser passer les composants qui sont dessous.
  Regardez le plan des GPIOs, vous verrez les 4 entrées analogiques à gauche, indiquées ADC0 à ADC3. Les E/S numériques sont notées GPxx. Comme tout MCU, les broches peuvent avoir plusieurs usages définissables par programmation.
  De même si on considère les E/S numériques il y en 29 réparties sur les broches et sur les pastilles à souder sous la carte. Après, si par exemple vous utilisez 2 entées analogiques, il reste seulement 27 E/S numériques. Si vous utilisez encore en plus un bus I2C, il ne reste que 25 E/S numériques…
  vous me direz si c’est clair pour vous?
  cdt
  françois
  
  Répondre ↓
Doudy 20 septembre 2022 à 8 h 43 min

Très intéressant mais ça sert à quoi cette carte supplémentaire ?

Faire clignoter des leds avec un Raspberry est possible aussi !

😉

Répondre ↓
1. François MOCQ Auteur de l’article20 septembre 2022 à 8 h 57 min
  
  Bonjour Doudy
  La LED qui clignote c est pour montrer que ça fonctionne (« Hello Word »)
  Cette carte embarque un microcontrôleur double coeur, le même que celui du Raspberry Pi PICO. On a donc une carte aussi puissante que le PICO dans une taille minime.
  Arduino a sorti une carte avec le même MCU : https://fr.rs-online.com/web/p/arduino/2221486 et de nombreux fabricants l’utilisent également (Seeedstudio, Adafruit, Waveshare…) on trouve une large gamme de programmes.
  Les applications du Raspberry Pi PICO (et donc de cette carte) sont vraimùent très étendues…
  cdt
  françois
  
  Répondre ↓
  1. Doudy 20 septembre 2022 à 11 h 17 min
    
    👍
    
    Répondre ↓
2. Viriathe 30 septembre 2022 à 20 h 01 min
  
  avec 4 ou 5 relais en plus elle peut remplacer à merveille le programmateur d’une machine à laver ou d’un lave vaisselle parce au vu du prix des programmateur en pièces de rechange au tant racheter un appareil neuf cela coûterait a peine plus cher.
  
  Répondre ↓
didifart 20 septembre 2022 à 12 h 15 min

Bojour,

Merci pour cet article si bien détaillé.

Est-ce qu’il est simple d’adapter un code fait au départ pour un arduino (AVR) au pico ?

Merci

Répondre ↓
Marlock 21 septembre 2022 à 9 h 30 min

Bonjour,

Pourriez-vous faire un tuto pour l’utilisation avec Arduino ? Il n’existe rien de tel sur le net pour cette carte qui est pourtant très prometteuse !

Merci par avance.

Répondre ↓
1. François MOCQ Auteur de l’article21 septembre 2022 à 9 h 32 min
  
  Bonjour
  vous voulez dire comment programmer cette carte dans l’IDE Arduino ?
  C’est comme pour le Raspberry Pi Pico ici : https://www.upesy.fr/blogs/tutorials/install-raspberry-pi-pico-on-arduino-ide-software
  cdt
  francois
  
  Répondre ↓
DDE 22 mai 2023 à 1 h 00 min

Bonjour,

Article bien complet mais il manque un point important à aborder pour que cette carte soit réellement utilisable : Est-il possible d’alimenter cette carte sans connecter l’USB-C ? Sur le PICO on peut utiliser le port 39 VSYS. Quel port est utilisable sur le RP2040-Zero ?

Merci par avance.

Répondre ↓
1. François MOCQ Auteur de l’article22 mai 2023 à 9 h 05 min
  
  Bonjour
  merci pour ce retour
  vous pouvez connecter directement du 5v entre les bornes 5v et masse
  Il n’y a pas de protection, il faut vous assurer que le 5V est stable
  Idem pour le 3,3v entre les bornes 3,3v et masse avec la certitude de ne jamais dépasser 3,3v !!
  Ne connectez pas non plus le 5v en direct sur le broches et la prise USB c…
  VSYS est particulier au PICO et n’existe pas sur cette carte
  cdt
  francois
  
  Répondre ↓
Elek 25 octobre 2024 à 12 h 12 min

Bonjour,
Très bel article.
J’ai deux questions.
La première concerne l’alimentation : si j’alimente la carte avec 5 V via USB, puis-je utiliser en toute sécurité les 5 V et 3 V3 extraits des broches de la carte ?
La seconde concerne la mémoire : puis-je utiliser la mémoire flash W25Q16JVUXIQ sur la carte (comment ?) dans mes programmes (j’ai besoin d’environ 32 octets) ou dois-je ajouter de la mémoire externe, par exemple via I2C ?

Répondre ↓
Alex 27 octobre 2024 à 7 h 49 min

Merci vraiment pour ce boulot formidable que vous faites , grâce à vous tout au long des années je suis débloqué où je progresse merci encore continuer le plus possible.

Répondre ↓
1. François MOCQ Auteur de l’article27 octobre 2024 à 7 h 59 min
  
  Merci ! je vais essayer 🙂
  
  Répondre ↓

Laisser un commentaire Annuler la réponse

Ce site utilise Akismet pour réduire les indésirables. En savoir plus sur comment les données de vos commentaires sont utilisées.

Framboise 314, le Raspberry Pi à la sauce française….

La référence du Raspberry Pi en France – Par l'auteur du livre "Raspberry Pi 4" paru aux Edts. ENI

Carte WaveShare RP2040-ZERO

Carte miniature Waveshare RP2040-Zero

Présentation

Composants de la carte RP2040-Zero

Dimensions de la carte RP2040-Zero

GPIO accessibles sur la carte RP2040-Zero

Caractéristiques

Mise à jour au démarrage

Entrer dans le mode Bootloader

Reset – Réinitialisation

Schéma de la carte

Mise en œuvre de microPython

Introduction à MicroPython

Mise en route

Installer microPython

Le matériel utilisé

Installation de THonny

Connexion de la carte RP2040-Zero

Conclusion provisoire

Animer la LED RGB sur la carte RP2040-Zero

Principe

Utiliser une bibliothèque ws2812

Télécharger la bibliothèque

Collez la bibliothèque dans Thonny

Enregistrer la bibliothèque dans le RP2040

Utiliser la bibliothèque

Conclusion

Sources

À propos François MOCQ

14 réflexions au sujet de « Carte WaveShare RP2040-ZERO »

Laisser un commentaire Annuler la réponse