Découvrir le Raspberry Pi

Introduction

Attention – section LAN modifiée

Lors du dernier festival de robotique à l’EPLF (https://festivalrobotique.epfl.ch/ ) , comme un leitmotiv résonnait les mots “Raspberry Pi” Ainsi que plusieurs amis du MICROCLUB, nous nous décidons d’acquérir un de ces modules, qui a les caractéristiques suivantes (http://www.raspberrypi.org/ ):

board

  • Prix $35 (avec alimentations, câbles boîtier, carte SD, ça revient à CHF 60.-)

  • Taille du print: carte de crédit, 85.6 x 54 mm (avec boîtier… compter un peu plus!!)

  • Alimentation 5V, via USB, mais 700 mA (3.5 W)

  • CPU ARM à 700 MHz (hackable à 1 Ghz…)

  • Mémoire RAM 512 Mb

  • Mémoire FLASH par SD Card, minimum 2 Go (j’ai mis 8 Go)

  • Graphique : 1920×1200, capable de décoder du MP4 (H264); sorties HDMI et PAL/NTSC

  • Audio: jack 3.5 mm et HDMI

  • LAN: 10/100 MB, RJ45

  • Ports: 3 x USB2

La puissance de cette carte est comparable à celle d’un petit portable. Les systèmes d’exploitation possibles sont aussi nombreux; mais les “tunés” sont un Debian (Raspbian), un Arch Debian et un RISC OS. J’ai choisi le Raspbian.

Lancement

Après avoir téléchargé l’image et initialisé la carte SD par l’excellent tool, le module est connecté sur la TV via le câble HDMI du lecteur DVD. Le chargeur de mobile USB sera l’alimentation; il est plus musclé qu’un port de PC. Sur le site de Raspberry, on y retrouve cette recommandation à de multiples reprises. La plupart des modules prétendus défectueux n’ont pas été alimentés correctement; ou les périphériques ont mis à genoux l’alimentation qui, d’un port de PC, est limitée à 500 mA. J’y adjoint clavier et souris USB. A l’écran de config (qui apparait en mode texte), je choisis d’enclencher le SSH, d’étendre l’espace mémoire “root” sur le restant de la carte SD ainsi que de démarrer le graphique par “startx”. L’utilisateur par défaut et “pi”; on lui donne un mot de passe. Pas trop compliqué, vu que le clavier est resté en “QWERTY”. Okay…

L’interface passe en graphique haute résolution, affiche une belle framboise. La souris est reconnue.

Configurer Raspberry

Tout cela est bien joli; mais je ne peux pas continûment squatter la TV – qui ne me sert d’écran que pour passer des DVD – et laisser trainer ces câbles ainsi. Il me faut une connexion réseau, que je n’ai bien sûr pas dans cette pièce; et une prise à distance du module pour éviter de devoir utiliser un écran. Même si un câble HDMI – DVI est à disposition pour 20.- chez Distrelec, n° 847355. Pris d’une inspiration en voyant l’icône « Wifi config », je tente de connecter sur l’USB libre une antenne Wifi de marque Netopia, venue avec l’ancien modem/routeur de Swisscom. Bingo! Elle est reconnue. Suit l’introduction de la clef WPA, et la liaison est établie. Via le terminal, il est possible de lire l’adresse IP prise en DHCP.

Pour être sûr que la connexion soit fiable, je retire l’antenne de l’USB, puis je la reconnecte. La liaison se rétablit sans autre. Parfait.

Comment configurer le module ? Après quelques recherches sur l’Internet, un site en français répond à plein de questions, avec des exemples pratiques :

http://www.tropfacile.net/doku.php/raspberry-pi/

Dès que le Raspberry est sur le réseau, je peux l’atteindre avec deux outils indispensables via mes PCs Windows:

  • Putty, un terminal SSH

  • WinSCP, un explorateur 2 panneaux à la TotalCommander

Ecran à distance par VNC

Or donc, si je veux éviter de poser un second écran et sa panoplie de câbles sur mon bureau, il me faut atteindre Raspberry via le LAN par mes portables. C’est bien sûr déjà fait en ce qui concerne la console, par Putty via une connexion SSH, ainsi que pour manipuler les fichiers par WinSCP. Ajouter VNC? La manip est décrite ici:

http://reviews.cnet.co.uk/desktops/how-to-make-a-raspberry-pi-solar-powered-ftp-server-50009923/

En fait, je n’ai pas l’intention de le transformer en serveur FTP solaire, quoique… pour afficher automatiquement des images de mon nid en WiFi, l’idée est à creuser. L’auteur précide justement comment installer un serveur TightVNC. Depuis la console (en root, pas besoin du préfixe “sudo”)

sudo apt-get update
sudo apt-get install vnc-server
vncserver

Et là, on indique le password de connexion VNC désiré. Ça devrait déjà fonctionner.

Cependant, si on veut un automatisme au démarrage, il faut ajouter le script suivant dans /etc/init.d :

#!/bin/sh
# /etc/init.d/tightvncserver
# Positionne la variable VNCUSER pour démarrer tightvncserver avec
VNCUSER=’pi’
case “$1” in
start)
su $VNCUSER -c ‘/usr/bin/tightvncserver :1’
echo “Démarre TightVNC server pour $VNCUSER ”
;;
stop)
pkill Xtightvnc
echo “Tightvncserver stoppé”
;;
*)
echo “Usage: /etc/init.d/tightvncserver {start|stop}”
exit 1
;;
esac
exit 0

Afin qu’il soit éxécutable, il faut encore lui changer ses bits ‘x’, soit par WinSCP, soit via la console, par:

sudo chmod 755 /etc/init.d/tightvncserver

Ce n’est pas tout. Si on lance ce script, on peut en effet démarrer et arrêter le service VNC. Afin qu’il soit lancé au démarrage, il faut l’inscrire dans les services à démarrer, par la commande:

update-rc.d tightvncserver defaults

Il reste a vérifier le résultat. La commande de VNC reader, depuis un PC Windows, est un peu originale.

VNC_param

Normalement, on y indique l’IP du poste sur lequel on veut se connecter (ou son nom NetBios s’il est propagé). Ici, il faut aussi préciser l’écran, par le le ‘:1’ après l’adresse:

Si tout se passe bien, on accède à Raspberry. Sinon, vérifier que le service démarre, par la commande “top”.

VNC_view

Adresse LAN fixe (static in english)

Comme je souhaite que le module soit connecté via le câble -ET- qu’il conserve une adresse fixe, car même si le DHCP de mon modem DSL garde la même adresse pour un périphérique donnée, pas sûr que ce soit reproductible sur le long terme. Il distribue les adresses au dessus de 192.168.1. 32. J’ai fixé les adresses de mes imprimantes et du NAS en dessous. L’adresse réservée pour Raspberry, sera la 192.168.1.11.

auto lo

iface lo inet loopback

iface eth0 inet static

address 192.168.1.11

netmask 255.255.255.0

gateway 192.168.1.1

network 192.168.1.0

broadcast 192.168.1.255

allow-hotplug wlan0

iface wlan0 inet manual

wpa-roam /etc/wpa_supplicant/wpa_supplicant.conf

iface default inet dhcp

La solution est d’éditer le fichier /etc/network/interfaces, ce que je fais grâce à WinSCP. Le fichier est complété comme suit, pour l’interface eth0, soit le câble (le Wifi, wlan0, reste en dynamique).

Depuis mai 2015, le Raspian utilise une nouvelle méthode – tous les tuto qui modifient le fichier /etc/network/interface sont obsolètes.La nouvelle config est basée sur dhcpcd.

Il faut travailler sur /etc/dhcpcd.conf:

interface eth0
static ip_address=192.168.1.XX/24
static routers=192.168.1.1
static domain_name_servers=192.168.1.1

Puis je passe au retrait du WiFI, connecte le Raspberry avec un câble réseau au modem/routeur, redémarre le module… Quelques ping et reconfiguration des outils plus tard, c’est tout bon. J’en profite pour retirer le bloc alimentation du mobile; le câble est branché au NAS, qui possède des USB avec alimentation musclée de 1.3 Ampères.

La config est prête, il s’agit de trouver une application. Pour ce faire, le site de Korben propose pas moins de 50 liens sur des solutions à base de Raspberry: http://korben.info/idees-raspberry-pi.html

Yves Masur (5/2013) (Modif LAN static 4/2016)

Arduino: un succès embarqué

Qu’est ce qu’est Arduino?

