RpiPowerControl, un contrôleur d’alimentation pour le RaspberryPi!

Cela fait un moment que je n’ai plus posté d’article sur ce blog, et ce, pour plusieurs raisons. La principale étant que je travaillais sur un petit projet en parallèle de Touchradio :RpiPowerControl. Derrière ce nom se cache un petit module me permettant de contrôler (ON/OFF) l’alimentation du RaspberryPi et de l’écran tactile, individuellement.

J’avais en effet besoin de ce genre de module pour Touchradio. Comme je l’ai dis précédemment, j’ai actuellement une version utilisable du soft, et j’ai donc commencé à l’utiliser dans ma cuisine. Comme vous le savez, le RaspberryPi ne dispose pas de bouton permettant d’allumer, d’éteindre ou de resetter le système. Il est donc nécessaire de brancher l’alimentation lorsque l’on souhaite l’allumer, et de retirer la prise pour l’éteindre ou le redémarrer. Cela se faisait du temps de Windows95, où l’ordinateur nous demandait gentiment d’éteindre l’ordinateur lorsque le système avait fini sa procédure d’arrêt. Mais de nos jours, nous sommes habitués à allumer nos appareils high-tech en appuyant sur un simple bouton, et à les arrêter ou les mettre en veille en réappuyant sur ce même bouton.

Je me devais donc de trouver une solution. Et je ne suis pas le premier à avoir fait ce constat car il existe déjà des solutions toutes prêtes, dédiées au RaspberryPi. Notamment:

  • Pi UPS, qui est un circuit disposant de deux sources d’alimentation : le secteur et des piles. Dès que l’alimentation sur le secteur disparaît, il peut soit laisser le Raspberry fonctionner sur les piles, soit donner de l’énergie au Raspberry le temps d’effectuer un arrêt proprement.
  • ATXRaspi, qui permet d’allumer et d’éteindre le RaspberryPi via un bouton externe.
  • Et en cherchant un peu, on trouve facilement des articles de blogs, de forums et des sites présentant d’autres montages aux fonctionnalités similaires.

ATXRaspi réponds presque à mon besoin… Mais pas tout à fait: Touchradio est basée sur un RaspberryPi et un écran tactile! Je ne suis pas sûr que ce genre de montage puisse supporter le courant nécessaire pour alimenter les deux, car on doit avoisiner les 2A en 5V. De plus, l’idéal serait de pouvoir éteindre et allumer l’écran tout en laissant le RaspberryPi allumé, afin de le laisser continuer à jours de la musique même quand l’affichage n’est plus nécessaire.

C’est donc suite à ce constat que j’ai décidé de créer mon propre module de contrôle d’alimentation intelligent à deux sorties.

Pour ce faire, je pouvais essayer de trouver un circuit existant et le modifier et l’adapter à mes besoins, ou créer mon propre circuit électronique mais… mes connaissances en électronique sont extrêmement limitées. Par contre, niveau soft, je me débrouille assez bien. J’ai donc récupéré une carte de d’évaluation pour processeur STM32F0 (STM32F0Discovery).

Hardware

Il s’agit d’une « petite » carte d’évaluation pour le processeur STM32F0, disposant d’une LED, d’un bouton ainsi que des pin header permettant un accès aisé à toutes les pins du µP. Le processeur est basé sur un coeur ARM Cortex disposant de 64KB de mémoire FLASH, 8KB de mémoire RAM, des USART, DMA, Timers, GPIO,…

Utiliser ce µP pour un module aussi simple, c’est comme utiliser un tank pour tuer une mouche, mais… au moins, je me retrouve dans un domaine que je connais (le développement embarqué), sur une plateforme que je connais (je travaille avec ce genre µP tous les jours au boulot), et je n’avais que ça sous la main!

J’ai donc demandé à un gentil collègue électronicien de me monter deux relais, deux boutons, deux LEDS et des borniers afin de pouvoir interfacer le µP avec le monde extérieur et… le RaspberryPi. Finalement, nous en sommes arrivés à un montage représenté par le schéma suivant :

