M4101

DUT InformatiqueInformatique avancée

Nano ordinateur

©Université de LorraineResponsable du module : E. NatafIntervenants : J.-F. Mari, E. Natafreleased November 14, 2018

Contents

Contents 3

1 Installation et configuration 51.1 Liste du matériel nécessaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51.2 Procédure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51.3 Accès réseau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61.4 Accès SSH . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81.5 Évaluation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

2 Serveur WEB 112.1 Installer et configurer un serveur Web . . . . . . . . . . . . . . . . . . . . . . . . . . . 112.2 Configuration initiale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112.3 Création d’un script CGI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112.4 Sécurité du serveur Web . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132.5 Évaluation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

3 Programmation du PiFace 173.1 Mise en place . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173.2 Programmation en C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183.3 Programmation en Java du PiFace . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203.4 Évaluation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

4 Services réseaux 214.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214.2 DNS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224.3 DHCP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 234.4 NFS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244.5 Évaluation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

5 Programmation du GPIO 275.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275.2 Montage électronique de la platine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275.3 Programmation via le système de gestion de fichier . . . . . . . . . . . . . . . . . . . . 295.4 Accéder directement au GPIO en C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

6 Serveur Web et PiFace - Java 356.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 356.2 Architecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36

3

7 Serveur Web et PiFace - C 397.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 397.2 Architecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 397.3 Ressources . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 407.4 Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40

4

1Installation et configuration

1.1 Liste du matériel nécessaire

• un câble de connexion vidéo HDMI;

• 1 raspberry Pi et sa boîte;

• 1 clavier et 1 souris;

• 1 alimentation électrique;

• 1 lecteur de carte et 1 carte micro SD.

1.2 Procédure

• Créer un sous répertoire dans /tmp, appelé noobs

• Récupérer le fichier NOOBS (version2_4_5) sur ~/pot/ et décompresser le sur le PC dans lerépertoire /tmp/noobs. Déplacer le fichier zip dans /tmp, il n’est plus utile (ne pas le sup-primer, au cas où on doive recommencer).

• Insérer la carte dans le lecteur et le lecteur dans une prise USB.

• Avec l’utilitaire disques (Menu Activités, rechercher : disques) sélectionner la carte SD, puis :

1. S’il n’y a qu’une partition déjà formatée, allez directement au point 5, sinon :

2. Supprimer toutes les partitions si elles existent (bouton “-”).

3. Créer une partition (bouton “+”, laisser les valeurs par défaut).

4. Formater la carte (bouton avec des engrenages, là aussi laisser les choix par défaut).

5. Monter le système de fichier (bouton play à gauche)

La clé est maintenant dans le répertoire /media/login/XXXXX, où login est votre nomd’utilisateur et XXXXX un identifiant dépendant de la clé.

5

1.3: Accès réseau M401C

• Copier le contenu de l’archive sur la carte micro SD que vous avez préalablement insérée dans lelecteur. C’est long !cd /tmp/noobscp -r * /media/login/XXXXX (mon dieu, que c’est long !)

• démonter la carte depuis l’utilitaire disque;

• Insérer la carte dans le raspberry.

• Connecter raspberry / clavier / souris / écran par le câble HDMI.

1. Utiliser le menu de l’écran (boutons sur le bas) pour sélectionner l’entrée DVI

• Brancher l’alimentation et attendre l’écran d’installation

1. Sélectionner la langue (en bas)

2. Sélectionner Raspbian et Install

3. L’installation commence (compter 1 heure environ)

4. A la fin, le Raspberry démarre sur une session graphique

5. Pour éviter cette interface qui est lente, choisir dans le menu : Préférences puis Rapsberry Piconfiguration. Dans l’onglet système affiché par défaut, changer l’option de Boot en CLI(Command Line Interface).

6. Ouvrir un terminal (bouton en haut) et vérifier que le clavier est bien en AZERTY. Sinon,Menu Préférences, puis CLavier et Souris. Y changer le Keyboard Layout pour choisir unclavier français (le premier).

7. Redémarrer le Raspberry. Le système n’a que l’utilisateur pi, du groupe pi (il appar-tient aussi à plusieurs autres groupes, voir la commande groups), avec le mot de passeraspberry.

8. Une fois reconnecté, taper la commande sudo raspi-config, un menu de configura-tion apparaît.

a) Choisir : Interfacing Options puis P2 SSH pour autoriser les connexions SSH;

b) Choisir le fuseau horaire (Localisation Options et I2 Change Timezone)afin que le Raspberry soit à l’heure.

1.3 Accès réseau

Principe

Les raspberry peuvent utiliser le réseau de l’IUT en se connectant avec le protocole 802.1X qui nécessiteune authentification. En effet, les comptes utilisateurs crées sur les raspberry ne sont pas connus par leréseau et la sécurité impose que tout utilisateur qui utilise le réseau soit authentifié. Le nom d’utilisateuret le mot de passe doivent être les mêmes que ceux qui permettent de se connecter sur les machines del’IUT.

6

M401C 1.4: Accès SSH

Les salles machines où se déroulent les TD sont spécifiquement câblées pour accepter des connexionsréseaux authentifiées en 802.1X. C’est dans ces salles uniquement que l’on pourra connecter les rasp-berry et chaque raspberry devra avoir le nom d’utilisateur et mot de passe d’une personne reconnue parle réseau.Pour chaque binôme, une personne devra configurer l’accès en 802.1X avec son nom et mot de passe del’IUT.

Fichier de configuration

Le système Raspbian tel qu’il est installé contient les programmes nécessaires à l’authentification 802.1X.Il s’agit du programme wpa_supplicant et son fichier de configuration :/etc/wpa_supplicant/wpa_supplicant.conf.Le contenu de ce dernier doit être remplacé par ceci :

network=key_mgmt=IEEE8021Xeap=PEAPidentity="login_ul"password="votre_passwd"

(Vous trouverez un exemple sur ~/pot/ du PC)Les valeurs pour identity et password doivent être adaptées avec vos paramètres.

Accès automatique

Pour finir, il faut écrire le script ci-dessous, appelé wired802.#!/bin/bash### BEGIN INIT INFO# provides: wired802# Default-Start: 2 3 4 5# Default-Stop:### END INIT INFO

rm /var/run/wpa_supplicant/eth0ifconfig eth0 upifconfig eth0 promiscwpa_supplicant -i eth0 -dd -B -Dwired -c /etc/wpa_supplicant/wpa_supplicant.confsleep 1dhclient eth0 -nw

Ce script effectue la connexion proprement dite. Pour qu’elle soit faite à chaque démarrage du Rasp-berry, il faut l’ajouter aux services lancés au démarrage à l’aide de la commande update-rc.d. Oncommence par le copier dans le répertoire /etc/init.d/ qui contient les scripts qui lancent tous lesservices.sudo chmod 755 wired802sudo cp wired802 /etc/init.d/sudo update-rc.d wired802 defaults

Brancher le Raspberry sur le réseau filaire et le rebooter sudo rebootUne fois reconnecté, l’adresse du Raspberry est de la forme :100.64.87.2xyoù xy est le numéro sur l’étiquette du Raspberry.La commande ifconfig ou ip addr show eth0 permet de voir l’adresse IP du Raspberry.