Une plateforme de développement hard et soft, souple, bon marché, aux sources multiples, facile à mettre en oeuvre, bien documentée, bref l’environnement idéal pour débuter dans le domaine de l’embarqué (embedded in english). Vous désirez utiliser de l’électronique et de la microprogrammation? Piloter un moteur, activer un buzzer? afficher des informations, lire une température, une pression? C’est de prime abord passablement difficile.

Il faut se farcire des datasheet éprouvantes, souvent en anglais. Faire un schéma des composants qui tienne la route. Sortir le fer à souder, picots, circuit imprimé, ou pour le moins câbler (sans se tromper!) des chips et autres composants pas facile à appréhender, poser des connecteurs. Choisir une alimentation.

Ce n’est pas fini: il faut aussi trouver un environnement de développement: en assembleur (pas de chance! On se retappe des liste d’opcodes et on cherche les registres du processeur et leurs multiples finesses) en BASIC ou en C. Puis il faut se documenter comment produire le code exécutable et le charger dans la mémoire de la cible que vous aurez sélectionnée. Avec un peu de chance, on trouve des exemples de code qui résolvent notre problème: mais là encore, il faut adapter, voire fortement modifier le code pour que ce soit compatible avec notre montage.

Arduino standardise tout ça et le rend accessible rapidement: hard, soft, exemples Voyons comment.

La plateforme hardware

Commençons par voir ce qui se fait au point de vue du matériel. La carte processeur est faite autour du microcontrôleur Atmel AVR. La carte de base classique est la Arduino Uno.

Arduino Uno

