Club robotique de Sophia-Antipolis

Accueil > POBOTpedia > Ordinateurs embarqués (SBC) > La carte Raspberry PI > Logiciels et langages de programmation sur RPi > Entrées/sorties GPIO sur Raspberry Pi

Entrées/sorties GPIO sur Raspberry Pi

jeudi 6 septembre 2012, par Julien H.

Cet article est un cours d’introduction aux entrées et sorties numériques sur carte Raspberry Pi, permettant de comprendre leur fonctionnement, leur connexion et de les tester depuis le shell, avant de voir leur programmation dans différents langages.

La carte Raspberry Pi donne accès à des entrées et sorties numériques appelées GPIO (en anglais "general purpose input & output") contrôlées par le processeur ARM. 

Elles sont à usage multiple :
- en entrée numérique tout ou rien, pour détecter un interrupteur par exmeple
- en sortie numérique tout ou rien, pour activer un relais par exemple
- en sortie numérique PWM, pour contrôler la puissance moyenne d’une led par exemple
- en protocole I2C, d’échanger avec une ou plusieurs puces
- en protocole SPI, idem
- en protocole UART, d’échanger avec une seule puce (ou un PC)

D’autres usages sont possibles (audio PCM, vidéo sur les connecteurs DSI et CSI), nous y reviendrons si nécessaire, contactez-nous pour toute question d’ordre technique.

Plusieurs connecteurs donnent accès aux GPIO, mais le principal est un connecteur comportant 2 rangées de 13 picots mâles distants du pas standard de 2,54 mm.

Voici les signaux qu’on peut y trouver. Certaines pattes ont deux usages, mais pour plus de simplicité, ne tenez compte que de celui indiqué sur l’image ci-dessous pour réaliser vos premiers montages.

PNG - 47.1 ko
Position du connecteur GPIO de la RPi
Image réalisée depuis Fritzing avec le modèle d’Adafruit.

Bien entendu cela limite les pattes de connexion I/O simples à 8 seulement, mais si vous voulez avoir accès aux 53 GPIO, à vos risques et périls ! Si vous avez besoin de plus de 8 pattes, il est peut-être préférable d’utiliser un circuit d’extension, mais effectivement on peut en récupérer 5 autres si on n’a pas besoin des usages spécifiques (SPI par exemple) du connecteur principal. Et encore quelques autres en se connectant sur les autres connecteurs.

Surtout, notez que le numéro de GPIO n’est pas sa position sur le connecteur, mais son numéro dans les registres de la puce ARM BCM2835. C’est donc celui qui sera utilisé dans la plupart des bibliothèques d’accès.

Premier test

Avant d’utiliser un langage de programmation pour faire son propre logiciel, voyons comment tester les pattes d’entrées/sortie depuis le shell, en ligne de commande. Cet usage est vraiment pratique et permet de tirer parti de la présence d’un système d’exploitation Linux, avec toutes les fonctionnalités disponibles en ligne de commande ou en script bash (boucles, accès aux fichiers, etc...).

On va utiliser les éléments suivants pour lire une entrée reliée à un bouton et pour faire allumer une led :

- une carte Raspberry Pi
- une distribution Linux basée sur Debian (l’Occidentalis 1.0)
- une plaque d’essai Labdec ou breadboard
- un bouton (interrupteur)
- une résistance 10k
- une led
- des fils de connexion

C’est le minimum. Vous pouvez utiliser un clavier et un écran pour utiliser un terminal de la Raspberry Pi, ou y accéder depuis un PC distant grâce à une liaison réseau Ethernet.

Le montage

Voici le schéma du circuit ainsi réalisé. Notez que la Raspberry Pi est stylisée, réduite à son connecteur d’entrées/sorties principal.

PNG - 26.5 ko
Montage simple autour du GPIO RPi

Pour les débutants, voici une vue des composants tels qu’on les implantera sur une plaque d’essai :

PNG - 41.3 ko
Implantation des composants

L’installation logicielle

Comme nous aimons la simplicité, et que nous avons choisi la Raspberry Pi pour la communauté d’experts Linux capables d’écrire de bons programmes fiables, nous n’allons pas utiliser de codes complexes mais des outils pratiques.

Pour accéder aux GPIO depuis le shell en ligne de commande, nous utiliserons donc WiringPi, une bibliothèque C et des outils de compilation partagés par Gordon sur son site.

L’installation est un peu différente de celle qu’il décrit sur son site, alors je me permets de recopier ce que j’ai fait (sur une Raspbian / Occidentalis) :

atelier@ubuntu:~$ ssh pi@10.42.0.77
pi@10.42.0.77's password: raspberry
Linux raspberrypi 3.2.27+ #102 PREEMPT Sat Sep 1 01:00:50 BST 2012 armv6l
pi@raspberrypi ~ $ sudo apt-get install git-core
...
pi@raspberrypi ~ $ mkdir gpio
pi@raspberrypi ~ $ cd gpio/
pi@raspberrypi ~/gpio $ git clone git://git.drogon.net/wiringPi
...
pi@raspberrypi ~/gpio $ cd wiringPi/
pi@raspberrypi ~/gpio/wiringPi $ git pull origin
remote: Counting objects: 11, done.
remote: Compressing objects: 100% (8/8), done.
remote: Total 8 (delta 6), reused 0 (delta 0)
Unpacking objects: 100% (8/8), done.
From git://git.drogon.net/wiringPi
  99095e3..30d79da  master     -> origin/master
Updating 99095e3..30d79da
Fast-forward
wiringPi/wiringPi.c |  108 ++++++++++++++++++++++++++++++++++++++++++--
1 file changed, 104 insertions(+), 4 deletions(-)
pi@raspberrypi ~/gpio/wiringPi $ cd wiringPi/
pi@raspberrypi ~/gpio/wiringPi/wiringPi $ sudo make install
[CC] wiringPi.c
[AR] wiringPi.o wiringPiFace.o wiringSerial.o wiringShift.o gertboard.o piNes.o lcd.o piHiPri.o piThread.o softPwm.o wiringPiSPI.o
  text           data            bss            dec            hex        filename
  5992            516            304           6812           1a9c        wiringPi.o (ex libwiringPi.a)
  1908              8              8           1924            784        wiringPiFace.o (ex libwiringPi.a)
   828              0              0            828            33c        wiringSerial.o (ex libwiringPi.a)
  1696              0              0           1696            6a0        wiringShift.o (ex libwiringPi.a)
   208              0              0            208             d0        gertboard.o (ex libwiringPi.a)
   828              0            100            928            3a0        piNes.o (ex libwiringPi.a)
  2452              0              4           2456            998        lcd.o (ex libwiringPi.a)
    76              0              0             76             4c        piHiPri.o (ex libwiringPi.a)
    76              0             96            172             ac        piThread.o (ex libwiringPi.a)
   372              4            512            888            378        softPwm.o (ex libwiringPi.a)
   420              1             20            441            1b9        wiringPiSPI.o (ex libwiringPi.a)
[install]
install -m 0755 -d /usr/local/lib
install -m 0755 -d /usr/local/include
install -m 0644 wiringPi.h        /usr/local/include
install -m 0644 wiringSerial.h        /usr/local/include
install -m 0644 wiringShift.h        /usr/local/include
install -m 0644 gertboard.h        /usr/local/include
install -m 0644 piNes.h                /usr/local/include
install -m 0644 softPwm.h        /usr/local/include
install -m 0644 lcd.h                /usr/local/include
install -m 0644 wiringPiSPI.h        /usr/local/include
install -m 0644 libwiringPi.a        /usr/local/lib
pi@raspberrypi ~/gpio/wiringPi $ cd ../gpio/
pi@raspberrypi ~/gpio/wiringPi/gpio $ sudo make install
cp gpio /usr/local/bin
chown root.root /usr/local/bin/gpio
chmod 4755 /usr/local/bin/gpio
mkdir -p /usr/local/man/man1
cp gpio.1 /usr/local/man/man1
pi@raspberrypi ~/gpio/wiringPi/gpio $

Les dernières commandes sont très importantes : elles copient le programme binaire compilé dans un répertoire permettant l’accès à la commande depuis n’importe où sur votre Linux. Elles installent aussi le manuel au bon endroit pour être appelé.

Si quelqu’un vous répond "RTFM" quand vous posez une question sur un programme, cela signifie "read the famous man" (en édulcoré), et il faut alors exécuter la commande man suivie du nom de l’exécutable concerné, depuis n’importe quel répertoire. Tapez "q" pour sortir.

pi@raspberrypi ~ $ man gpio
GPIO(14 June 2012)                                          GPIO(14 June 2012)

NAME
      gpio - Command-line access to Raspberry Pi and PiFace GPIO

SYNOPSIS
      gpio -v
      gpio [ -g ] read/write/pwm/mode ...
      gpio [ -p ] read/write/mode ...
      gpio unexportall/exports
      gpio export/edge/unexport ...
      gpio drive group value
      gpio pwm-bal/pwm-ms
      gpio pwmr range
      gpio load  i2c/spi
...

Il y a plusieurs pages. Vous pouvez les lire ou suivre nos tests.

Les tests

On a connecté la Raspberry au montage présenté plus haut, avec un signal d’entrée/sortie (interrupteur ou led) sur la patte 7 du connecteur, correspondant à la GPIO 4 de la Raspberry Pi.

PNG - 374 ko
Montage simple led + bouton
Cela ressemble au schéma, non ?

Selon l’explication donnée dans le manuel (man gpio), on pourra utiliser de manière équivalente les instructions suivantes :

pi@raspberrypi ~ $ gpio -g mode 4 out
pi@raspberrypi ~ $ gpio mode 7 out

On préférera la première écriture, qui sensibilise à l’usage général des GPIO et permettra d’aller vérifier les autres modes disponibles sur la patte 4 dans la doc du ARM BCM2835.

Voici pour éteindre la led puis la rallumer :

pi@raspberrypi ~ $ gpio -g mode 4 out
pi@raspberrypi ~ $ gpio -g write 4 1
pi@raspberrypi ~ $ gpio -g write 4 0

Pour lire l’état (il change en appuyant sur le bouton) :

pi@raspberrypi ~ $ gpio -g mode 4 in
pi@raspberrypi ~ $ gpio -g read 4
1
pi@raspberrypi ~ $ gpio -g read 4
0
pi@raspberrypi ~ $

On peut maintenant écrire un script bash :

pi@raspberrypi ~/gpio $ nano test.sh
#!/bin/bash

setup ()
{
 echo Setup
 gpio -g mode 4 in
}

waitButton ()
{
 echo -n "Waiting for button ... "
 while [ `gpio -g read 4` = 1 ]; do
   sleep 0.1
 done
 echo "Got it"
}

setup
while true; do
 waitButton
done

Un petit CTRL+O pour enregistrer et CTRL+X pour sortir et vous pouvez exécuter le programme :

pi@raspberrypi ~/gpio $ chmod 755 test.sh
pi@raspberrypi ~/gpio $ ./test.sh
Setup
Waiting for button ... Got it
Waiting for button ... Got it
Waiting for button ... Got it
Waiting for button ... Got it

Et là vous aurez atteint l’échelon numéro 1 en électronique ludique : vous avez découvert le problème de la détection de l’appui sur un bouton, avec la nécessité de détecter le passage sur un front (nom donné à un changement d’état) plutôt que sur l’état lui-même.

Vous pouvez maintenant rejoindre un club de robotique qui vous apprendra des solutions logicielles ou matérielles à ce problème... en attendant l’échelon 2 (nom de code : anti-rebond).