7

1.4: Accès SSH M401C

1.4 Accès SSH

Clé privée et clé publique

La sécurisation par cryptage passe par l’utilisation de clés qui sont des valeurs numériques (sur 128 bitspar exemple) permettant de transformer des données de sorte qu’elles soient totalement différentes etque l’on puisse retrouver leur valeur initiale avec une clé. Les techniques de sécurité actuelles utilisentsouvent un couple de clés : la clé publique et la clé privée.Ce sont deux clés numériques qui ont la propriété de décoder avec l’une ce qui a été codé avec l’autre.En d’autres termes, si m est un message, K+ la clé publique et K- la clé privée, alors :K-(K+(m)) = K-(K+(m)) = m

Le message m, codé avec la clé publique, peut être décodé avec la privée et réciproquement. La clépublique est accessible par tous alors que la clé privée doit rester secrète. Les cas d’utilisation sont lessuivants :

• Si A veut envoyer un message m secret à B, et qu’il possède la clé publique de B (appelonsla K_B+), il crypte donc K_B+(m) qui ne pourra être décrypté que par B, avec sa clé privée :K_B-(K_B+(m))

• Les clés permettent aussi l’authentification : si A veut être sûr que c’est B qui lui répond. B cryptesa réponse r avec sa clé privée K_B-(r) et si A peut décrypter correctement le message avec laclé publique de B : K_B+(K_B-(r)), cela prouve que c’est bien B qui a crypté la réponse (noterque tout le monde a pu décrypter la réponse).

L’implémentation de SSH

Le répertoire $HOME/.ssh contient les fichiers remarquables suivants :

id_rsa : contient votre clé privée. Ce fichier a la protection -rw----- ;

id_rsa.pub : contient votre clé publique. Ce fichier a la protection -rw-r-r- ;

authorized_keys : Si votre machine contient un serveur ssh, ce fichier contient les clés publiques desclients qui veulent se connecter sur votre serveur ssh ;

known_hosts : contient les noms des serveurs ssh auxquels votre machine s’est déjà connectée.

Les commandes suivantes concernent l’accès ssh :

ssh-keygen : construit un couple de clés privée et publique. Sans option, le répertoire $HOME/.sshest utilisée ainsi que les fichiers id_rsa et id_rsa.pub. Cette commande demande unepassphrase qui sert de certificat identifiant votre machine ;

ssh-add : ajoute une clé privée ;

ssh-agent : gère les passphrase et permet les connections aux serveurs ssh qui possèdent votre clépublique sans avoir à donner de mot de passe.

8

M401C 1.5: Évaluation

Accès au Raspberry

On veut pouvoir accéder au raspberry en ssh depuis les PC sans avoir à taper son mot de passe. Dans cecas, le Raspberry doit contenir la clé publique, par défaut dans un fichier ~/.ssh/authorized_keys,et le PC la clé privée dans ~/.ssh

• Générer une clé publique et privée avec la commande ssh-keygen sur votre PC.

• Mettre chacune de ces clés dans le bon répertoire de la bonne machine, sous le bon nom. Pourvous aider, rappelez vous que seule la clé publique peut être déposée sur le serveur.

• Configurer l’agent SSH (ssh-add) du client – votre PC – pour qu’il prenne en compte la nouvelleclé. Tapez les deux commandes :

eval `ssh-agent`ssh-add ~/.ssh/id_rsa

• Si cela fonctionne, on doit pouvoir se connecter en SSH depuis un PC, sans avoir à donner sonmot de passe, par exemple la commande suivante vous connecte au Raspberry01:

monlogin $ ssh rasp01.iutnc.site.univ-lorraine.fr

1.5 Évaluation

• On doit pouvoir se connecter en SSH au Raspberry depuis sa session linux, sans taper de mot depasse.

• la commande date doit donner la bonne date.

9

2Serveur WEB

2.1 Installer et configurer un serveur Web

Installer le package apache2 et personnalisez le serveur. Pour cela s’aider des informations contenuesdans le cours M3102 Services réseaux, dans sa partie Service HTTP.

2.2 Configuration initiale

Une fois installé, le serveur web peut être accédé par un navigateur. Il donne l’accès à un site web trèssimple que l’on demande de personnaliser. Avant toute modification d’un fichier, faites une sauvegarde!

• La page d’accueil doit afficher les noms des étudiants.

• Elle doit contenir une image (de taille raisonnable) du raspberry ou du logo.

• Elle doit avoir un lien, nommé scripts, vers une autre page qui sera vide pour être utilisée dans lasuite.

• Elle permet aussi d’accéder à la page d’accueil initiale qui contient des informations importantessur les fichiers de configuration.

2.3 Création d’un script CGI

Un script CGI est un programme qui peut être exécuté par un serveur HTTP. Ce programme produit unepage HTML qui est interprétée ensuite par le serveur.Normalement la configuration initale d’apache permet l’utilisation de scripts CGI. Vérifier les pointssuivants (qui pourront varier, suivant la version d’apache2) :

• Dans le répertoire conf-enabled, le fichier de configuration serve-cgi-bin.conf doitexister. Il contient une directive ScriptAlias qui permet d’utiliser une URL plus simple et quicache le véritable emplacement du répertoire où se trouve les scripts CGI.

• Le fichier doit également contenir une définition Directory pour le répertoire des script CGI.Cette définition contient la directive : Options +ExecCGI.

11

2.3: Création d’un script CGI M401C

• Le module qui gère les programme CGI n’est pas activé par défaut, il se trouve dans le répertoiremods-available, sous le nom cgid.load et la commande a2enmod permet de configurerapache2 avec ce module (en fait la commande fait un lien symbolique).

• il faut relancer le serveur sudo service apache2 restart

Premier programme

Ce premier programme est écrit sous la forme d’un script shell. Voici le source de date.cgi :

#!/bin/sh

tmp=`/bin/date`

cat << EndFileContent-type: text/html

<HTML><HEAD><TITLE>Script Cgi</TITLE></HEAD><BODY>

<CENTER>

<H1>La date courante sur le serveur est</H1>$tmp

</CENTER>

</BODY></HTML>

EndFile

On fait un chmod 555 date.cgi et on copie le fichier dans le répertoire des scripts CGI. On peututiliser un navigateur vers l’URL http://IP-DU-RASPERRY/cgi-bin/date.cgi pour voir lerésultat.

La date courante sur le serveur estWed Jan 7 09:32:00 CET 2015

Au niveau du source, on affecte à la variable tmp le résultat de la commande /bin/date. La com-mande cat << EndFile permet d’afficher sur la sortie standard tout ce qui suit jusqu’à ce que l’onrencontre une ligne formée uniquement par EndFile (la chaîne suivant immédiatement <<). En fait,tout ce qui se trouve entre << EndFile et EndFile est utilisé comme entrée standard de la com-mande cat (la chaine EndFile est choisie arbitrairement).Ce qu’il faut retenir à ce niveau, c’est qu’un script CGI doit produire sur sa sortie standard quelquechose de compréhensible par le navigateur, donc, dans la majorité des cas, une sortie au format HTML.La seule obligation est la présence, sur la première ligne, du header Content-type suivi d’UNELIGNE VIDE !!