Et voici deux photos du montage réel. D’abord, la carte STM32F0Discovery, et, fixé par des pin-headers sur son dos, le petit circuit électronique avec les relais, boutons et leds:

Les deux relais permettent de contrôler indépendamment l’alimentation du RaspberryPi et de l’écran tactile. Ils sont contrôlés au moyen des deux boutons. Les LEDs permettent de fournir un retour à l’utilisateur. La communication entre le module et le RaspberryPi s’effectue via un USART (port série). De nouveau, j’aurais pu utiliser de simples signaux analogiques (GPIO) mais vu que j’en avais sous la main, autant les utiliser! Cela permettra d’implémenter des fonctionnalités de plus haut niveau par la suite.

Software

Voici la partie intéressante pour moi, celle où je maîtrise la situation : le software. La première question que je me suis posée était de savoir si j’allais utiliser un RTOS (Real-time operating system) ou non… N’étant pas limité par des problèmes de coûts, de temps ou de ressources, j’ai naturellement choisis la solution du RTOS. Cela permet un développement plus aisé et une évolutivité bien plus facile du code. Concernant le choix du RTOS, je n’ai pas fais de grands comparatifs, j’ai rapidement décidé d’utiliser FreeRTOS, car cela faisait un moment que je voulais voir ce qu’il avait dans le ventre.

Le développement consiste en :

  • Création d’un projet intégrant FreeRTOS
  • Initialisation des périphériques utilisés : USART, GPIO, IRQ, TIMERS,…
  • Machine d’état permettant de gérer correctement les relais en fonction des attentes de l’utilisateur (en effet, il ne faut pas juste ouvrir et fermer le relai, il faut laisser le temps au Raspberry de démarrer, de s’éteindre,…)
  • Protocole de communication entre le module et le RaspberryPi (j’envoie des commandes très simples « emballées » dans un protocole SLIP)
  • Implémentation d’un petit démon en Python sur le RaspberryPi

Et oui! Il est nécessaire aussi d’écrire un petit programme sur le RaspberryPi. Celui-ci envoie un signal au module lors du démarrage du système. Ensuite, il se met en attente d’un message du module lui indiquant qu’il doit effectuer son shutdown. Enfin, il envoie un dernier signal avant l’arrêt complet du système. C’est suite à ce dernier signal que le module sait qu’il peut couper l’alimentation du RaspberryPi.

Des évolutions futures pourraient permettre par exemple au RaspberryPi d’envoyer un signal demandant au contrôlleur d’éteindre et d’allumer l’écran, d’éteindre le système après un certains temps (Sleep), de vérifier que le RaspberryPi fonctionne toujours bien et de le resetter si ce n’est pas le cas (watchdog),…

Le mot de la fin

Si j’avais dû réaliser le même genre de travail dans un projet réel avec des ambitions commerciales, je n’aurais certainement pas fais les choix que j’ai effectué ici. En effet, j’ai toujours choisis l’approche la plus évolutive, la plus complète et la plus facile pour moi. D’un autre côté, dans un projet commercial, j’aurais certainement été entouré d’électroniciens et de mécaniciens pour réaliser un module sur mesure.

D’un autre côté, ce projet me permet de mettre mes connaissances en pratique d’une autre façon que dans ma vie professionnelle, de tout faire à ma façon et à mon propre rythme.

En associant RpiPowerControl avec Touchradio, j’effectue un développement partant du très bas-niveau (quasi-électronique, développement embarqué) jusqu’au très haut niveau (interface utilisateur) en passant par de la programmation système (script d’init sous Linux) et la mise au point d’un protocole de communication simple.

Le code

J’ai encore un peu de travail à effectuer sur le code de RpiPowerControl, tant du côté embarqué, en C, que du côté Python sur le RaspberryPi, mais dès que j’aurai terminé (ce qui prendra un temps indéterminé :D), je publierai tout cela sur ma page GitHub!

Intéressé?

Si vous êtes intéressé par le module, si vous avez des remarques, des questions, n’hésitez pas à poster un commentaire!

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *