SunFounder m’a envoyé cette carte PiPower 5 pour la tester sur le Raspberry Pi. Il s’agit d’une UPS (Uninterruptible Power Supply), c’est-à-dire d’une alimentation secourue : en cas de coupure du secteur, la batterie prend le relais pour éviter un arrêt brutal du système. La PiPower 5 sert donc à protéger la carte, la carte […]

Cet article SunFounder PiPower 5 HAT+ : test complet de l’UPS pour Raspberry Pi 5 a été publié en premier sur Framboise 314, le Raspberry Pi à la sauce française..... - 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

 Bonjour à tous,

Tout récemment, je voulais utiliser un module RFM69 sur un Compute Module 5 (autrement dit l'équivalent d'un Raspberry-Pi 5) faisant fonctionner un logiciel écrit Python.

Une API MicroPython sous Python

Le module RFM69

L'image ci-dessous se présente le module RFM69HCW 433MHz . Ce module permet de transmettre des données sur un réseau numérique utilisant le ondes-radios comme medium de transfert. C'est un peu le protocole internet appliqué à la radio.

RFM69HCW 433MHz

Comme le Pilote est développé sous le précepte "Plateform Agnostic Driver" de sorte à pouvoir fonctionner indépendamment de la plateforme MicroPython cible.

esp8266-upy - Plateform Agnostic Micrpython Driver

Ce module se branche sur un bus SPI, il est donc possible de le connecter sur GPIO d'un Raspberry-Pi 5 (ou du Compute Module 5).

Source: Raspberry-pi.ovh

Brancher RFM69 sur GPIO

Les connexions suivantes sont établies entre le module RFM69 et le GPIO Raspberry-Pi.

Prototype

Compatibilité avec Python

Commençons par récupérer la bibliothèque MicroPython du RFM69 depuis le dépôt esp8266-upy pour y ajouter l'encodage du fichier (important pour Python).

Ajout de l'encodage dans le bibliothèque RFM69

Récupérer l'exemple test_config.py utilisé pour tester la communication avec le module RFM69. Nous y ajoutons également l'information d'encodage dans le fichier.

Couche de compatibilité Python --> MicroPython

Création des fichiers machine.py et micropython.py pour accueillir les classes Pin & SPI ainsi que la déclaration de la fonction const()

Le script le plus intéressant est hack_time.py car celui-ci permet d'ajouter les fonctions MicroPython (ticks_ms, ticks_diff, sleep_ms, etc) manquantes dans Python.

#!/usr/bin/python
# -*- coding: utf-8 -*-
""" hack_time.py : mimic the MicroPython alike specific methods """
import time

def _sleep_us( us ):
	time.sleep( us*0.000001 )

def _sleep_ms( ms ):
	time.sleep( ms*0.001 )

def _ticks_ms():
	return int(time.time()*1000)

def _ticks_diff( v1, v2 ):
	return v1-v2

time.sleep_us = _sleep_us
time.sleep_ms = _sleep_ms
time.ticks_ms = _ticks_ms
time.ticks_diff = _ticks_diff

Il ne reste plus qu'a adapter le script d'exemple pour créer l'instance du bus SPI (sur le RPi) et passer le tout à la bibliothèque MicroPython originale.

#!/usr/bin/python
# -*- coding: utf-8 -*-

from machine import SPI, Pin
import hack_time
from rfm69 import RFM69

# Machine.py for Raspberry-Pi 5
spi = SPI( 0 )
nss = Pin( 25, Pin.OUT, value=True )  # Do not use the RPI CE0/CE1, it is not compatible with the Burst_Read of RFM69
rst = Pin( 18, Pin.OUT, value=False )

rfm = RFM69( spi=spi, nss=nss, reset=rst )
rfm.frequency_mhz = 433.1
....

Le bus SPI est rattaché au bus matériel SPI0 & CE0. 

Une broche Enabled (nss) alternative est utilisé avec le GPIO25 pour contrôler les transactions du bus SPI. La broche CE0 du GPIO est donc ignorée.

Enfin, le GPIO 10 est utilisé pour réinitialisé le module RFM69.

Au final, la création de l'instance RFM69 et le restant du code (y compris la bibliothèque RFM69) est identique entre MicroPython et Python (sur RPi5).

L'exécution de l'exemple sur le Raspberry-Pi 5 produit le résultat attendu (identique lorsqu'il est exécuté sur un Pico).

test_config.py : exécution de la bibliothèque MicroPython RFM69 sur Raspberry-Pi 5

Ressources

• MicroPython-API-for-Python experiment is published on GitHub.

Bonjour à tous,

J'ai eu l'occasion, de récupérer une ancienne tablette Galaxy Tab 6 (2019) et son clavier Bluetooth. Un système Android malheureusement plus tenu à jour en 2025 donc à l'utilisation déconseillée.

Clavier Galaxy Tab S6 (Bluetooth)

Contre toute attente, il m'a été impossible d'appairer ce clavier avec un autre système. Ceci dit, cela n'est pas très étonnant d'être confronté à un système fermé.

A contre-courant de l'obsolescence

Si je n'ai pas encore trouvé comment reconvertir la tablette (n'hésitez pas à commenter), je me suis lancé dans la reconversion du clavier pour une future application MicroPython.

Cela commence forcement par l'ouverture du clavier qui n'est pas bien difficile (il y a 4 vis sous chacun des anti-dérapant.

Clavier Galaxy Tab S6

On y retrouve un clavier à membranes connecté sur un connecteur 26 broches, un accu Lipo de faible puissance, un touchpad I2C et un microcontroleur bluetooth (non visible de ce côté de la carte).

Clavier Galaxy Tab S6

Loin moi l'idée de reprogrammer le microcontrôleur Bt de la carte (ses protections matérielles sont certainement active), je me suis dit qu'il serait plus facile de réutiliser directement la membrane avec un Pico.

C'est que l'on imagine cette membrane comme un clavier de KeyPad dont le fonctionnement est sommaire.

Avec un peu d'analyse, j'ai rapidement repéré des résistances pull-down de 35 KΩ sur chacune des lignes (excepté les 5 premières). D'autres lignes marquée sont elles équipées d'un composant spécifique (voir les points blancs sur l'image ci-dessous).

Je pensais avoir repéré les colonnes, les autres signaux étant alors les lignes.

Malheureusement, les choses ne furent pas si simples!

Un peu de hacking

Je commence donc par souder des fils vernis 0.2mm sur le connecteur en vue de réaliser des tests. Les fils sont maintenus bien en place à l'aide de colle chaude (pour éviter  de casser les fragiles soudures des fils).

Quelques fils soudés sur le connecteur (pin 1 à droite).

J'ai procédé de même avec les 26 contacts ensuite reporté sur une plaque de prototypage (bien dans l'ordre).

report des connexions sur une plaque de prototypage offrant un accès via connecteur 2.54mm

Connexion au Pico

J'ai utilisé 2x MCP23017 (GPIO expander 16 bits) pouvant être contrôlé via bus I2C, donc avec seulement deux lignes connectés sur le Pico.

Matrice clavier branché sur des MCP23017

Brochage du MCP23017

L'intérêt des MCP23017 est d'avoir les broches 1 à 26 du connecteur clavier branchés scrupuleusement dans l'ordre croissant des GPIOs des MCP23017. Pas de mathématiques complexes, il y a une relation 1-à-1 entre les MCP et la matrice clavier.

Correspondance broche clavier (1..26) vers MCP (0..15) + MCP (0..9)

Enfin, j'ai aussi remarqué que l'usage de résistance pull-down sur les 5 premières lignes améliorait la stabilité de la détection. Ces pull-down manquantes sur le connecteur clavier était probablement activée sur le microcontroleur bluetooth.

Décoder la matrice clavier

Après un premier échec sur l'identification des colonnes et des lignes de la matrice, un second script a été écrit pour tester une à une chaque ligne comme une colonne considérant alors les 25 autres lignes pour détecter une touche.

Le script tester2.py publié sur le dépôt agit comme suit:

1. Presser une touche du clavier
2. Au démarrage, toutes les broches sont configurées en entrée.
   Elles présentent toutes une haute impédance.
3. Ensuite le script sélectionne une ligne -- dite driver pin--, la configure en sortie et la place au niveau haut. Cette broche présente donc une faible impédance et est capable de fournir du courant.
4. Ensuite, les 25 autres broches --read pin-- sont interrogés une par une pour y détecter un niveau haut.
   Note: la touche pressée doit permettre au courant de circuler vers une des broches en lecture.
   
5. S'il N'Y A PAS de détection de niveau haut ALORS
   * le script repasse la driver pin au niveau bas
   * PUIS  reconfigure celle-ci en entrée.
   * ENFIN, le script passe la driver pin sur la broche suivante
   * et recommence le cycle de détection au point 3.
6. S'il Y A détection d'un niveau haut  ALORS le script a détecté un couple (driver_pin, read_pin) permettant de détecter la touche enfoncée.

Après avoir testé toutes les touches et répertorié les combinaisons dans une feuille calcul. Nous avons enfin un description de la matrice du clavier.

feuille calcul des détection de touches

La feuille de calcul reprend les couples drive_pin,read_pin dans la 2ieme colonne. 

Puisque le contact électrique se fait dans les deux sens entre drive_pin--et--read_pin alors il est possible d'écrire la relation de détection de F12 comme 7,13 ou 13,7 (d'ailleurs, les deux options sont indiquées par tester2.py ). 

Par souci de simplicité, la relation est écrite avec le plus petit numéro de broche d'abord (donc 7,13 pour la touche F12).

Compilation des broches

Maintenant que nous disposons d'une description de la matrice, il serait opportun d'identifier les driver_pin et les read_pin utilisés dans la matrice.... cela revient à identifier les lignes et les colonnes du keypad présenté plus haut dans l'article.

C''est justement l'objectif du script tester2-driver-pin-detect.py disponible dans le dépôt.

Ce dernier permet d'identifier:

• driver pin = [6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21]
• read pin = [12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26]

Remarque:

Il y a un recouvrement des broches driver_pin et read_pin. Suivant les circonstances, une broche de la matrice clavier agit tantôt comme broche driver_pin tantôt comme broche de read_pin (de lecture).

Lecture optimisée

Sur base des informations obtenue, le script tester3.py disponible dans le dépôt effectue une détection optimisée des touches du clavier.
La détection s'étend aux combinaisons de touches avec Shift,Ctrl,Alt.

Il reste encore un peu de travail mais le plus gros est fait :-)

 

 

Il y a un peu plus de trois ans, je vous présentais déjà la carte NadHAT MK2, basée sur un modem 4G A7682E, imaginée et fabriqué en France par Garatronic et distribuée par McHobby. Cette carte bénéficie d’un support sérieux et de bibliothèques bien suivies, ce qui la distingue de nombreuses productions asiatiques. Aujourd’hui, place […]

Cet article La 4G avec un Raspberry Pi Pico ? C’est possible ! a été publié en premier sur Framboise 314, le Raspberry Pi à la sauce française.....

Amis de MicroPython... Bonjour,

Cela faisait longtemps que nous n'avions pas eu l'occasion de porter un nouveau pilote sous MicroPython. 

Renesas FS3000

Cette fois, nous nous sommes penchés sur le capteur FS3000  de Renesas qui mesure la vélocité de l'air. Capteur que l'on retrouve sur les breakout FS3000 de SparkFun.

Capteur FS3000 de SparkFun

Ce type de capteur est principalement utilisé dans des systèmes de refroidissement ou de conditionnement d'air. Comme il dispose d'une interface I2C, il est très facile de l'exploiter avec de nombreux microcontrôleur.

Les cartes breakout existent en deux versions:

• FS3000-1015 mesurant des flux jusqu'à 15m/s (54 Km/H).
• FS3000-1005 mesurant des flux jusqu'à 7ms/s  (25 km/H).

Pilote MicroPython

Bien que SparkFun propose un pilote MicroPython --ce que je salue-- celui-ci est construit sur une surcouche d'abstraction permettant permettant d'utiliser le capteur avec CircuitPython et MicroPython.

Etant un fan inconditionnel de MicroPython, je pense qu'il est préférable de disposer d'un code qui va droit au but... avec le moins de détour possible! C'est ainsi que l'on maintient une efficacité optimale d'exécution.

J'ai décidé de recréer un pilote à partir du code Arduino. En effet, il à été plus facile de travailler à partir du code Arduino que de suivre la couche d'abstraction CircuitPython/MicroPython.

Le pilote alternatif est disponible sur notre dépôt esp8266-upy/qwiic-ait-velocity .

Brancher sur un Raspberry-Pi Pico

Le schéma suivant indique comment brancher le capteur sur un Pico à l'aide d'un câble Qwiic (qui transporte un bus I2C).

Brancher un capteur FS3000 sur un Raspberry-Pi Pico

 

Du code pour le peuple

Après avoir transféré la bibliothèque airspeed sur la plateforme MicroPython, il ne reste plus exécuter l'exemple ci-dessous.

from machine import I2C,Pin
from airspeed import FS3000, AIRFLOW_RANGE_15_MPS
import time

# Raspberry-Pi Pico
i2c = I2C( 1, sda=Pin.board.GP6, scl=Pin.board.GP7 )
# Adresse par défaut
air_speed = FS3000( i2c )

# air_speed.set_range( AIRFLOW_RANGE_7_MPS )
air_speed.set_range( AIRFLOW_RANGE_15_MPS )

while True:
	print( "FS3000 lecture brute:", air_speed.read_raw() ) # 125ms acquisition
	#  lecture en metre par seconde, retourne un float de 0 - 7.23 pour FS3000-1005, 0 - 15 pour FS3000-1015 
	airflow_mps = air_speed.read_mps()
	if airflow_mps != None: # retourne None en cas d'erreur CRC!
		print( "   m/s:", airflow_mps ) 
		airflow_kmh = airflow_mps*3600/1000
		print( "   Km/h:", airflow_kmh ) 
		airflow_mph = airflow_mps*2.2369362912
		print( "   Miles/h:", airflow_mph ) 
	time.sleep( 1 )

Ressources

• Bibliothèques FS3000 pour MicroPython
• Gamme Raspberry-Pi Pico
  

Le 1/1000ème de seconde est sans doute superflu, mais il illustre bien la précision qu’il est possible d’obtenir avec un microcontrôleur moderne comme le Raspberry Pi Pico. Ce projet vous propose de réaliser un chronomètre autonome, pensé pour des jeux ou activités scolaires, doté d’un écran OLED bien lisible et alimenté par une batterie LiPo. […]

Cet article Construire un chronomètre scolaire autonome avec Raspberry Pi Pico et écran OLED a été publié en premier sur Framboise 314, le Raspberry Pi à la sauce française.....

💾

Bonjour à tous,

Aujourd'hui, nous avons l'occasion de nous pencher sur le microcontrôleur MicroPython le plus rapide à ce jour.

RT1010-Py

IMXRT1010RM de NXP qui équipe la carte RT1010-Py d'Olimex, une carte de développement Cortex M7 fonctionnant à 500 MHz. soit 4 fois plus rapide que le RP2040 avec MicroPython pré-installé.

carte RT1010-Py d'Olimex

Avec un Cortex M7 et un support DSP, ce microcontrôleur sera surtout intéressant pour les applications en besoin de réactivité et de puissance de calcul (unité de calcul en virgule flottante à double précision).

Nous avons travaillé/collaboré sur le manuel utilisateur et la documentation afin de rendre la carte de développement et son DevKit plus accessibles.  Vous savez... dès qu'il s'agit de MicroPython, on ne se tient plus!

Brochage du RT1010-Py (par MCHobby)

Nous avons apporté quelques ressources graphiques mais également étayé la documentation avec des exemples et des ressources utiles autour pour MicroPython. Nos apports les plus significatifs restant l'exemple I2S, le support WS2812/NeoPixel et la gestion du PMIC (gestion d'alimentation intégrée au RT1010) qui permet, par exemple, de maintenir la RTC à l'heure alors que le MCU est arrêté.

• MIMXRT1011DAE5A running at 500Mhz
• 128KB de RAM RAM
• 2MB de FLASH SPI
• 3x UARTs
• 2x bus SPI matériel
• 2x bus I2C matériel
• 1x bus I2S (il y en a un second mais pas encore testé)
• 4 contrôleurs PWM (avec sorties complémentaires pour créer des circuits push-pull)
• USB 2.0 OTG
• Connecteur Micro SD
• RTC avec cristal 32.768 kHz
• Bouton RESET
• Bouton BOOT (pouvant servir de bouton utilisateur)
• Connecteur fUEXT (flat ribbon) avec 3.3V, GND, I2C, SPI, UART
• Connecteur GPIO breadboard friendly
• Dimensions: 53.34 x 25.4 mm 

Cette plateforme existe depuis un moment mais le support MicroPython est maintenant mature. 

RT1010-Py DevKit

RT1010-Py DevKit

Le kit de développement RT1010-Py propose:

• 2x relais
• 2x connecteurs UEXT distincts (voir notre gamme UEXT, voir la gamme UEXT chez Olimex).
  MC Hobby propose d'ailleurs un support MicroPython pour de nombreux modules UEXT).
• 1x Edge connector avec de nombreux GPIOs
  

Comme pour le RT1010-Py, nous avons participé à la rédaction de son manuel utilisateur et aux ressources graphiques facilitant la prise en main.

 

Brochage des connecteurs UEXT

Edge connector du RT1010Py-DevKit

Toute l'information nécessaire pour débuter facilement avec cette plateforme sous MicroPython.

Ressources

• Microcontroleur RT1010-Py @ MCHobby
• RT1010-Py-DevKit @ MCHobby 
• DOCUMENTATION du RT1010-Py (anglais)
• DOCUMENTATION du RT1010-Py-DevKit (anglais)
  

Bonjour à tous,

Nombre d'entre-vous savent que nous sommes impliqué dans le projet CanSat (voir précédents articles sur le sujet CanSat). 

Nous poursuivons les travaux sur Kit CANSAT version 2, l'occasion de s'intéresser à des extensions utiles.
Pour rappel, notre kit utilise un Raspberry-Pi Pico et du code Python sur microcontrôleur (MicroPython).

Documentation Open-Source disponible sur le Wiki de MCHobby.

A propos de CanSat

CanSat est un concours visant a stimuler l'apprentissage des sciences dans le domaine de l'AéroSpatial en réalisant un mini-satellite (la CanSat) pas plus grande qu'une boîte de Soda. Ce satellite est envoyé et éjecté à 3000m d'altitude à l'aide d'une roquette. C'est à partir de ce moment que votre projet capture les données et les envois au sol.

Si vous voulez en apprendre plus sur le concours CanSat, je vous invite à visiter la page d'accueil CANSAT sur EseroBelgium.be .

Module GPS pour CanSat

Dans les divers modules envisagé, il y a le module GPS/GNSS destiné à communiquer la position de la CanSat durant son vol.

Ci-dessous le module en cours de validation.

CANSAT-GPS-V2 par MCHobby

Ainsi, une variante de l'attache parachute (dit CanSat-BUN) pour l'équiper d'un  GPS Ultime. 

Etant donné que ce module est supposé se retrouver sur le dessus de la CanSat (pour exposer l'antenne vers le ciel), le point de connexion est reporté sous la carte. 

Un simple câble Grove permettra de raccorder le GPS sur l'entrée UART de la CANSAT en deux clicks.

CANSAT-GPS-V2 par MCHobby

La carte expose également les deux signaux supplémentaires:

• 1pps : Pulsation à très précisément 1 Hertz (1 pulsation par seconde)
• nRest : Reset du module GPS. Placer cette broche au niveau bas réinitialise le module GPS.

A propos du module GPS Ultime

C'est que le breakout GPS/GNSS produit par AdaFruit dispose d'une excellente module GPS/GNSS disposant d'une grande sensibilité et d'une antenne intégrée (dite Patch Antenna).

Même avec son antenne Patch, le démarrage à froid de ce module permet d'obtenir un fix GPS/GNSS relativement rapidement (de l'ordre de la minute).
Tandis que s'il est utilisé avec un pile CR2032, le démarrage à chaud permet de réduire drastiquement le temps du fix GPS/GNSS.

Le GPS-Ultime est capable d'offrir un rafraîchissement des données jusqu'à 10 fois par secondes (10 Hz).

Support MicroPython

Le dépôt cansat-belgium-micropython reprend la bibliothèque lib/adafruit_gps.py résulte d'un précédent portage Arduino vers MicroPython.
Maintenant compatible avec les trames GNSS, la bibliothèque permet de tester les scripts d'exemples test-gps pour CanSat :

cansat-belgium-micropython

Le script simpletest.py permet de collecter les données du GPS et d'en afficher les données. 

========================================
Fix timestamp: 10/18/2025 17:03:51
Latitude: 50.69063 degrees
Longitude: 4.400778 degrees
Fix quality: 1
# satellites: 10
Altitude: 110.0 meters
Speed: 0.36 knots and 0.666468 km/h
Track angle: 159.4 degrees
Horizontal dilution: 1.19
Height geo ID: 47.4 meters
========================================
Fix timestamp: 10/18/2025 17:03:52
Latitude: 50.69063 degrees
Longitude: 4.40078 degrees
Fix quality: 1
# satellites: 10
Altitude: 110.0 meters
Speed: 0.31 knots and 0.573903 km/h
Track angle: 159.4 degrees
Horizontal dilution: 1.19
Height geo ID: 47.4 meters

Il est possible de visualiser les coordonnées dans google maps en saisissant les coordonnées "50.69063 ,  4.400778" (lattitude , longitude) dans la zone de recherche.

Où acheter

• Le CANSAT-GPS-V2 est disponible chez MCHobby.

Bonjour à tous,

ROMFS: une nouvelle fonctionnalité fait son apparition dans MicroPython. 

ROMFS qui est en développement depuis plusieurs années permet de stocker 

• des utilitaires (scripts pré-compilé), 
  
• des fichiers de données (fonts)
• des programmes pre-compilés 

Au sein même d'une partition dans la Mémoire Flash (sous forme d'un système de fichiers en lecture seule).  

Le but de ROMFS est d'optimiser l'accès et la rapidité d'exécution de ressources  SANS DEVOIR RECOMPILER MicroPython à chaque fois. 

Jusqu'à maintenant, seule l'inclusion -au sein du firmware- de scripts pré-compilés avec mpy-cross permettait d'atteindre les performances nécessaires à l'exécution de code "time sensitive".

Certes, mpy-cross permet de compiler un script en byte-code (des fichiers .mpy) mais l'accès reste encore conditionné par le système de fichiers pour le chargement (ou chargements multiples). Les fichiers .mpy, bien que pré-compilé, nécessite malgré tout des vérifications de routine et du chargement d'information en RAM.

Avec ROMFS, une partition dans la mémoire Flash permet d'être accédée directement par la VirtualMachine MicroPython. Les ressources sont directement accessibles par le noyaux MicroPython qui peut aussi lancer l'exécution directement en Flash (In-Place execution)... et cela en s'évitant la lourdeur du système de fichiers, les phases de compilations et allocations de RAM. Les routines de vérifications sont elles aussi réduites au stricte nécessaire puisque celles-ci sont opérées majoritairement au moment de l'assemblage/compilation de la ROMFS.

Implémentation restreinte

Au moment de l'écriture de ces ligne (MicroPython v1.25), ROMFS n'est disponible nativement que sur certaines plateformes: PYBD-SFx (Pyboard D), ALIF-Ports, ESP8266_Generic, STM32 boards.

Sinon, il est possible de compiler le firmware en activant la flash_romfs (voir FLASH_2M_ROMFS).

Utilitaire mpremote

L'utilitaire MPRemote de MicroPython a également le nouveau mot clé romfs avec les options:

• query: pour consulter la romfs dans la flash.
• build: pour créer une image romfs sur l'ordinateur
• deploy: pour déployer l'image sur la romfs dans la mémoire flash du microcontroleur.

A noter que la compilation/build d'une image romfs require l'utilitaire mpy-cross .

romfs query

La capture suivante indique le contenu de la romfs sur le microcontroleur.

mpremote romfs query

Comme l'indique le réponse de l'utilitaire, la partition n'est pas encore initialisée. La partition fait 131 Kio (32 blocks de 4 Kio chacun).

romfs build

Prenons l'exemple d'un répertoire "utilities" qui contient les sources. Celui-ci ne contient qu'un script nommé "scan_i2c.py".

L'image de la partition romfs est créé avec la commande suivante:

mpremote romfs -o utilities.img build utilities

Le nom de l'image à créer est spécifié par le paramètre '-o'.
Le contenu du répertoire à compiler est précisé après le paramètre 'build'.

romfs deploy

Une fois l'image prête sur l'ordinateur, l'option deploy permet de copier celle-ci sur le microcontroleur.

mpremote romfs deploy utilities.img

Une fois l'image déployée, il est possible de vérifier une nouvelle fois l'état de la ROMFS avec romfs query . Cette fois, la partition est initialisée.

Exploiter la ROMFS

Une fois romfs initialisé, il est très facile d'utiliser son contenu.
Utiliser Thonny IDE permet d'inspecter le système de fichiers MicroPython. 

La partition romfs est montée dans le système de fichiers MicroPython sous le répertoire 'rom'.
Il est donc possible d'en inspecter le contenu.

Comme le démontre le shell interactif, il est possible de charger et d'exécuter le contenu de scan_i2c.py (compilé en .mpy) en executant un simple "import" sous Python.

ROMFS est un système de fichiers

L'appel de mount() sans paramètre affiche les systèmes de fichiers déjà monté dans MicroPython.

Ainsi les lignes suivantes indique la présence de romfs:

>>> import vfs
>>> print( vfs.mount() )
[ VfsRom('rom'), VfsFat('/flash') ]
>>> 

Toutes les fonctions de manipulation de fichiers sont donc utilisable sur le système de fichiers ROMFS.

Ressources

• Micropython 1.25.0 - What's ROMFS?
• Deep Dive MicroPython 1.20 : ROMFS Architecture

 

Bonjour à tous,

Nombre d'entre-vous savent que nous sommes impliqué dans le projet CanSat (voir précédents articles sur le sujet CanSat). 

Nous poursuivons les travaux sur Kit CANSAT version 2, l'occasion de faire le point.
Pour rappel, notre kit utilise un Raspberry-Pi Pico et du code Python sur microcontrôleur (MicroPython).

Documentation Open-Source disponible sur le Wiki de MCHobby.

A propos de CanSat

CanSat est un concours visant a stimuler l'apprentissage des sciences dans le domaine de l'AéroSpatial en réalisant un mini-satellite (la CanSat) pas plus grande qu'une boîte de Soda. Ce satellite est envoyé et éjecté à 3000m d'altitude à l'aide d'une roquette. C'est à partir de ce moment que votre projet capture les données et les envois au sol.

Si vous voulez en apprendre plus sur le concours CanSat, je vous invite à visiter la page d'accueil CANSAT sur EseroBelgium.be .

Cansat V2 : le point

100% compatible avec la version précédente (câblage code), nous avons terminé le premier round de test du prototype Alpha. Les correctifs nécessaires sont apportés et aux cartes et le prototype Beta arrive prochainement.

Outre les aspects mécaniques déjà abordés au précédent article, nous allons pouvoir nous attarder sur les caractéristiques électroniques.

Je vous présente Cansat-Pico V2

Cansat Pico V2 (source: MCHobby Wiki)

 

Cansat Pico V2 (source: MCHobby Wiki) Note: connecteur d'antenne manquant.

Et le visite ne serait pas complète sans inspecter le dessous de la carte.

Cansat Pico V2 (source: MCHobby Wiki)

Quelques détails croustillants

Comme annoncé, nous avons cherché à faciliter les connexions en utilisant des connectiques populaires (Qwiic/StemmaQt et Groove).

LA sérigraphie reprend également de nombreuses informations pour permettre

Cansat Pico V2 (source: MCHobby Wiki) Note: le connecteur d'antenne est manquant sur la photo

Cansat Pico V2 (source: MCHobby Wiki)

Les autres cartes permettant de créer une CANSAT complete sont également prêtes...

Cansat Pico V2 (Lettuce, Onion et Bun)

Pour l'instant, nous consacrons les efforts sur:

• La mise-à-jour et réorganisation du Wiki
• Travail approfondi sur les antennes.

Bonne lecture,
Dominique

Bonjour à tous,

Nombre d'entre-vous savent que nous sommes impliqué dans le projet CanSat (voir précédents articles sur le sujet CanSat). 

Nous faisons actuellement évoluer notre Kit CANSAT vers une version 2 .
Pour rappel, notre kit utilise un Raspberry-Pi Pico et du code Python sur microcontrôleur (MicroPython).

Documentation Open-Source disponible sur le Wiki de MCHobby.

A propos de CanSat

CanSat est un concours visant a stimuler l'apprentissage des sciences dans le domaine de l'AéroSpatial en réalisant un mini-satellite (la CanSat) pas plus grande qu'une boîte de Soda. Ce satellite est envoyé et éjecté à 3000m d'altitude à l'aide d'une roquette. C'est à partir de ce moment que votre projet capture les données et les envois au sol.

Si vous voulez en apprendre plus sur le concours CanSat, je vous invite à visiter la page d'accueil CANSAT sur EseroBelgium.be .

Les retours d'expériences

Des précédents tirs et expériences utilisateurs, voici ce qu'il serait utile d'améliorer sur le kit actuel:

• Améliorer la robustesse globale (meilleure résistance aux chutes).
• Réduire le diamètre des cartes (l'actuel 1mm pour réaliser une paroi semble trop contraignant pour de nombreux débutants).
• Connecteur FPC (pour le ruban) reste "fragile".
  Les manipulations avec brusqueries peuvent facilement déboîter la fermeture.
• Pour les débutants, il serait préférable d'insérer un Pico dans un connecteur plutôt que le souder directement sur la Cansat-Base. Il sera ainsi plus facile à remplacer.
• Souder le module radio et le chargeur Lipo sont des opérations fastidieuses (surtout si c'est la première fois).

Cansat : améliorations mécaniques

3) carte MCU remplaçable