On en trouve de nombreuses déclinaisons, dont celle mise au point par le Professeur Nicoud, la Diduino (http://didel.com) basée sur le modèle ATmega328, un modèle RISC de 8 bits à 20 MHz (voir: http://www.atmel.com/devices/ATMEGA328.aspx pour les détails). Car c’est possible de fabriquer soi-même une carte compatible Arduino: http://arduino.cc/en/Main/Policy. La carte Diduino possède un bloc d’expérimentation, elle est livrée avec un set de composants pour tester des montages.Diduino

Suivant le but du montage, on peut choisir une autre déclinaison du board CPU: le modèle Mega, Lyli Pad, le Nano, ou le Mini, voir d’autres dérivations de fabricants imaginatifs.

Des extensions, dénommées “shield”, peuvent être rapportées sur la version de base pour y ajouter, Bluetooth, Ethernet, Flash card, commande de moteurs. Bref un joli pannel d’interfaces possibles. Les modules d’origine des différentes versions de l’Arduino sont fabriqués par la société italienne Smart Projects. Mais oui, les concepteurs d’Arduino sont italiens!

L’environnement soft

Installation

L’environnement de développement se charge depuis le site officiel: http://arduino.cc/en/Main/Software. C’est assez lourd: 70 Mb, et une fois décomprimé, c’est 232 Mb. Par contre vous pouvez déplacer le répertoire arduino-1.0 ou bon vous semble, voire sur une clef USB: il se lancera sans problème. Comme il est écrit en Java, il tourne sur les trois OS phares: Windows (32 et 64 bits), Linux, Mac. Il est basé sur Processing et contient le compilateur avr-gcc, ainsi qu’une panoplie de softs Open Source.

Une fois arduino.exe lancé, le développement proprement dit se fait dans des modules appelés “sketch”. Voici à quoi cela ressemble.

Sketch

Sketch

La barre des menus est suivie d’icônes, permettant de faire son développement: valider le code, le charger, créer un nouveau Sketch, charger et enregistrer. Le source, en C/C++ est introduit dans la fenêtre texte. La partie code montre une syntaxe à peine colorée: les mots-clefs reconnus sont en brun. Le Sketch est sauvé dans un répertoire du nom du projet, et le fichier de même nom prend l’extension “.ino”; c’est en fait le fichier source à l’identique, sans fioriture, éditable et copiable p. exemple avec Notepad++.

Une fenêtre inférieure montre le résultat des différentes commandes: ici celui d’une compilation réussie. Des erreurs seraient écrites en rouge.

Les paramètres de transfert sont réglés par le choix de la cible, et le port série à utiliser. Ici: Atmega328 et COM11.

De manière générale, le programme est constitué d’une fonction d’initialisation setup(), et d’une boucle infinie loop(). Elles constituent une surcouche du C qui habituellement appelle le programme principal par la fonction main().

Vous trouverez une introduction pratique plus détaillée sur le site de notre HB9 préféré, Michel Vonlanthen, ici: http://www.von-info.ch/hb9afo/arduino/main.htm

Parmi un foultitude d’exemples de programmation, la base consensuelle et universelle est toujours le clignotement d’une LED, alimentée par une patte de sortie du CPU via une résistance de quelques kilo-Ohms. Le programme consiste à : positionner la sortie à l’état haut, attendre, positionner à l’état bas, attendre, et boucler ad aeternam. Ensuite, on peut compliquer à souhait en testant un bouton, en attendant une valeur, en écrivant sur le port sériel, en pilotant un moteur, etc, etc!

Or l’exemple ci-dessus montre l’utilisation d’une technique fort avancée: l’utilisation de l’interruption. On en discute plus bas.

Chargement et éxécution

Le programme est fait, la cible connue (type de circuit Arduino ATmega328) , il faut maintenant charger le programme. Diduino (et d’autres…) proposent la connexion USB. Celle-ci, non seulement alimente la carte – tant qu’on ne lui ajoute pas de moteurs ou de relais qui demande de la puissance – ouvre une connexion série. Autant sous Windows que Mac, il faut installer le pilote adéquat. La version la plus simple est de laisser Windows “chercher le pilote adéquat”; sinon, il faut le faire à la main. Les pilotes sont dans le répertoire: \arduino-1.0\drivers\. Ou directement du fabricant,  FTDI, a disposition ici: http://www.ftdichip.com/Drivers/VCP.htm.

Un fois la fiche USB connectée, le pilote Windows se montre: Start -> Périphérique et imprimantes -> Non spécifié(e)s

UART

Malgré l’installation réussie du pilote, du paramètre Tools -> Serial Port (et le choix du bon n° de seriel), il se peut que ça ne fonctionne pas. A titre indicatif, sur 2 PC différents j’ai expérimenté:

– Pas de recherche automatique de Windows 7: il m’a fallut indiquer où se situe le pilote sur le bon répertoire, et l’installer. Tout a fonctionné parfaitement

– Recherche automatique: Windows recherche le pilote, l’installe.

Par contre à l’utilisation, des soucis de menu: il met 18 secondes pour se développer! La programmation patine aussi, avec le message sibyllin suivant: avrdude: stk500_getsync(): not in sync: resp=0x00. Un driver corrigé s’adresse à ce problème, ici: http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1237179908. Il appert que la DLL qui scrute les ports série les énumère à tout coup et attend leur time-out… Suite au remplacement de la DLL : rxtxSerial.dll, tout fonctionne bien sur mes deux PCs.

Il faut donc persévérer et rechercher sur le WEB une solution.

La souplesse et l’exemple

La force de l’ensemble Arduino est d’offrir d’une part un matériel défini, puisque même les sources d’autres constructeurs “collent” aux spécifications des originaux; en offrant bien entendu plus de ports, ou un processeur plus puissant. Et d’autre part, un ensemble logiciel préparé et épuré pour programmer la cible. Le choix du C/C++ est à mon avis fort judicieux: ce langage permet de compiler du code très efficace et proche de la machine.

NDA: je suis un peu plus dubitatif avec le C++. Vu la taille mémoire à disposition, on ne voit pas trop comment des instanciations d’objets ou des templates un peu compliquées auraient leur place. Mais comme à l’heure d’écrire ces lignes je n’ai que pratiqué des petits exercices, cela pourrait changer à l’avenir.

Il vaut la peine de se pencher un peu plus sur ce programme d’interruption, pour montrer la souplesse et la puissance d’abstraction des librairies Arduino. Comment est gérée une interruption? Pour répondre à une requête d’interruption, le processeur devra (source Wikipédia) :

  • préserver le contexte d’exécution du programme en cours afin de pouvoir, à terme, en reprendre l’exécution ;
  • lire en mémoire l’emplacement du programme destiné à gérer l’événement particulier (appelé gestionnaire d’interruption ou routine de gestion d’interruption), pré-établi lors de la prise en charge, par l’ordinateur, de l’ensemble spécialisé ici, par la routine start();
  • exécuter la routine, court programme grâce auquel le processeur interagira avec l’ensemble spécialisé qui le sollicite afin de satisfaire ses attentes ;
  • restaurer le contexte d’exécution du programme interrompu ; et enfin
  • continuer à exécuter ce dernier.

On le voit, ce mécanisme est aussi complexe que délicat à mettre en oeuvre. Eh bien, avec Arduino, on initialise l’interruption en une fonction de 3 paramètres: attachInterrupt(0, irq_func, FALLING); . Ceci a pour effet de lier lorsque l’interruption hardware n°0 est déclenchée, d’appeler la routine d’interruption ici réalisée par la fonction “irq_func()”, sur un flanc descendant. Les autres possibilités étant: flanc montant, état haut, état bas. Le fameux flanc descendant est activé lorque la LED rouge s’eteint, car on aura pris soin de relier cette sortie n°13 sur la patte n°2 qui est effectivement l’entrée d’interruption 0.

La fonction d’interruption se contente d’inverser l’état de la LED jaune, ce qui fait qu’elle clignote à une fréquence de moitié de la LED rouge. Avec l’environnement de développement viennent de nombreux exemples didactiques de programmation : \arduino-1.0\examples\, et bien sûr sur le site officiel: http://arduino.cc/en/Tutorial/HomePage.

Les fonctions dédiées et librairies

Il est clair que le C pur ne suffit pas – a vrai dire, le C pur n’existe pas! Ce langage s’applique a quasi tous les CPU, du 8 bit au 64 bits (voir plus?) et un montage 8 bits n’a pas les mêmes possibilités qu’un système multicoeurs. Pour chaque implémentation, il y a des fonctions dédiées qui permettent d’utiliser toutes les finesses du système. Arduino a aussi les siennes, sur le WEB ici: “langage reference“, en local dans /arduino-1.0/reference/index.html.

On y trouve notamment les possibilités de positionner directement et efficacement une patte à 0 ou à 1, de la lire, par respectivement digitalWrite() et digitalRead(). Plus exotique, la fonction qui permet de moduler une largeur d’impulsion (PWM, Pulse Width Modulation) s’appelle analogWrite(), en décalage par rapport à analogRead(), qui fait elle fait une vraie conversion analogique -> numérique (A/D: Analog -> Digital). C’est bien sûr dépendant des possibilités du CPU.
Des librairies sont également à disposition http://arduino.cc/en/Reference/Libraries. Il s’agit des les importer pour pouvoir en utiliser les fonctions. Celles-ci d’adressent à du matériel (EEPROM, LCD, cartes SD) ou des protocoles souvent utilisés (Serie, Ethernet, SPI).

Du hard et du soft, un cours très complet

Le document ci-dessous est une large représentation de réalisations Arduino. Mais constitue aussi un cours complet de mise en oeuvre, qui explore toutes les facettes en partant de l’électronique, de la réalisation pratique avec des maquettes dessins, schémas. En français, s’il vous plaît.
http://fr.flossmanuals.net/_booki/arduino/arduino.pdf

Des fournisseurs

Pour débuter et tester, la carte Diduino, elle est idéale.

Les indications ci-dessous m’ont été communiquées par M. Frédéric Benninger, donc pas (encore) testées personnellement.

Le Seeeduino Starter Kit Standard[Shop.boxtec.ch] vise le même but, mais elle pourra par la suite être réutilisée dans un produit fini. Pour ceux qui visent une application dédiée, cela dépend de la taille du projet et du type d’alimentation envisagée. Par exemple en modélisme le Seeeduino Film est un must, seulement quelques grammes, elle est livrée avec une petite batterie et le régulateur de charge pour panneaux solaires est inclus.

Pour faire une application qui a besoin de gérer une horloge calendaire, par exemple à des fins d’ d’acquisition de données, le Seeeduino Stalker est parfait, il intègre une RTC et un emplacement pour carte micro SD.

Voici encore des châssis [www.sparkfun.com] pour les bricoleurs, sans oublier des boîtes [shop.boxtec.ch] pour mettre en valeur le fruit du travail fourni.

Des références

LE site de référence: Arduino.cc

Documentation Arduino/Diduino très complète+exercices ici: http://www.didel.com/diduino/Liens.pdf

Wikipédia: http://fr.wikipedia.org/wiki/Arduino

Liste de discussion (Suisse) : http://fr.groups.yahoo.com/group/arduino_suisse/