Vos commentaires

  • Le 30 juin 2013 à 00:49, par nathan0407 En réponse à : Entrées/sorties GPIO sur Raspberry Pi

    bonjour , je n arrive pas a installer wiringpi ,je bloque depuis 4 jours comprend pas
    help

    Répondre à ce message

  • Le 8 octobre 2014 à 16:23, par kouraichi En réponse à : Entrées/sorties GPIO sur Raspberry Pi

    bonjour ,Je travaille actuellement sur un projet utilisant principalement le raspberry.sous le theme modbus tcp sur raspberry le probléme que j’arrive pas gerer les composant entre sortiee et aussi parmi les objectifs c’est developé une application gérant la connexion modbus /tcp sur la arte vous pouvez m’aider s’il vous plait

    • Le 14 octobre 2014 à 23:32, par Eric P. En réponse à : Entrées/sorties GPIO sur Raspberry Pi

      Bonsoir,
      Les commentaires aux articles sont prévus pour poster des questions ou des commentaires sur les articles.
      Pour les demandes d’aides, utiliser le formulaire de contact, qui permettra d’initialiser une discussion par email, plus adaptée à ce type d’échanges.
      Cordialement
      Eric

    Répondre à ce message

  • Le 23 juillet 2014 à 17:06, par paul En réponse à : Entrées/sorties GPIO sur Raspberry Pi

    bonjour j’ai un petit souci avec le wiringPi il me dit que j’ai pas la permission, pouvez vous m’aider ?

    • Le 31 juillet 2014 à 14:05, par Julien H. En réponse à : Entrées/sorties GPIO sur Raspberry Pi

      Bonjour,
      Vous n’avez pas les droits d’écriture sur le répertoire /gpio.
      Vous pouvez soit modifier les droits de ce répertoire (sudo chmod +wx ../gpio/) soit utiliser la commande sudo pour récupérer le programme d’installation de wiringPi (sudo git clone ...).
      Cordialement,
      Julien.

    Répondre à ce message

  • Le 7 avril 2014 à 17:10, par Fetra En réponse à : Entrées/sorties GPIO sur Raspberry Pi

    Bonjour,
    Je travaille actuellement sur un projet utilisant principalement le raspberry. Je voudrais avoir des retours de votre part sur la faisabilité de celui-ci.
    En gros, je voudrais réaliser une espèce de "pédale de boucle" pour guitare électrique dont les fonctions principales seraient : Acquisition, traitement puis reconstitution du son. Tout ceci utilisant le raspberry.
    Est-il ainsi possible d’acquérir du signal son numérique avec le GPIO ?
    Et quelle bibliothèque faudrait-il installer pour permettre au raspberry de jouer les sons ainsi traités ?
    En vous remerciant déjà pour votre réponse.

    • Le 7 avril 2014 à 18:16, par Eric P. En réponse à : Entrées/sorties GPIO sur Raspberry Pi

      Bonjour,
      Il n’y a pas (à ma connaissance) de possibilité d’acquérir un signal audio sur les GPIO de la RasPi, et elle ne comporte pas d’entrée audio non plus. Certains ont réussi à faire des choses par le biais de cartes son USB (cf www.g7smy.co.uk/?p=283 par exemple). On retrouve quelques éléments via Google(raspberry audio acquisition).
      Ceci étant, indépendamment du problème de l’interface physique, je doute que la RasPi soit suffisamment musclée pour numériser un signal et le traiter en temps réel.
      Cordialement
      Eric

    • Le 7 avril 2014 à 18:47, par Fetra En réponse à : Entrées/sorties GPIO sur Raspberry Pi

      Merci beaucoup pour votre réponse.
      En somme j’avais prévu une partie numérisation avant la raspberry et seul le traitement en temps réel et la reconstituition se ferait par le raspberry. Le problème c’est que je ne sais par où commencer pour permettre au raspberry d’acquérir le signal déjà numérisé et de lui faire traiter.
      Cordialement
      Fetra

    • Le 7 avril 2014 à 19:03, par Eric P. En réponse à : Entrées/sorties GPIO sur Raspberry Pi

      Tout dépend de la solution utilisée pour la numérisation. En fait c’est ce que font les cartes son USB sur lesquelles j’ai donné les pointeurs. La récupération des données est possible vie les libs Linux telles que Alsa et autres. L’article que j’ai référencé aborde le sujet me semble-t-il.
      Cordialement
      Eric

    Répondre à ce message

  • Le 5 mars 2014 à 22:26, par anthony En réponse à : Entrées/sorties GPIO sur Raspberry Pi

    bonjour,
    comment puis je faire pour augmenter le nombre de GPIO car voici ce que j’aimerais faire :
    je suis en BTS maintenance industrielle et j’aimerai faire une amélioration sur une machine ,
    pour cela je ferais une sorte de redondance en mettant des capteurs de tension sur des capteurs de présence de pièces par exemple
    je verifirai l’état des capteurs en installant un serveur HTTP sur le raspberry et en suivant un peu le tuto se situant ici ---> http://blog.idleman.fr/raspberry-pi-13-detecter-louverture-des-portes-et-fenetres/

    je rechangerai un peut le code pour l’adapter a ma situation mais le probleme est que je ne pence pas avoir assez de patte GPIO ^^ si quelqu’un a une meilleur idée je suis preneur :) .

    Répondre à ce message

  • Le 29 janvier 2014 à 17:10, par Simbabou En réponse à : Entrées/sorties GPIO sur Raspberry Pi

    Bonjour,
    Est-il possible d’utiliser les port GPIO comme un interrupteur sans fournir de courant (genre d’interrupteur électronique). Je souhaite pouvoir allumer une carte mère de PC (qui a déjà son alimentation) donc ne pas lui rajouter du courant pour ne pas l’endommager.
    Merci d’avance
    Simbabou

    • Le 5 février 2014 à 07:40, par Julien H. En réponse à : Entrées/sorties GPIO sur Raspberry Pi

      Oui tout à fait, c’est justement leur usage (ils ne fournissent pas un courant suffisant). On peut utiliser un transistor, un mosfet, un relais pour servir d’interrupteur, selon la tension à couper.

    Répondre à ce message

  • Le 18 juin 2013 à 23:34, par hawai_romain En réponse à : Entrées/sorties GPIO sur Raspberry Pi

    bonjour est que ce possible d’utilise les gpio pour commande la prise de photo/video avec la camera pour raspebbery pi ?
    https://www.modmypi.com/raspberry-pi-expansion-boards/raspberry-pi-camera-board

    • Le 18 juin 2013 à 23:51, par Eric P. En réponse à : Entrées/sorties GPIO sur Raspberry Pi

      Il me semble qu’il n’est pas du tout nécessaire d’utiliser les GPIO pour cela.

      Pour s’en convaincre il suffit de noter qu’un outil comme RasPiStill (https://www.modmypi.com/blog/raspberry-pi-camera-board-raspistill-command-list) effectue des prises de vue sans cela. En fait le contrôle de la caméra se fait au travers des signaux véhiculés par le câble en nappe qui la relie à la RasPi.

      Eric

    • Le 19 juin 2013 à 00:06, par hawai_romain En réponse à : Entrées/sorties GPIO sur Raspberry Pi

      en clair ? puis pour faire un appareil photo/camera sa a pas l’air pratique

    • Le 19 juin 2013 à 00:29, par Eric P. En réponse à : Entrées/sorties GPIO sur Raspberry Pi

      Je ne comprends pas quelle est la question. Pourriez-vous être plus clair et précis sur ce que vous cherchez à faire.

      Si le but est de faire un appareil photo, eh bien... autant acheter un appareil photo :) Ce sera toujours plus pratique à utiliser qu’une RasPi avec sa caméra et son alimentation.

      Soyez plus explicite sur ce que vous cherchez à réaliser si vous voulez que nous vous aidions à trouver une solution.

      Eric

    • Le 19 juin 2013 à 00:45, par hawai_romain En réponse à : Entrées/sorties GPIO sur Raspberry Pi

      je pensez être clair prendre une photo en appuyant sur un bouton et sur un autre prendre une vidéo
      et pour l’alimentation de mon raspberry j’utilise une batterie d’airsoft

    • Le 19 juin 2013 à 10:40, par Julien H. En réponse à : Entrées/sorties GPIO sur Raspberry Pi

      On peut effectivement utiliser une entrée de la Raspberry Pi pour déclencher un programme (par exemple une prise de vue). Il suffit de relier un interrupteur normalement ouvert ("microrupteur à contact NO" chez les distributeurs de composants électroniques) à la masse, à la GPIO de votre choix et via une résistance de 10kOhms à la tension 3.3 volts également disponible sur le connecteur de la Raspberry Pi.

      Il y a des exemples en Python pour contrôler les GPIO : il suffit ensuite d’appeler la commande de prise de vue de votre choix.

      Cordialement,
      Julien.

    • Le 19 juin 2013 à 23:14, par Eric P. En réponse à : Entrées/sorties GPIO sur Raspberry Pi

      Je comprends mieux maintenant. Vous vouliez utiliser une GPIO en entrée pour fournir le signal de déclenchement, et non pas en sortie pour contrôler la caméra. Le message initial était un peu ambigu.

      Julien a donné la réponse qui va bien.

      Attention cependant un "détail" important : les GPIO de la RasPi ne sont pas du tout protégées contre les surcharges ou autres maladresses, et on a vite fait de les griller définitivement si on ne prend pas quelques précautions. Comment le signal de déclenchement est-il prévu : par un simple bouton poussoir connecté à une GPIO ou bien en provenance d’un autre circuit électronique ?

      Rien à voir avec ce qui précède, mais SVP essayez de relire vos messages avant de les poster pour en retirer le plus de fautes d’orthographe possible et utilisez le correcteur orthographique disponible dans tout navigateur Web digne de ce nom. Trop de fautes dans un texte tendent à le rendre beaucoup moins compréhensible par ceux qui le lisent. Merci d’avance pour votre compréhension ;)

    Répondre à ce message

  • Le 21 mars 2013 à 19:01, par dim En réponse à : Entrées/sorties GPIO sur Raspberry Pi

    Tres bon article !

    cependant j’ai une question savez vous si l’on peux reprendre un signal video analogique sur une broche GPIO ? pour pouvoir faire une "webcam" avec un appareil photo (ça ne passe pas en usb)

    merci

    cordialement

    Répondre à ce message

  • Le 18 septembre 2012 à 22:22, par ? En réponse à : Entrées/sorties GPIO sur Raspberry Pi

    Bonjour,

    j’ai une RPi et j’ai suivi votre tutoriel à la lettre, mais j’ai une erreur qui apparait juste après ces 2 commandes :
    pi@raspberrypi /gpio/wiringPi $ cd ../gpio/

    pi@raspberrypi /gpio/wiringPi/gpio $ sudo make install

    J’ai le message suivant qui apparait :
    cp gpio /usr/local/bin

    cp : cannot stat `gpio’ : No such file or directory

    make : *** [install] Error 1

    Effectivement il n’y a pas de répertoire "gpio". Est-ce qu’il faut faire "cd .." ?
    Voici ce que la commande "ls" me retourne :
    pi@raspberrypi /gpio/wiringPi/gpio $ ls

    COPYING.LESSER gpio.1 gpio.c Makefile test.sh

    Merci d’avance pour votre aide.

    • Le 18 septembre 2012 à 22:52, par Julien H. En réponse à : Entrées/sorties GPIO sur Raspberry Pi

      Bonjour,

      Peut être "make" avant "make install" ? Je retesterai ce week-end.

      Cordialement,
      Julien.

    • Le 20 septembre 2012 à 21:34, par cristobal En réponse à : Entrées/sorties GPIO sur Raspberry Pi

      actuellement en master nous devons réalisé à l’aide du rasBerry une tondeuse autonome on dispose de capteur de chocs de capteur inductif, capteur de soulèvement moteur de coupe , moteur roue motrice , batterie et un arrêt d’urgences dessus pouvez vous nous aider pour la programmation sous linux

    • Le 20 septembre 2012 à 23:02, par Julien H. En réponse à : Entrées/sorties GPIO sur Raspberry Pi

      Bonjour,

      Tout à fait, ce sera un plaisir de vous aider. Avez-vous fait un schéma du circuit ?

      Cordialement,
      Julien.

    • Le 1er février 2013 à 20:09, par cristobal En réponse à : Entrées/sorties GPIO sur Raspberry Pi

      pouvez vous me dire
      comment faire pour lancer automatiquement un programme au demarrage du RPI sans passer par le mot de passe et password ?

      cordialement
      christophe dépret

    • Le 3 février 2013 à 01:06, par Julien H. En réponse à : Entrées/sorties GPIO sur Raspberry Pi

      Bonjour,

      Il s’agit plus d’une question concernant Linux et les principes de boot que d’un point spécifique à la Raspberry Pi.

      Cordialement,
      Julien.

    Répondre à ce message

  • Le 4 janvier 2013 à 21:56, par ? En réponse à : Entrées/sorties GPIO sur Raspberry Pi

    Comment fait on en c++ pour lire l’état d’un port du gpio ?

    • Le 6 janvier 2013 à 17:49, par Julien H. En réponse à : Entrées/sorties GPIO sur Raspberry Pi

      Bonjour,

      En installant WiringPi, vous obtenez également (en plus de l’outil shell gpio) les fichiers C++ que vous pouvez utiliser depuis votre code :


      #include <wiringPi.h>

      #include <stdio.h>
      #include <stdlib.h>
      #include <stdint.h>

      int main (void)

      if (wiringPiSetup () == -1)
      exit (1) ;

      pinMode (4, OUTPUT) ;
      pinMode (7, INPUT) ;

      for ( ; ;)

      if (digitalRead(7)==0)
      digitalWrite(4,HIGH) ;
      else
      digitalWrite(4,LOW) ;

      return 0 ;

      Ce qui allume ou éteint une led sur la patte 4 selon qu’on appuie ou pas sur un bouton relié sur la patte 7.

    Répondre à ce message

Un message, un commentaire ?

modération a priori

Attention, votre message n’apparaîtra qu’après avoir été relu et approuvé.

Qui êtes-vous ?

Pour afficher votre trombine avec votre message, enregistrez-la d’abord sur gravatar.com (gratuit et indolore) et n’oubliez pas d’indiquer votre adresse e-mail ici.

Ajoutez votre commentaire ici

Ce champ accepte les raccourcis SPIP {{gras}} {italique} -*liste [texte->url] <quote> <code> et le code HTML <q> <del> <ins>. Pour créer des paragraphes, laissez simplement des lignes vides.