RaspberryPi à tout faire…

Un titre un peu fourre tout car en effet le sujet est vaste…Cet article présente les bases de l’installation d’un RaspberryPi et sa configuration de base. Puis nous allons tester les différentes possibilités d’E/S SANS programmation : E/S TOR (GPIO), bus 1Wire, bus I2C, voie série,bus SPI. Puis nous passerons à la programmation en langage C à l’aide de la bibliothèque WiringPi de Gordon Henderson. Enfin nous terminerons par la création d’une page web qui dialoguera avec ces différents bus grâce à un script CGI. Bref que du bon…

Installation et configuration du RaspberryPI

Dans ce qui suit vous allez configurer votre raspberry pour une utilisation « de base » sur un réseau avec des adresses IP fixes. Mais avant tout quelques ressources (anglaises ou françaises) sur Internet.

Collection de liens

Création de la carte SD

Téléchargez sur le site de la fondation Raspberry l’image de la distribution Raspian ainsi que l’utilitaire de création de carte SD Win32Imager. Sous Microsoft Windows, lancez Win32Imager pour créer votre carte SD (mini 4Go). Patientez…votre carte est prête. Lorsque vous démarrerez avec cette carte votre raspberry, vous obtiendrez une distribution « debian » adapté à votre carte ARM. La fondation vous propose aussi une image « New Out Of the Box Software » qui permet de tester les différentes distributions disponibles pour le raspberry. Pour installer cette image, téléchargez-là, formatez votre carte SD de 4Go avec l’utilitaire SDFormat puis désarchivez les fichiers de l’image directement sur cette carte. Connectez les cables nécessaires sur le raspberry (clavier et souris USB, cable hdmi vers écran), insérez la carte SD raspian et enfin connectez l’alimentation. Vous devriez voir les messages de démarrage du noyau Linux à l’écran. Comme nous allons en parler tout le temps, j’insère ici un exemple de brochage des connecteurs du RaspberryPi (il en existe des tas sur internet, faites donc une recherche avec google image et les mots clés GPIO RaspberryPi): Nom et numero des broches du RaspberryPi Si vous ne disposez pas de tout cela, vous pouvez travailler sur votre raspberry ! Il vous faudra un simple convertisseur USB-Série TTL comme on en trouve des dizaines sur e-bay (ici par exemple : 1,5€ frais de port compris!!). Il suffit de connecter la masse, RX et TX du convertisseur vers la masse (P1.6), la broche TX (P1.8) et la broche RX (P1.10) du raspberry. La connexion s’effectue en 115200 8N1. Vous pouvez utiliser le logiciel Putty sous Windows ou minicom sous Linux.

Première configuration du RaspberryPi

Quelque soit la méthode choisie, vous devez maintenant vous identifier: utilisateur (login) : pi, mot de passe: raspberry. La première chose à faire est de finir la configuration du raspberry. Pour cela tapez la commande suivante après l’invite de commande :

La commande ‘sudo’ permet d’exécuter la commande qui la suit avec les droits administrateur (root sous Linux). Vous obtenez le menu suivant :

  • 1- Expand Filesystem : utiliser la totalité de la carte SD
  • 2 – Change User Password : changer le mot de passe de l’utilisateur PI
  • 3 – Enable boot to Desktop : démarrer en mode texte ou en mode graphique
  • 4 – Internationalisation Options : choix des options d’internationalisation
  • 4.1 – Change Locale : choix de la langue du SE : ici francais (Fr_fr UTF8)
  • 4.2 – Change Timezone : pour appliquer le bon fuseau horaire (Europe/Paris)
  • 4.3 – Change Keyboard Layout : le clavier francais sera automatiquement choisi si les deux dernières options ont été configurées
  • 5 – Enable Camera : activation des pilotes de la camera du raspberry
  • 6 – Add to Rastrack : enregistrement de votre raspberry en ligne
  • 7 – Overclock : au choix différentes options pour « booster » votre raspberry de « pas du tout » à « ne pas toucher le Soc (brulures) »
  • 8 – Advanced Options : options avancées
  • 8.1 – Overscan : a tester si vous avez des bandes noires autour de l’écran
  • 8.2 – Hostname : changer le nom de votre raspberry (si vous en avez plusieurs)
  • 8.3 – Memory Split : partage de la mémoire entre le processeur et la carte graphique
  • 8.4 – SSH : permet de se connecter à distance et/ou de copier des fichiers à distance (application putty et winSCP sous Windows)
  • 8.5 – Update : mise à jour de l’utilitaire raspi-config
  • 9 – About Raspi-config : A propos…

Parcourez les différents menus pour finaliser l’installation du raspberry. Redémarrez si c’est nécessaire. La commande pour redémarrer est ‘reboot’ et pour éteindre proprement le raspberry ‘poweroff’ (la del verte prêt du connecteur audio clignotera rapidement lorsque le système peut être débranché). Vous pouvez maintenant lire ‘le guide du débutant sous GNU/Linux’ disponible en fin d’article au format OpenOffice.org ou au format PDF. Parmi les différentes commandes présentées dans ce document, il faudra connaitre en particulier la commande ‘aptitude’ qui permet d’installer/désinstaller/rechercher des logiciels. Bonne lecture… Déjà de retour 😉 ! Pour rassurer les plus septiques de la ligne de commande, lancez votre environnement graphique avec la commande ‘startx’ à moins que vous n’ayez décidé de démarrer directement en mode graphique (commande raspi-config). Lancez un terminal (une console) pour retrouver une ligne de commande. A titre d’exercice installez le logiciel ‘synaptic’ : logiciel graphique de recherche/suppression/installation de logiciels. Lancez-le puis installez par son biais le logiciel ‘Geany’ : environnement de développement intégré qui va nous servir dans quelques lignes pour compiler nos premiers exemples en langage C. Notez bien que l’on peut faire tout ce qui précède en ligne de commande sans environnement graphique !

Configuration réseau du RaspberryPi

Par défaut, le raspberry cherche un serveur DHCP sur le réseau auquel il est connecté. Si ce serveur existe, aucun problème la pile réseau du raspberry sera correctement configurée. Cependant vous pouvez avoir besoin de figer cette configuration pour pouvoir intégrer votre raspberry dans votre réseau (établissement scolaire ou entreprise). Pour cela il faut éditer (avec nano par exemple) et modifier le fichier ‘/etc/network/interfaces’ pour qu’il ressemble à celui donné ci-dessous en adaptant bien sur les paramètres IP (lignes address, netmask, gateway, dns-nameservers de la section iface eth0). Les lignes qui commencent par ‘#’ sont des commentaires ou les lignes de la configuration d’origine :

La configuration du DNS sera automatique grâce à la ligne dns-nameservers. Mais il faut auparavant installer le paquetage resolvconf puis redémarrer :

Pour tester votre configuration réseau, faites donc un ‘ping’ vers les serveurs de google…

Découverte des différents bus de communication SANS programmation

Dans un premier temps vous allez découvrir les GPIO, le bus I2C, le bus SPI, la voie série sans programmation. Cela permet de valider les parties « matériels » d’un montage AVANT de passer au « logiciel.

Les E/S Tout Ou Rien (ES TOR) ou GPIO (General Purpose Input Output)

J’ai déjà un article sur ce thème, même s’il ne s’agit pas de la même carte, le principe de base s’applique sur le raspberry (en fait sur toutes les cartes GNU/Linux embarqué récentes et correctement supporté par le noyau). En résumé, il faut:

  1. informer le noyau Linux que l’on souhaite ‘exporter’ une broche
  2. configurer celle-ci en entrée ou en sortie
  3. lire ou écrire sur celle-ci

Connectez par exemple la DEL rouge du shield de test à la broche  GPIO4 (P1.7) et le bouton poussoir associé à celle-ci à la broche GPIO17 (P1.11)  ainsi que la masse des cartes puis tapez les commandes suivantes en étant ‘root’ (commande sudo su):

Maintenant suivant si vous voulez mettre cette broche en entrée ou en sortie il faut tapez une des lignes suivantes:

Enfin pour lire (appuyez sur le BP) ou écrire sur cette broche (éteindre allumer la del) :

Le bus One-Wire

Ce bus est très souvent utilisé avec des capteurs de températures (type DS18B20) mais sachez qu’il existe de nombreux pilotes sous Linux pour d’autres périphériques. Le raspberry ne possède pas de pilote matériel onewire, en conséquence c’est le pilotage d’une broche TOR qui permet de dialoguer sur ce bus. Par défaut, lors de la compilation du noyau Linux, la broche affecté au bus onewire est la GPIO4 (P1.7). Si vous l’avez utilisé pour faire des manipulations en tout-ou-rien, il faut tout d’abord la « dé-exporter », c’est à dire la libérer pour que le noyau puisse installer son pilote 1-wire sur cette broche. Pour libérer une broche GPIO, il faut taper une commande du style:

A partir de ce moment, vous pouvez charger les pilotes noyau pour la gestion du bus 1-wire et des capteurs de températures:

Pour savoir quels sont les autres pilotes disponibles pour le bus 1-wire, tapez:

Connectez des DS18B20 au bus 1-wire (platine fournie) puis testez s’ils sont reconnus avec la commande suivante:

Dans le cas précédent, deux capteurs de températures ont été trouvé. Pour lire la température, il faut taper une commande du style (en adaptant le numéro de série du capteur) :

La température est ici de 24,25°C. Le bus 1-wire est donc validé. Passons au bus i2c.

Le bus I2C

Ce bus est déjà décrit dans un article de ce site. Vous pouvez réaliser des tests avec la platine qui possède l’horloge RTC DS3231 et un capteur de température DS1621/DS1631. MAIS vous pouvez aussi tester une platine qui possède un CAN (MCP3221) et un CNA (MCP4726) sur bus I2C. Cette platine est intéressante dans le sens ou le raspberry n’a pas de CAN intégré et une seule sortie MLI (PWM).

carte-can-cna-i2c carte-can-cna-i2c_routage

Je vous encourage donc à générer une tension sur le CNA et à relire celle-ci avec le CAN à l’aide des commandes i2cget et i2cread.

La voie série

La voie série matériel est déjà utilisée par le noyau pour proposer un « login » par cette même voie série. Si vous désirez utiliser cette vois série dans vos montages, il faut tout d’abord la « libérer » du noyau. Pour cela, il faut modifier la ligne de commande passer au noyau au démarrage. Vous pouvez l’éditer en tapant la commande suivante en remplaçant ‘cat’ par ‘nano’ :

Il faut supprimer ‘console=ttyAMA0,115200’ puis sauver ce fichier. De plus, il faut commenter la ligne ‘ T0:23:respawn:/sbin/getty -L ttyAMA0 115200 vt100’ à la fin du fichier /etc/inittab. Si vous redémarrez votre raspberry, il vous faut absolument :

  • soit un écran/clavier pour vous connecter,
  • soit vous connectez à distance par ssh (serveur ssh activé sur le raspberry, adresse IP du raspberry connu, logiciel putty coté Windows).

Comme vous l’avez sans doute remarqué, la voie série porte le nom ttyAMA0. Cette voie série est disponible dans le répertoire devices (périphériques en anglais, aussi appelé ‘/dev’ dans l’arborescence Linux). Il nous faut aussi régler la vitesse de transmission et le nombre de bit de données, de parité et de stop. La commande qui permet de régler ces paramètres est ‘stty’. Par exemple, pour lister les paramètres actuels de la voie série, il faut taper la commande suivante:

Parmi tous ces paramètres la vitesse nous intéresse (ici speed 9600), le nombre de bit de donnée (cs8 : 8 bit de données) et la parité (ici aucune car on a -parenb -parodd : – = absence, par = parité, enb = even = paire, odd = impaire). Donc si l’on veut dialoguer avec un périphérique (par exemple le PC) à 115200 bits/s, il faudra tapez une commande du style:

Vous pouvez alors envoyer sur la voie série, une chaine de caractères avec la commande de la première ligne ou alors recevoir des caractères avec la commande de la seconde ligne :

Conclusion : la voie série matériel du raspberry est fonctionnelle pour vos programmes personnels. Donc si votre application ne fonctionne pas, ce sera un problème du coté logiciel et pas matériel !

Le bus SPI

Je n’ai pas trouvé d’applications précompilé pour tester ce bus. Une des meilleures sources d’information est sans doute les sources du noyau Linux et en particulier ce code. Vous pouvez cependant envoyer des caractères vers le bus SPI del manière suivante :

Notez cependant qu’un caractère LineFeed est ajouté derrière le caractère.

Les servomoteurs

Un pilote noyau pour le pilotage de 8 servomoteurs existe. Celui-ci est disponible sur ce site. Téléchargez et copiez le module noyau « servoblaster.ko » sur votre carte SD. Il faut ensuite le charger en mémoire (commande insmod) puis créer son point d’entrée dans les périphériques (commande mknod, ici le chiffre important est 248) :

On remarque ci-dessus que les 8 servomoteurs sont à l’arrêt (=0). En passant, le brochage associé à ces huits servomoteurs:

Je relie la masse et la sortie servomoteur 0 (GPIO 4) sur un oscilloscope. Pour fixer la durée de l’impulsion à 2ms sur la sortie servomoteur 0, il faut taper la commande suivante que vous pouvez ensuite vérifiez avec la seconde commande:

On obtient les signaux suivants :
capture-servoblaster-2ms capture-servoblaster-periode-20ms
La génération de ces signaux est très précise (utilisation de la méthode DMA : Direct Memory Access), même en cas de charge système (ne pas oublier que nous travaillons sur un système multitâche qui dans ce cas n’est pas configuré pour le temps réel).
Pour désinstaller le pilote servoblaster, tapez la commande suivante:

Après avoir testé les différents bus et E/S sans programmation, nous allons passer à la programmation en langage C avec l’aide de la bibliothèque WiringPi.

Programmation en langage C des E/S et des bus du RaspberryPi

La librairie qui permet un accès rapide aux fonctionnalités du Raspberry est sans aucun doute la librairie WiringPi. Il faut donc se rendre de toute urgence sur le site de celle-ci… En résumé, cette bibliothèque de fonctions vous permet de :

  • gérer les E/S (GPIO),
  • gérer le bus I2C,
  • gérer le bus SPI,
  • gérer une sortie en mode PWM matériel,
  • gérer n’importe quelle sortie en mode PWM logiciel,
  • gérer les échanges sur la voie série,
  • gérer les cartes PiFace, GertBoard, des afficheurs LCD compatible HD44780,
  • etc… (découvrez le site par vous même…)

Installation de la librairie WiringPi

Il faut tout d’abord télécharger et installez cette librairie. Les étapes sont données sur cette page. Si l’installation par clonage du dépôt git (commande ‘git clone’) ne fonctionne pas dans votre lieu de travail (parefeu) il faut télécharger une archive de la bibliothèque (retrouver dans le texte le « Plan B »).

Une fois que la bibliothèque est compilée et installée, testez les commandes suivantes :

Des exemples de code C utilisant la librairie WiringPi sont donnés dans le répertoire ‘examples’ et seront consultés avec profit. Le répertoire ‘devLib’ propose des pilotes pour des périphériques évolués (afficheur LCD alphanumérique et graphique, cartes PiFace et GertBoard, etc…). L’utilitaire ‘gpio’ est décrit sur cette page.
Pour réaliser notre premier programme vous avez deux possibilités :
  • soit tout faire en ligne de commande dans une console (fonctionne même à distance depuis un PC),
  • soit saisir votre code, le compiler et l’exécuter depuis un EDI (Environnement de Développement Intégré) : par exemple Geany que vous avez installé au début de l’article.

Pour le premier test, je vais décrire les deux solutions.

Premier test de la librairie WiringPi : faire clignoter une DEL

C’est le grand classique habituel, utilisez le shield arduino fourni pour avoir une DEL… Si vous êtes en ligne de commande, tapez le code suivant à l’aide de l’éditeur nano. Si vous êtes en mode graphique, lancez Geany puis saisissez le même code. Dans les deux cas, pensez à sauvegarder ce code sous le nom ‘clignot_del.c’.

Il faut maintenant compiler ce code source. En ligne de commande, la ligne à taper est :

Si tout se passe bien, la DEL doit clignoter ! On indique sur la ligne de compilation la librairie utilisée (-lwiringPi). La commande ‘file’ permet de savoir à quel type d’exécutable vous avez à faire (ici un binaire pour ARM qui utilise des librairies partagées (dynamically) et qui contient encore les symboles de débuggage (not stripped)). On peut diminuer la taille du binaire en tapant la commande suivante:

Si vous utilisez Geany, il faut configurer les options de compilation. Celle-ci sont accésibles par (ToDo). Pour compiler, cliquez sur l’icône (ToDo). Lancez votre binaire dans une console.

Deuxième test : Lire l’état d’une broche et la MLI matériel

La sortie MLI matériel est disponible sur une broche seulement du raspberry (GPIO18). Le code suivant permet de régler le rapport cyclique de la MLI à l’aide de deux boutons. On utilise toujours le shield arduino pour réaliser les tests. Les boutons poussoirs ont une résistance de rappel au + donc on a un niveau logique bas lorsqu’on appuie sur eux. La sortie MLI est visualisée sur une DEL. Le code source de l’application est le suivant:

L’explication des fonctions spéciales au RaspberryPi se trouvent sur cette page.

Troisième test : la MLI logiciel

Quasiment dans le même registre, la mise en oeuvre de la MLI logiciel sur une DEL RGB. Les fonctions logicielles sur la MLI sont décrites sur cette page :

Vous remarquerez que j’ai inclus le fichier « math.h » pour avoir la fonction ‘sin’. De plus, si vous utilisez les sorties logicielles MLI, la documentation indique qu’elles utilisent les « thread » de Linux. Donc la ligne de compilation pour cet exemple évolue légèrement:

Vous devez donc rajouter les librairies mathématiques ( -lm ) et des processus légers ( -lpthread ). Cablez les GPIO 22, 23 et 24 sur la DEL RGB disponible sur le shield et lancez votre programme. Pendant l’exécution de ce programme, la fréquence mesurée sur une des GPIO est de 100Hz et l’occupation processeur pour la génération des trois MLI logicielles est de 1,5% ( utilisez la commande ‘top’).

Quatrième test – Le bus I2C – Capteur de temp. DS1621

Remarque:  Le DS1621 fonctionne avec une tension d’alimentation de 5V. Celle-ci est fourni par la broche P1.2. Cependant cela ne pose pas de problème sur le bus i2c car les résistances de rappel au +3,3V de ce même bus sont câblées sur le raspberry et que les sorties des esclaves i2c sont à collecteur ouvert.

Avez-vous bien lu l’article sur l’utilisation du bus I2C sur ce même site. Il faut en effet s’assurer que les modules i2c_bcm2708 et i2c_dev sont bien gérés par le noyau (vérifiez-le avec la commande ‘lsmod’). Si les modules sont correctement chargés, testez s’il y a des esclaves connectés sur votre bus I2C avec la commande ‘i2cdetect -y 1’. Par exemple, j’ai un capteur de température DS1621 à l’adresse 0x48 dans la capture suivante :

Je ne détaillerai pas ici la séquence d’initialisation du DS1621, ni la lecture de la température (cependant cette documentation peut vous faire gagner du temps !). Lisez le code C ci-dessous pour cela:

Ci-dessous la ligne pour compiler cet exemple et un exemple se son exécution :

Remarquez que le résultat de la température est retourné dans l’ordre LSB,MSB. De plus je ne tiens pas compte que le bit de poids fort du LSB est à 1 dans le résultat (on devrait rajouter +0,5°C).

Cinquième test – Bus I2C – CAN et CNA

Il faut cabler la petite plaque qui supporte ces deux convertisseurs. Attention la tension d’alimentation est ici de 3,3V (broche P1.1). On commence par une recherche sur le bus i2c avec la commande i2c_detect :

En lisant les documentations des convertisseurs ( CAN:MCP3221, CNA:MCP4726 ) on trouve que l’adresse 0x4D correspond au CAN MCP3221 (voir doc page 16) et l’adresse 0x60 au CNA MCP4726 (voir doc page 46).

Dans le code qui suit, on utilisera qu’une seule fonction du CNA : Write volatile DAC register (voir p49 et 50) et une fonction du CAN : Executing a conversion ( voir p16) :

On peut ensuite le compiler et l’exécuter :

Les résultats concordent. Nos convertisseurs fonctionnent correctement.

Sixième test – le bus SPI

Pour tester le bus SPI, je dispose d’une platine comme décrite dans cette article (partie bus SPI). Il faut donc cabler :

  • l’alimentation en +3,3V et la masse,
  • le signal LE (Latch Enable) : nous prendrons la sortie GPIO 4 pour cela,
  • les signaux MOSI et SCLK,
  • le signal OE (output enable) sera cablé à la masse pour que les dels soient toujours activées.

En tant qu’exemple on va juste faire « tourner » un ensemble de deux dels (premier exemple réalisé avec LIFA). Le code source est donc le suivant :

Rien de très spécial à dire sur ce code. J’ai vérifié à l’oscilloscope la fréquence SCLK est bien de 500KHz. Le signal SPI CE0 ( GPIO 8 ) passe bien à zéro lorsqu’on écrit sur cette interface. Il peut donc être utilisé pour piloter une broche CS (Chip Select) si le besoin s’en fait sentir. La documentation du bus SPI est disponible sur cette page. Bien retenir que le tableau que vous passez pour l’émission est aussi celui du stockage des données reçues. C’est pour cette raison que dans le code il y a deux tableaux différents !

La compilation se fait toujours de la même manière :

Conclusion: le bus SPI est très vraisemblablement la solution si vous devez communiquer rapidement avec un périphérique (par exemple un CAN ou CNA rapide). Rappel, pour modifier la vitesse du bus SPI, modifiez la valeur dans la fonction wiringPiSPISetup.

Logiquement il reste la partie sur la communication avec la voie série. Mais il y a plusieurs exemples dans le répertoire « examples » et les fonctions ressemblent à celles d’arduino. Donc pour l’instant je fais l’impasse.

Nous allons passer à l’interaction entre tout ce que l’on vient de voir et un serveur web à travers des scripts CGI.

Commandes des E/S ou des différents bus à travers une interface web

La première chose à faire et d’installer un serveur web. Il en existe de multiples sous Linux, le plus connu étant Apache. Cependant on souhaite économiser un peu les ressources du raspberry. Pour cela on va s’orienter vers un serveur web plus léger mais qui propose une interface avec les scripts CGI. Nous pouvons citer lighttpd, boa, nanohttpd, etc…

L’heureux serveur http est…apache2

J’ai eu un problème avec les scripts CGI sur lighttpd que je n’ai pu résoudre pour l’instant, aussi je passe à apache2. Vous allez tout simplement l’installer avec la commande suivante:

Ensuite connectez-vous sur votre serveur web tout beau, tout neuf depuis un navigateur (local ou distant). Vous verrez alors qu’il reste quelques petites étapes de configuration avant qu’il corresponde à nos attentes. Les modifications à faire sont les suivantes:

  • vos pages web doivent être sous le répertoire /var/www/
  • les scripts CGI doivent être sous /usr/lib/cgi-bin/

On va tester un petit script codé en C. Une description théorique des scripts CGI est disponible sur Wikipédia.

Premier script CGI codé en langage C

Un script CGI est lancé par le serveur web (ici apache2) et tout ce qui est « imprimé » par la fonction printf est redirigé vers le serveur web qui renvoie le tout vers le client. Vous pouvez aussi consulter cet article ou encore celui-ci. Dans ce premier exemple, on va basculer l’état d’une sortie TOR à chaque fois que l’on lance le script.

Le code C de ce script CGI est le suivant:

Quelques commentaires :

  • on utilise la GPIO4 en sortie pour commander une del par exemple,
  • la ligne printf(« Content… est très importante car elle indique à votre navigateur ce qu’il va recevoir comme données. Ici ce sera une page html. Les -deux- retours chariots ( n ) doivent être IMPÉRATIVEMENT présent car ils indiquent le commencement des données. C’est une source de problème très répandu sur les forums.
  • ensuite on commence la structure d’une page web classique,
  • on teste l’état de la broche 4 (oui oui on relie l’état de cette broche même si elle est en sortie) et en fonction de son niveau logique,
  • on passe à l’état complémentaire et on en informe l’utilisateur final.

Cet exemple est compilé avec la ligne ci-dessous. Par contre il faut que cet exécutable est le bit setuid de positionner : ce bit permet d’exécuter le programme concerné avec les droits du créateur du fichier et pas celui qui le lance. En clair, c’est le serveur apache qui va lancer votre exécutable et il tourne avec l’identité ‘www-data’. Or pour modifier l’état d’une broche il faut avoir des droits ‘root’ ! Ce n’est pas une « bonne pratique » car si votre programme a des « bugs », ils peuvent être exploités pour obtenir l’identité ‘root’ sur votre raspberry. Dans notre cas, on va dire que l’on a rien à cacher et à protéger 😉

Enfin on finit par déplacer cet exécutable dans le répertoire /usr/lib/cgi-bin car c’est le seul endroit ou le serveur web apache à le droit d’exécuter des scripts CGI (dans sa configuration de base sur Debian). Les commandes sont donc les suivantes :

Connectez-vous alors à l’adresse de votre raspberry depuis un navigateur (Ex: http://addr_ip_raspberry/cgi-bin/cde_del.cgi). Si vous avez connecté une del sur la broche concerné elle changera d’état à chaque accès:

capture-commande-gpio-navigateur-etat-bas capture-commande-gpio-navigateur-etat-haut

Premier script CGI (bis)

On va s’intéresser de nouveau au capteur de température 1wire mais en accédant au système de fichiers virtuels comme dans la première partie de l’article. Saisissez le code C ci-dessous:

Ce programme récupère le contenu du fichier qui donne la température depuis un capteur 1wire puis la renvoie vers le client à travers le serveur apache. C’est en gros ce que vous faisiez au début de l’article en ligne de commande. Compilez ce programme, changez ces droits d’exécution puis copiez-le dans le répertoire des scripts CGI:

Connectez-vous alors à l’adresse suivante depuis un navigateur : http://addr_ip_raspberry/cgi-bin/temp_1w.cgi

Et voilà… ce principe est alors reproductible avec quasiment toutes les commandes que l’on a vu en début d’article…

Deuxième exemple de script CGI : un bouton, deux boutons…un formulaire

On va égayer un peu notre page avec des boutons « ON » et « OFF » pour commander notre GPIO à distance. Pour cela, il faut créer un formulaire HTML (ne pas hésiter maintenant à utiliser des balises html5 : pour l’instant navigateur compatible : chrome et firefox). L’utilisation d’un formulaire est décrite sur cette page ou sur celle-ci. On crée donc notre page html pure comme suit :


On sauvegarde cette page sous le nom ‘cde_del.html’ et on la copie dans le répertoire des pages web géré par apache, à savoir /var/www.

On utilise une méthode POST pour passer les données du formulaire, donc on va récupérer la longueur de la chaine d’arguments du formulaire dans une variable d’environnement nommée CONTENT_LENGTH et son contenu depuis l’entrée standard (stdin). Pour traiter ce formulaire le code C suivant est proposé :

Connectez-vous sur la page : http://addr_ip_raspberry/cde_del.html puis cliquez sur un des boutons ON ou OFF. On passe alors à la page de traitement de ce formulaire. Vous remarquerez que les données du formulaires sont passées sous la forme clé=valeur (ici GPIO4=ON ou GPIO=OFF).

capture-commande-gpio-navigateur-boutons capture-commande-gpio-navigateur-boutons-on capture-commande-gpio-navigateur-boutons-off

Un exemple complet…enfin par rapport à notre cahier des charges initiales !

A venir 🙂

commandes-unix
Titre: commandes-unix (801 clics)
Légende:
Nom du fichier: commandes-unix.pdf
Taille: 112 KB

5 réflexions au sujet de « RaspberryPi à tout faire… »

  1. lolo406

    Bonjour,
    Bravo pour ce très bon tutoriel.
    J’ai un compteur (base DS2423, hobby-boards) en 1-wire. J’ai effectué la manip que vous décrivez et j’ai 2 problèmes :
    – la ligne modprobe w1_therm, je la fait avec w1_ds2423 et j’obtiens « Operation non permitted »; je la résout en faisant sudo.
    – suite à ça lorsque je liste les capteurs avec « ls /sys/bus/w1/devices/ » je ne trouve pas mon compteur.

    Auriez vous une idée pour solutionner?
    Merci.

  2. Sebastien

    Salut,
    Merci pour ton tuto très complet !!
    Je rencontre un problème concernant l’affichage d’une image dans un cgi, voilà j’ai repris ton code « GPIO4 maintenant a l’etat haut ! » et « GPIO4 maintenant a l’etat bas ! » qui change de couleur, mais je voudrais mettre une image du genre un voyant vert ou rouge à la place du texte mais ça ne fonctionne pas :
    printf(« Content-Type: text/html;\n\n »);
    printf(« Commande du relais »);
    if (digitalRead(RELAY) == ON)
    {
    digitalWrite(RELAY, OFF);
    printf(« Le relais est active ! »);
    printf(«  »);
    }
    else
    {
    digitalWrite(RELAY, ON);
    printf(« Le relais est desactive ! »);
    printf(«  »);
    }
    printf(«  »);

    Merci d’avance pour ton aide !

  3. Z3ro0ne

    Salut pour ton problème c’est tout simplement tu va changer ce qui entre print comme ca
    printf(«  »)
    ou
    printf(«  ») si tu veu appler une image sur internet selon ton bosoin

    j’ai ajouter la height et width pour maîtrisé la taile d’image

    donc ton il va rassembler a ca
    #include
    #include

    int main(void)
    {
    wiringPiSetupGpio();
    pinMode(4, OUTPUT);

    printf(« Content-type: text/html\n\n »);
    printf(« Commande d’une DEL »);
    if (digitalRead(4) == 0) {
    digitalWrite(4, HIGH);
    printf(«  »);
    } else {
    digitalWrite(4, LOW);
    printf(«  »);
    }
    printf(«  »);
    return 0;
    }

    @Sebastien

  4. Faraday

    bonjour,

    Bravo pour ce tuto très complet.
    J’ai remarqué qu’à partir du troisième test de la programmation en C, il manque les librairies inclues.
    Les lignes ne contiennent que « #include ».

    Merci encore pour ce très bon travail.

Laisser un commentaire

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