12

M401C 2.4: Sécurité du serveur Web

Intégration dans le site

Faire en sorte que le script CGI précédent puisse être exécuté à partir de la page référencée par le lienscripts créé initialement.

Deuxième programme

Réaliser le même service avec un programme C (n’oubliez pas la ligne vide !). Ajouter un deuxièmelien dans la page des scripts.

2.4 Sécurité du serveur Web

HTTP peut fonctionner de manière sécurisée, c’est à dire que les échanges entre le client et le serveurseront cryptés. Cette utilisation est appellée HTTPS (HTTP Sécurisé), et elle consiste à faire passer lesmessages HTTP par une couche de transport sécurisée : SSL/TLS.

Activation du mode sécurisé

Pour autoriser le mode SSL, entrez les commandes en tant que super utilisateur

a2ensite default-ssla2enmod sslservice apache2 restart

Ces commandes installent le module ssl nécessaire à la prise en compte des certificats et créent les liensnécessaires entre répertoires. Le serveur Apache est relancé après toute modification sur les fichiers deconfiguration.Le fichier /etc/apache2/sites-available/default-ssl est un exemple de fichier de con-figuration d’un site sécurisé.Les navigateurs vont automatiquement utiliser le mode sécurisé si on précise que l’on utilise le protocolehttps, qui prend par défaut le port 443 comme destination. Par exemple :https://localhost

Accès par certificat

Les certificats sont des données, généralement sous la forme d’un fichier, qui contiennent le nom de sonpropriétaire, sa clé publique et une période de validité (pour l’essentiel).Un certificat permet à un utilisateur du Web d’être sûr que le site qu’il contacte est bien celui qu’ilprétend être, par exemple lorsque l’on accède à son compte en banque, ou que l’on fait une déclarationd’impôt. Il est donc nécessaire d’avoir confiance au certificat en lui même; un utilisateur mal intentionnépourrait faire un site imitant celui d’une banque et délivrer un certificat dans lequel il affirme être cettebanque.Pour pallier ce problème, il existe des organismes reconnus : les autorités de certification (ou CAcomme Certification Authority), dont le travail consiste à s’assurer qu’un certificat est bien émis parcelui qu’il prétend être. Pour rendre cette certification fiable, un CA possède lui aussi un couple de cléprivée/publique et lorsqu’il valide un certificat, il fait deux opérations sur celui-ci :

• il génère une empreinte numérique (un hash) avec un algorithme connu (comme MD5),

13

2.4: Sécurité du serveur Web M401C

• il crypte cette empreinte avec sa clé privée, ce qui forme la signature du certificat de l’organisme,qui est rajoutée à la fin du certificat.

Ainsi, lorsqu’un site affirme une identité dans son certificat, et l’identité du CA, le client peut effectuerl’opération inverse. C’est à dire qu’il sépare la signature du certificat, génère l’empreinte de ce dernier etdécrypte la signature avec la clé publique du CA. Si les deux résultats sont identiques, alors le certificatest bien émis par le CA et donc l’organisme est bien celui qu’il prétend être.Les navigateurs sont en principe en possession des certificats des principaux CA, et l’accès à un site nese fera que si le certificat de ce site est bien vérifié. Verisign, GlobalSigne, Click and Trust sont desexemples de CA, il en existe des centaines.

Certification auto-signée

Dans de nombreux cas, le passage par une autorité de certification n’est pas une obligation (coût, accèsrestreint à un intranet) et tout le monde peut générer un certificat et l’installer dans son serveur Web.Lors de l’accès au site, le navigateur prévient l’utilisateur que le certificat n’est pas signé par une autoritéreconnue, mais laisse la possibilité de lui faire confiance. Si c’est le cas, le nouveau certificat est installédans le navigateur et il sera toujours considéré comme valable. C’est donc un choix important. Ladistribution Debian d’Apache fournit par défaut un certificat auto-signé ssl-cert-snakeoil rangédans le répertoire /etc/ssl/certs/.

Exercice

Après avoir relancé Apache, accéder à votre site ainsi qu’aux scripts cgi en mode sécurisé. Il faudraaccepter le certificat auto signé fourni avec la distribution d’Apache.

Génération d’un certificat

Pour générer un autre certificat auto-signé, utiliser la commande suivante (répondre aux questions qu’ellevous pose) :

openssl req -new -x509 -nodes -out server.crt -keyout server.key

permet de créer dans les fichiers server.crt et server.key respectivement un certificat et sa cléprivée. Une bonne place où ranger ses certificats auto-signés est /etc/ssl/private.Le fichier default-ssl du répertoire /etc/apache2/sites-available contient les variablessuivantes qu’il faut adapter afin de référencer le certificat :

SSLCertificateFileSSLCertificateKeyFile

Exercice

Générer un certificat auto signé pour votre site web et l’insérer dans la configuration du serveur. Lorsquevous accéderez au site, il faudra "accepter les risques" pour que le navigateur puisse continuer. Enrefaisant un accès, constatez que le navigateur accepte le certificat sans redemander de confirmation.

14

M401C 2.5: Évaluation

Certification du client

L’autre utilisation des certificats est, pour un serveur Web, d’authentifier certains clients auxquels il auradonné un certificat.Dans ce cas, lorsqu’un client se connecte au serveur, celui-ci lui demande le certificat et autorise – ounon – l’accès en fonction de sa validité. Ici, le serveur fait office de CA, il doit vérifier que le certificatprovenant du client est bien celui qu’il a lui même donné.Apache2 demande un certificat au format pem (Privacy Enhanced Mail) alors que les navigateursgénéralement demandent un format pkcs12.La procédure à suivre sur votre PC est la suivante :

• Sur votre PC, génération d’un couple clé privé/certificat : openssl req -new -x509 -nodes-out user.crt -keyout user.key

• Transformation du certificat dans le format pem : openssl x509 -in user.crt -outuser.pem -outform PEM

• Transformation du couple clé privée/certificat au format pkcs12 : openssl pkcs12 -export-out user.p12 -inkey user.key -in user.crt

• Déposer les fichiers user.* sur le serveur. Utiliser la commande scp analogue à ssh mais quipermet de copier des fichiers sur une autre machine.

• Sur le serveur, modification de la directive SSLCACertificateFile pour y désigner le certi-ficat du client (user) dans le fichier de configuration default-ssl.conf du site sécurisé.

• Mettre la valeur : require à la directive SSLVerifyClient.

• Relancer le serveur.

• Intégration du certificat (et de sa clé privée) au format pkcs12 dans le navigateur (ou le trousseaudans les Macs) par le menu préférences -> Avancées -> Voir Certificats -> mescertificats -> Importer

Suivre la procédure et vérifier que seul un client avec le bon certificat peut accéder à la partie sécuriséedu site.

2.5 Évaluation

• On peut accéder au site non sécurisé du Raspberry à l’URL http://raspXY.iutnc.site.univ-lorraine.fr

• On peut exécuter le cgi donnant la date.

• On peut accéder au site sécurisé du Raspberry à l’URL https://raspXY.iutnc.site.univ-lorraine.fr,en acceptant le certificat du serveur

• On ne peut accéder à ce site que si l’on a intégré un certificat de client dans le navigateur.

15

3Programmation du PiFace

3.1 Mise en place

La carte PiFace se monte au-dessus de la carte Raspberry à l’aide d’un prolongateur comme le montrela figure 3.1.

Figure 3.1: Emplacement des cartes Raspberry et PiFace connectées à l’aide d’un prolongateur. Le con-necteur GPIO du Raspberry est plus grand que le connecteur du PiFace. Veuillez au correct branchementsinon les cartes seraient endommagées

Elle permet les entrées-sorties suivantes :

entrées : un bornier permettant de connecter 8 interrupteurs. Les 4 premiers correspondent aux 4 inter-rupteurs sérigraphiés sur la carte S1, S2, S3, S4;

sorties : 8 diodes LED0, LED1 . . . LED7. Les diodes 0 et 1 activent aussi les 2 relais OMRON.

Cette carte communique avec le Raspberry par le biais du GPIO grâce au bus SPI. Elle permet deprotéger le GPIO du Raspberry tout en fournissant des entrées-sorties simples d’utilisation.

17

3.2: Programmation en C M401C

Installation

Avant toute utilisation du PiFace, commencer par autoriser le chargement du module SPI en allant dansl’option Interfacing Options de raspi-config.

sudo raspi-config

Vérification de l’installation du module

Le répertoire /dev doit contenir les fichiers virtuels:

$ ls -l /dev/spi*crw-rw---T 1 root spi 153, 0 Jan 1 1970 /dev/spidev0.0crw-rw---T 1 root spi 153, 1 Jan 1 1970 /dev/spidev0.1

Une fois cette configuration faite, éteignez le Raspberry et installez le PiFace (cf photos). Rallumezensuite le Raspberry.

3.2 Programmation en C

Interface avec le PiFace

Pour accéder au PiFace en C, nous utiliserons des fonctions de haut niveau définies dans la bibliothèquelibpiface-1.0. L’installation de cette bibliothèque suit le processus détaillé sur le sitehttp://www.noveldevices.co.uk/rp-piface-1.

1. Télécharger les fichiers source. Cela créera le répertoire appelé piface à partir de l’archivepiface_en_C.tgz se trouvant sur l’ENT. Cette archive est une copie du dépôt git suivant :

git clone https://github.com/thomasmacpherson/piface.git

2. Installer les paquets automake et libtool ;

sudo apt-get install automake libtool

3. En tant qu’utilisateur, installer la bibliothèque C libpiface-1.0 à l’aide des commandes suiv-antes, il n’est pas nécessaire d’être root. Le processus est long mais mérite attention !

cd piface/c/./autogen.sh./configuremakesudo make installsudo ldconfig

Le répertoire piface/c/examples contient des exemples d’utilisation qui permettent de savoirsi votre PiFace fonctionne correctement.

18

M401C 3.2: Programmation en C

Le fichier Makefile de ce répertoire contient les informations nécessaires à la compilation desdifférents programmes C présents. Pour l’utiliser, il faut passer par la commande make :

make the_amazing_les_show

Va compiler le fichier the_amazing_led_show.c et générer l’exécutable du même nom. Àpriori, il n’est pas nécessaire d’être administrateur pour pouvoir lancer les programmes. (Atten-tion, les programmes ont quelques bugs faciles à réparer)

4. En vous inspirant des programmes d’exemple et à l’aide de la documentation sur les fonctionsd’entrées-sorties données quelques lignes plus loin, créer un programme C qui allumera une LEDdont le numéro est donné en argument (de 0 à 7).

5. Compiler et exécuter le programme :

gcc -L/usr/local/lib/ -lpiface-1.0 -o piface_program piface_program.c./piface_program

ou bien rajouter quelques lignes au fichier Makefile pour gérer votre programme.

Les fonctions C d’entrées-sorties

Le fichier piface/c/src/piface/pfio.c contient les différentes fonctions interfaçant le PiFace.Le type uint8_t représente un octet (8 bits). Il est défini dans les programmes C de la bibliothèque.

typedef unsigned char uint8_t;

int pfio_init(void) : effectue l’initialisation des composants;

int pfio_deinit(void) : arrête les composants du PiFace.

Entrées-sorties globales :

uint8_t pfio_read_input(void) : retourne dans un octet les 8 bits représentant l’état du bornierd’entrée ;

uint8_t pfio_read_output(void) : retourne dans un octet l’état des sorties représentées par les 8diodes ;

void pfio_write_output(uint8_t value) : écrit value sur les 8 sorties. Chaque bit de valuecorrespond à une sortie. Les 8 diodes reflètent l’état des 8 sorties.

Entrées-sorties individuelles :

uint8_t pfio_digital_read(uint8_t pin_number) : retourne 1 ou 0 suivant l’état de l’entrée désignéepar la valeur de pin_number ;

void pfio_digital_write(uint8_t pin_number, uint8_t value) : écrit value – 1 ou 0 – sur lasortie désignée par la valeur de pin_number.

19

3.4: Évaluation M401C

Exercices

1. Allumer/éteindre une LED en donnant son numéro (de 0 à 7);

2. Tester si un des 4 boutons est enfoncé ;

3. Tester si un groupe de boutons est enfoncé et imprimer le détail ;

4. A l’aide des exemples donnés dans le répertoire piface/c/examples, écrire un programmequi allume une LED à l’aide du bouton correspondant. Le bouton S1 associé à l’entrée 0 allumela LED0, ...

3.3 Programmation en Java du PiFace

Installation

• Récupérer le paquet pi4j-1.2-SNAPSHOT.deb sur l’ent.

• Copiez le sur le Raspberry (dans le home de pi).

• Installez le paquet :sudo dpkg -i pi4j-1.2-SNAPSHOT.ded

Les fichiers installés sont dans le répertoire /opt/pi4j.

• le répertoire bin contient un script pi4j qui facilite les compilations et exécutions.

• le répertoire examples contient le fichier PiFaceExample.java qui utilise les diodes et lesboutons du PiFace.

3.4 Évaluation

En vous inspirant des exemples, soit en C, soit en java, réaliser le jeux suivant :

• Le PiFace allume en séquence des diodes 0 à 3, dans un ordre aléatoire, par example la diode 0,puis la 2.

• Le PiFace va ensuite attendre que les boutons correspondants aux mêmes positions soient appuyés;donc le switch 4 puis le 2 (il y a un décalage entre la numérotation des switchs et celle des diodes).

• Si c’est bon, le PiFace commence une nouvelle séquence, en augmentant le nombre de diodes (etéventuellement en allant plus vite).

• Libre à vous d’imaginer comment compter un score, comment arrêter. . .

20

4Services réseaux

4.1 Introduction

Ce chapitre a pour objectif de mettre en place différents services réseaux qui sont généralement présentsdans tout réseau local.

Travail à réaliser

On dispose des éléments suivants :

• 2 Raspberry :

– le Raspberry qui est déjà configuré avec les deux comptes du binôme (le serveur).

– le Raspberry qui contient juste le système mis à jour avec le package nfs-common installé(le client).

– 1 switch

– 1 clé USB qui contient un répertoire partage

Le but est de configurer le serveur pour qu’il offre les services DHCP, DNS et NFS. Le client, devra êtreconfiguré pour être le client de ces services.

Le câblage du réseau est le suivant (la clé USB étant dans un port USB du serveur) :

21

4.2: DNS M401C

Quand tout sera configuré, on devra allumer dans l’ordre :

1. le switch

2. le serveur avec la clé insérée (attendre ou vérifier avec l’écran qu’il a bien fini de démarrer)

3. le client

• Il obtient une addresse IP du serveur DHCP

• Il récupère également son nom de domaine, celui du serveur DNS et son propre nom : rasp.

• Il a les même utilisateurs que le serveur, qui verront leur home du serveur par NFS, ainsi quele répertoire /home/partage qui représentera la clé USB du serveur. Toute modificationdans l’un des home sur une machine doit se retrouver instantanément sur l’autre. Toutemodification dans le répertoire partage de la clé sur le serveur sera visible par le client.

4.2 DNS

Coté serveur

Pakages à installer : bind9, dnsutilsIl faut configurer le Raspberry serveur pour qu’il gère un domaine local appelé raspberry.iut.fr,il doit donner le nom rasp1 au Raspberry client.

• Le Raspberry serveur devra s’appeler serveur.raspberry.iut.fr

• Le Raspberry client devra obtenir l’adresse 192.168.0.222.

Les fichiers de configuration : Avant toute modification de ces fichiers, vous devez :

• en faire une sauvegarde ;

• regarder leurs contenus lorsque votre Raspberry est connecté au réseau la salle. Ceci vous guideradans les modifications à y apporter.

22

M401C 4.3: DHCP

/etc/bind/named.conf.options : ce fichier indique quels sont les DNS chargés de résoudre les nomsextérieurs au domaine raspberry.iut.fr.

/etc/resolv.conf : ce fichier indique le nom du domaine ainsi que l’adresse IP du DNS. Notez soncontenu quand votre Raspberry est connecté au réseau de la salle.

/etc/bind/db.local : ce fichier est un squelette à compléter. Il associe les noms locaux avec leursadresses IP (cf. poly réseau M3102)

/etc/bind/db.127 : ce fichier est un squelette qui permet l’association inverse. A l’aide d’une adresseIP, il permet de retrouver le nom local.

/etc/named.conf.local : ce fichier définit la ou les zones locales en donnant les noms des 2 fichiersprécédants qui définissent une zone.

Dans le répertoire /etc, modifier le fichier resolvconf.conf pour qu’il indique que la machinelocale est le serveur de noms et donner également le nom de domain qui sera recherché si on ne le précisepas. Dans notre cas, si on tape : ping rasp (le système devra traduire en ping rasp.raspberry.iut.fr).Dans /etc/network/interfaces, configurer l’adresse IP du serveur de manière statique (il doitavoir l’adresse 192.168.0.100/24).

4.3 DHCP

Le protocole de configuration dynamique des machines (Dynamic Host Configuration Protocol) a été vudans le module M3102 : Services réseau.

Package à installer : isc-dhcp-server

Description

Le service DHCP consiste à donner une adresse IP à une machine se connectant (ou démarrant) sur leréseau. Il peut également donner d’autres informations comme le routeur par défaut, ou le serveur denoms.

Serveur ISC

Le fichier de configuration du serveur DHCP du package isc-dhcp-server est :/etc/default/isc-dhcp-server.qui doit être modifié, d’une part en donnant un nom de fichier pour la variable DHCP_CONF, et d’autrepart en spécifiant l’interface réseau (généralement eth0) sur laquelle le serveur attend les requêtes.

Service DHCP

Le service proprement dit est décrit dans un fichier (référencé par le fichier précédent) et offre de nom-breuses possibilités.

• Configurer le Raspberry serveur pour qu’il attribue l’adresse IP que lui donnera le serveur DNSpour le Raspberry client, en fonction de l’adresse Ethernet du client (que l’on obtient avec lacommande ifconfig)

23

4.4: NFS M401C

Client DHCP

Le programme dhclient est déjà installé (c’est un élément assez indispensable) et sa configuration sefait par le fichier :/etc/dhcp/dhclient.confOn y trouve la définition de la requête DHCP, c’est à dire quelles informations vont être demandées auserveur. Le mot clé est : request. Dans notre cas, on demandera :

• le masque de sous réseau

• l’adresse du serveur de noms (DNS)

• le nom de domaine

• le nom du Raspberry (le host-name)

Pour que le nom du Raspberry retourné par le serveur DHCP soit pris en compte par le client, il suffit desupprimer le fichier /etc/hostname du Raspberry client.

4.4 NFS

NFS (NetWork File System) permet de monter des volumes situés sur des serveurs distants de la mêmefaçon qu’une clé USB.Il faut configurer le Raspberry serveur pour qu’il soit un serveur NFS et le Raspberry client pour qu’ilsoit un client de ce serveur.

Serveur NFS

Montage de la clé USB

La clé sera automatiquement montée grâce à des indications dans le fichier /etc/fstab. Modifier cefichier pour qu’il monte la clé dans le répertoire /mnt/USB. Ce n’est qu’une fois montée que l’on ycréera le répertoire partage.

Exports des répertoires

• Installer les packages suivants: nfs-common nfs-kernel-server portmap ;

• Editer le fichier /etc/exports qui définit quels fichiers seront accessibles via nfs. Pour laclé USB, il faut entrer la ligne suivante dans le fichier /etc/exports:

/mnt/USB/partage adresse.client(rw,sync,no_subtree_check)

Pour que les home des utlisateurs soient exportés, il faut utiliser les mêmes identifiants pour lesutilisateurs et le groupe sur les deux machines. Par exemple :

/home/login adresse.client(rw,sync,no_subtree_check,anonuid=1001,anongid=1002)

24

M401C 4.5: Évaluation

va exporter le répertoire /home/login vers le client, pour l’utilisateur 1001 du groupe 1002.Les deux comptes étant déjà créés sur le serveur, on récupérera leurs identifiants (commande id)et on pourra créer les mêmes utilisateurs et groupes sur le client (options --UID et --GID descommandes adduser et addgroup)

• Relancer les services nfs et rpcbind :

sudo /usr/sbin/update-rc.d rpcbind enablesudo /usr/sbin/update-rc.d nfs-common enablesudo service rpcbind restartsudo /etc/init.d/nfs-kernel-server restart

Client NFS

package nfs-commonLe client doit avoir les mêmes utilisateurs et groupe que le serveur (cf remarque ci-dessus). Il faut quele répertoire /home que l’on va récupérer depuis le serveur existe sur le client. La configuration se faitdans le fichier /etc/fstab, sous la forme :serveur.adresse:/home/ /home/ nfs auto,user,rw 0 0qui va monter le répertoire home/ du serveur vers le répertoire /home/ du client.Il faut deux lignes, une pour les home et une pour le répertoire partage de la clé

4.5 Évaluation

• On allume le switch et connecte les deux Raspberry et on démarre uniquement le serveur (sansécran).

• On allume le client (avec écran et clavier)

• On se connecte avec un des noms d’utilisateur

– le prompt du système affiche login@rasp, la commande hostname retourne rasp

– on peut faire ping rasp, ping rasp.raspberry.iut.fr, ping serveur

– le répertoire de la clé est visible dans /home/partage, un ajout depuis le serveur estvisible sur le client.

– le répertoire /home/login est synchronisé entre le client et le serveur (toute modificationest visible sur les deux machines).

• On se connecte sur le Raspberry serveur par ssh : ssh pi@serveur

– depuis le serveur, on peut faire ping rasp

25

5Programmation du GPIO

5.1 Introduction

Le GPIO (general purpose In/Out) est une partie du circuit intégré BCM2835 de la carte qui permetd’envoyer et recevoir des signaux électriques. Le GPIO possède 54 broches qui peuvent être configuréesen entrée ou en sortie. Deux broches nous intéresserons dans ce TD : les broches 23 et 24 qui sontreliées à la platine de montage soit en sortie pour allumer une diode led soit en entrée activée par uninterrupteur.

5.2 Montage électronique de la platine

description du matériel

• un raspberry ;

• un détrompeur pour identifier les broches du GPIO;

• une diode led

L

- +

La cathode (-) correspond au fil court. L’anode (+) correspond au fillong.

• des résistances :

– 330 ohms (orange, orange, marron, or) ;

– 12k ohms (marron, rouge, orange, or) ;

– 1k ohms (marron, noir, rouge, or).

• un interrupteur du type bouton poussoir

• un platine de montage (cf. Fig. 5.1).

27

5.2: Montage électronique de la platine M401C

Figure 5.1: La platine de montage et le schéma des connections possibles

Affichage d’une sortie du GPIO

Le GPIO représente un 1 par une tension de 3,3V et un 0 par une tension 0V. En sortie, le GPIO secomporte comme un générateur de faible puissance et délivre un courant pour maintenir cette tension. Ilest nécessaire de le limiter par une résistance dite “de tirage” ou pull-up / pull/down de valeur 330 ohms.Il ne faut pas relier directement une sortie du GPIO directement à la masse – quand il sort un1 – ou à3,3V quand il sort un 0. Le courant fourni serait trop important et grillerait le GPIO.Les deux circuits électroniques ci-dessous permettent l’affichage des signaux 0 et 1 émis par la broche24 du GPIO.

L

R 330Ω

3,3V

GPIO24 allumage si sortie = 0

R 330Ω

D

GPIO24

allumage si sortie = 1

Activation d’une entrée du GPIO

Quand elle est configurée en entrée, une broche du GPIO interprète une tension de 0V pour un 0 et 3,3Vpour un 1. Ces tensions sont fournies aux bornes de la résistance R1. La résistance R2 sert à limiter lecourant émis par le GPIO dans le cas où la broche serait configurée par erreur en sortie.Les deux circuits électroniques ci-dessous permettent de mettre à 0 ou 1 la broche 23 du GPIO suivantle contact.

S

R1 12kΩ

3,3V

R2

1kΩ

GPIO23

si contact alors 0 sinon 1

R1 12kΩ

S

R2

1kΩ

GPIO23

3,3V

si contact alors 1 sinon 0

28

M401C 5.3: Programmation via le système de gestion de fichier

Questions

Q0. A l’aide d’une platine de montage et de composants, réalisez un montage dans lequel la brocheGPIO24 commandera une diode et un interrupteur agira sur la broche GPIO23. Faites le contrôlerpar un enseignant.

Figure 5.2: La platine et le Raspberry montrant le positionnement du détrompeur. Les connexions réseauet alimentation ont été enlevées pour les besoins de la photo. Se reporter aux schémas électroniques pourretrouver les liaisons entre composants

5.3 Programmation via le système de gestion de fichier

Pour tester le montage qui vient d’être réalisé, nous allons écrire un script Bash pour lire / écrire lesbroches 23 et 24 du GPIO. Linux définit des fichiers virtuels dans /sys/class/gpio:

export : en écriture seule. On écrit dans ce fichier le numéro de la broche à laquelle on veut accéder.Le système ajoute en fonction des fichiers et répertoires qui permettront d’accéder à cette broche ;

unexport : en écriture seule, supprime les fichiers créés par export;

gpion : répertoire associé à la broche de numéro n ;

gpion/direction : fichier contenant in ou out et spécifiant le sens des données circulant sur la brochen. in pour une lecture, out pour une écriture.

gpion/value : contient 1 ou 0 suivant l’état de la broche.

29

5.4: Accéder directement au GPIO en C M401C

exemple

mari5@rasp20 ~ $ sudo su[sudo] password for mari5:root@rasp20:/home/mari5# cd /sys/class/gpio/root@rasp20:/sys/class/gpio# lsexport gpiochip0 unexportroot@rasp20:/sys/class/gpio# echo 24 > exportroot@rasp20:/sys/class/gpio# echo 23 > exportroot@rasp20:/sys/class/gpio# lsexport gpio23 gpio24 gpiochip0 unexportroot@rasp20:/sys/class/gpio# cd gpio24root@rasp20:/sys/class/gpio/gpio24# lsactive_low device direction edge subsystem uevent valueroot@rasp20:/sys/class/gpio/gpio24# echo out > directionroot@rasp20:/sys/class/gpio/gpio24# echo 1 > valueroot@rasp20:/sys/class/gpio/gpio24# echo 0 > valueroot@rasp20:/sys/class/gpio/gpio24# cd ../root@rasp20:/sys/class/gpio# cd gpio23/root@rasp20:/sys/class/gpio/gpio23# echo in > directionroot@rasp20:/sys/class/gpio/gpio23# cat value0root@rasp20:/sys/class/gpio/gpio23# cat value1root@rasp20:/sys/class/gpio/gpio23# cd ../root@rasp20:/sys/class/gpio# echo 23 > unexportroot@rasp20:/sys/class/gpio# lsexport gpio24 gpiochip0 unexport

Il faut être super utilisateur

On s’intéresse aux broches 24et 23Le système a crée les répertoires correspondants

On configure gpio24 en sortieon allume la ledet on éteint la led

On configure gpio23 en entréeOn lit l’état de la brocheLe poussoir n’est pas enfoncé!

Le poussoir est maintenant enfoncé!

on ne veut plus de la broche 23

Le répertoire gpio23 a disparu.

Questions

Q1. Écrire un script shell qui fait clignoter la diode reliée au GPIO24.

Q2. Modifier le script précédent pour l’arrêter avec l’interrupteur relié à la broche GPIO23.

5.4 Accéder directement au GPIO en C

(paragraphe rédigé à partir de l’article paru dans Linux magazine hors série numéro 75)

Le GPIO possède 41 registres qui font partie de l’espace mémoire adressable du Raspberry. Ils peuventêtre lus / écrits comme des mots de 32 bits en mémoire centrale. L’ensemble des 41 registres sera consid-éré comme un tableau du type unsigned int dont l’adresse de base sera placée dans un pointeur detype unsigned int* par une requête au système d’exploitation. Tous les programmes s’exécutentdans un espace mémoire virtuel. Seul le système d’exploitation connaît la mémoire physique. Unixautorise le super utilisateur à projetter un segment de mémoire physique – dans lequel se trouvent lesregistres du GPIO– dans l’espace mémoire virtuel d’exécution du super utilisateur gràce à la fonctionmmap().

Accéder au tableau des registres

Seul root a le droit d’y accéder. Linux donne la possibilité de projeter des adresses absolues dans l’espacemémoire utilisateur. La mémoire virtuelle est considérée comme un fichier /dev/mem. La fonctionmmap() rend accessible le tableau de registres. Le programme suivant est donné à titre indicatif pourcomprendre comment affecter le pointeur du tableau des registres.

// Linux magazine HS 75

#define GPIO_BASE (0x3F200000) /* pour raspberry PI3 */

unsigned where = GPIO_BASE ;

30

M401C 5.4: Accéder directement au GPIO en C

void* map;

// ouvre /dev/memif ((mmap_fd = open("/dev/mem", O_RDWR|O_SYNC) ) < 0)

erreur("Echec à l'ouverture de /dev/mem");

// projette les registres GPIO dans la mémoire de notre programmemap = mmap(

NULL, // projette où ça arrange le kernelBLOCK_SIZE, // les registres de contrôle tiennent dans une seule pagePROT_READ|PROT_WRITE, // on veut lire et écrireMAP_SHARED, // partagé avec d'autres processusmmap_fd, // la mémoirewhere // adresse de la zone à accéder

);

if (map == MAP_FAILED)erreur("Echec de mmap()");

La variable map contient l’adresse du tableau donné 5.2 et sera affectée à PI_gpio.

Définir la direction d’une broche

Chaque broche – pin en anglais – du GPIO peut être configurée en entrée ou en sortie en spécifiant troisbits comme décrit dans le tableau 5.1.

valeur fonction000 GPIO pin en entrée001 GPIO pin en sortie... GPIO pin pour d’autres fonctions

Table 5.1: Les fonctions de chaque broche

Les fonctions de 10 broches sont regroupées dans un mot de 32 bits. Les bits 30 – 31 sont réservés. Ilsfaut 6 mots pour représenter les fonctions des 54 broches (cf. Tab. 5.2).

indice Adresse physique Description0 0x3F20 0000 GPIO fonction pin:0 - 91 0x3F20 0004 GPIO fonction pin:10 - 19. ... ...5 0x3F20 0014 GPIO fonction pin:50 - 53

Table 5.2: Le tableau des registres du GPIO (début)

31

5.4: Accéder directement au GPIO en C M401C

Si on suppose que le pointeur PI_gpio contient l’adresse de base du tableau des registres du GPIO don-née par mmap(), un programme C accédera aux fonctions des broches 0 à 9 par la variable PI_gpio[0].

Mettre à 1 une broche

Une fois une broche configurée en sortie, on peut la mettre à 1 en écrivant dans les registres 7 et 8 poury placer un 1 en bonne place.Par exemple PI_gpio[7] = 1 met à 1 la broche 0 à condition qu’elle ait été configurée en sortie. Eneffet, 1 s’écrit en binaire 0 ... 01 sur 32 bits. On rappelle que les bits sont numérotés de la droitevers la gauche, le bit numéro 0 ayant le poids le plus faible. Ainsi PI_gpio[7] = 2 met à 1 la broche1 et ainsi de suite PI_gpio[7] = 2i met le bit numéro i à un. Il est préférable d’écrire PI_gpio[7]= 1 << i car un décalage à gauche revient à une multiplication par 2.

indice Adresse physique Description6 0x3F20 0018 reserved7 0x3F20 001C GPIO SETn (n=0..31) : 0 no effect, 1 set pin n8 0x3F20 0020 GPIO SETn (n=32..53) : 0 no effect, 1 set pin n

Table 5.3: Le tableau des registres du GPIO (cont.) permettant la mise à 1 d’une broche

Mettre à 0 une broche

L’écriture d’un zéro sur une broche suit le même processus. Pour mettre à 0 les broches du GPIOconfigurées en sortie, il faut écrire un 1 dans les registres 10 et 11.

indice Adresse physique Description9 0x3F20 0024 reserved10 0x3F20 0028 GPIO RESETn (n = 0..31) : 0 no effect, 1 reset pin n11 0x3F20 002C GPIO RESETn (n = 32..53) : 0 no effect, 1 reset pin n

Table 5.4: Le tableau des registres du GPIO (cont.) permettant la mise à 0

Par exemple l’instruction PI_gpio[10]= (1 << 6)met à zéro la broche 6. En effet, on commencepar décaler de 6 positions à gauche (opérateur <<) le bit numéro 0 qui est à 1. Les bits qui entrent à droitesont à 0. Les bits qui sortent à gauche sont perdus, mais ils étaient à zéro! L’utilisation du décalage évitede calculer 2i.

Lire l’état d’une broche

En lisant les registres 13 et 14, on peut connaître l’état des broches du GPIO configurées en entrée.Par exemple, l’expression ((PI_gpio[13] >> 6) & 1) donne le niveau de la broche 6. On décalede 6 positions à droite le bit 6 pour l’amener en position 0, puis on fait un et logique avec 1 pouréliminer tous les bits sauf le premier.

32

M401C 5.4: Accéder directement au GPIO en C

indice Adresse physique Description12 0x3F20 0030 reserved13 0x3F20 0034 GPIO LEV ELn (n=0..31) : gives value of pin n14 0x3F20 0038 GPIO LEV ELn (n=32..53) : gives value of pin n

Table 5.5: Le tableau des registres du GPIO (fin) permettant de connaître le niveau d’une broche

Questions

Q3. Ecrire un sous programme C void PI_GPIO_config(int pin, int mode) qui con-figure une broche donnée en paramètre soit en entrée (fonction 0), soit en sortie (fonction 1). Lavariable mode contient la fonction à activer.

Q4. Ecrire un sous programme C void gpio_clr_n(int n) qui met à 0 la broche n.

Q5. Ecrire un sous programme C void gpio_set_n(int n) qui met à 1 la broche n.

Q6. Ecrire un sous programme C int gpio_lvl_n(int n) qui permet de connaître l’état de labroche n.

Q7. Ecrire en C le programme réalisé en bash (cf. question 5.3) en vous aidant des pages 20 – 23de Linux Magazine HS 75, ou du squelette du programme fourni sur l’ENT (pi3_gpio.tgz).Exécutez le en mode super utilisateur. Faites clignoter la diode reliée en GPIO23 avec une périodede 1 seconde. Le clignotement doit cesser quand on presse le bouton relié à la broche GPIO24.

Q8. Utilisez la commande pmap en mode maître pour visualiser les adresses virtuelles du processus.Quelles sont les adresses virtuelles et réelles du tableau de registres du GPIO?

33

6Serveur Web et PiFace - Java

6.1 Description

On veut pouvoir commander un PiFace avec un navigateur Web. Le principe est de lancer un serveurWeb sur le Raspberry et de proposer un site qui permette de contrôler les entrées et sorties du PiFace.La figure ci-dessous en donne un exemple simple où chaque interrupteur contrôle une sortie du PiFaceet chaque ampoule reflète l’état de la sortie. Lorsqu’on se connecte, ou que l’on rafraîchit la page, le sitedoit afficher l’état courant du PiFace.

6.2 Architecture

Cette application a plusieurs parties :Sont donnés :

35

6.2: Architecture M401C

• Le site est composé d’une page au format HTML avec du javascript qui gère l’affichage dy-namique des boutons et des ampoules ainsi que la communication avec le serveur Web.

• Les actions sur les boutons et lors des rafraîchissements entraînent des requêtes POST vers desprogrammes cgi-bin écrits en bash. Ces derniers vont faire s’exécuter des programmes javavers le PiFace et devront retourner des informations vers le navigateur Web.

Il faut réaliser :

• Un programme java doit initialiser le PiFace et attendre les commandes d’ouverture, de fermeturedes sorties ainsi que la commande de l’état courant de toutes ses sorties.

• Un programme java qui est lancé par un script cgi-bin pour actionner une sortie du PiFace

• Un programme java qui est lancé par un script cgi-bin pour obtenir l’état des sorties.

36

7Serveur Web et PiFace - C

7.1 Description

On veut pouvoir commander un PiFace avec un navigateur Web. Le principe est de lancer un serveurWeb sur le Raspberry et de proposer un site qui permette de contrôler les entrées et sorties du PiFace.La figure 7.1 donne un exemple simple où chaque interrupteur contrôle une sortie du PiFace. Lorsqu’onse connecte, ou que l’on rafraîchit la page, le site doit afficher l’état courant du PiFace.

Figure 7.1: L’interface du PiFace avec un navigateur. Le clic sur un bouton allume la LED correspon-dante. Sur cet exemple, le programme onoff est appelé avec le paramètre 8 qui indique quels boutonssont enfoncés et agit sur le PiFace (d’après http://www.noveldevices.co.uk)

7.2 Architecture

Le Raspberry héberge un serveur W3 qui interagit avec le PiFace par le biais d’un programme Cgi– onoff sur la figure 7.1 – que vous avez à écrire en C. Ce programme écrit une nouvelle pageHtml chaque fois qu’un bouton est cliqué. Il possède un paramètre qui correspond au(x) bouton(s)enfoncé(s). Il accède aussi au PiFace à l’aide des fonctions pfio_init, pfio_digital_write. . . (cf. chapitre 5).

37

7.4: Exemple M401C

7.3 Ressources

On donne les images correspondant aux boutons enfoncés et relachés. Vous pouvez aussi utiliser lesvôtres. Les placer dans /var/www/ :

onbutton.png : le bouton enfoncé

offbutton.png : le bouton relaché

Le code Html produit par un programme Cgi doit débuter par:

Content-type: text/html

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN""http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en"><head><meta http-equiv="Content-Type" content="*/*+xml" /><link rel="stylesheet" type="text/css" href=le_cssFile" media="screen, print" /><title>Le_titre_de_la_page</title></head><body>...</body></html>

Le programme cgi doit avoir le bit setuid positionné :

sudo chmod 4711 /usr/lib/cgi-bin/votre_prog_cgi

afin d’avoir le droit d’accéder au PiFace. Il a le fonctionnement suivant:Lancé sans paramètre, le programme cgi affiche tous les boutons en position off. Lancé avec unparamètre (par exemple un entier de 8 bits), le programme cgi affiche les boutons en position on ouoff suivant la valeur du bit de l’entier donné en paramètre. Quand on clique sur l’image d’un bouton,l’URL correspondante active à nouveau le programme cgi avec un nouveau paramètre dans lequel le bitcorrespondant au bouton sélectionné est inversé.La feuille de style css est nécessaire pour la mise en page du site quand les options par défaut neconviennent pas.

7.4 Exemple

Dans cet exemple, on affiche une ampoule qui s’allume ou s’éteind quand on clique dessus. Le pro-gramme cgi contient trois fonctions Rubric(), SendFooters() et SendHeaders() qui génèrentle texte Html de la page. Le programme admet un paramètre qui est l’état de la lampe affichée.

// affiche une ampoule clickable et active la diode 1 du piface// compiler avec:// gcc -L/usr/local/lib/ -lpiface-1.0 example0-cgi.c -o example0.cgi// copier l executable dans:

38

M401C 7.4: Exemple

// sudo cp example0.cgi /usr/lib/cgi-bin/// sudo chmod 47111 /usr/lib/cgi-bin/example0.cgi

#include <stdio.h>#include <stdlib.h>#include <string.h>#include <ctype.h>#include <libpiface-1.0/pfio.h>#include <sys/stat.h>#include <sys/types.h>#include <fcntl.h>

char WebServer[256];// Full URL to webserver (for images) with http:// and trailing /char WindowTitle[80];char AppServer[256] ;

void Rubric()

printf("<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n");printf("<html xmlns=\"http://www.w3.org/1999/xhtml\" xml:lang=\"en\" lang=\"en\">\n");printf("<head>\n");printf("<meta http-equiv=\"Content-Type\" content=\"*/*+xml\" />\n");printf("<link rel=\"stylesheet\" type=\"text/css\" href=\"%sonoff.css\" media=\"screen, print\" />\n",WebServer);printf(" <title>%s</title>\n",WindowTitle);printf(" </head>\n");printf(" <body>\n");return;

void SendFooters()

printf(" </body>\n");printf("</html>\n");return;

void SendHeaders(void)

printf("Content-type: text/html\n\n");return;

int main(int argc, char* argv[])

int LightState = 0 ; // l'etat de l'ampoulechar Message[256] ; // l'URL de l'ampoule qui s'afficheint argument ;strcpy(WebServer, "http://152.81.98.16/") ; // mon raspberrystrcpy(WindowTitle, argv[0]) ;strcpy(AppServer, "http://152.81.98.16/cgi-bin/example0.cgi") ;// read light stateif (argc > 1) LightState = atoi(argv[1]) ;// build messageif (LightState == 0) strcpy(Message, "ampouleE.png") ;argument = 1 ;

else strcpy(Message, "ampouleA.png") ;argument = 0 ;

// generate HTML

SendHeaders() ;Rubric() ;

// display lightprintf("<H1>\n") ;printf("<a href=\"%s?%d\"><img src=\"%s%s\"></a>\n", AppServer, argument, WebServer, Message);printf("</H1>\n") ;

SendFooters() ;

// do same thing with led 1 on pifacepfio_init() ;pfio_digital_write(1,argument) ;pfio_deinit() ;return 0 ;

39

7.4: Exemple M401C

40

Résumés des chapitres

Chapitre Titre Résumé1 Installation et configuration Installation5 Programmation du GPIO Manips sur le GPIO

41