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.

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.

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 :

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.

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 [ <span class="base64" title="PGNvZGUgY2xhc3M9InNwaXBfY29kZSBzcGlwX2NvZGVfaW5saW5lIiBkaXI9Imx0ciI+Z3BpbyAtZyByZWFkIDQ8L2NvZGU+"></span> = 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 20 mars 2017 à 16:19, par Bernard En réponse à : Entrées/sorties GPIO sur Raspberry Pi

    Comment fait on pour l’audio via le GPIO alors ?

    • Le 22 mars 2017 à 23:45, par Eric P. En réponse à : Entrées/sorties GPIO sur Raspberry Pi

      De l’audio sur le GPIO ? Ben, on ne fait pas, car il y a une sortie audio pour cela.
      Vous pouvez toujours produire un signal rectangulaire à fréquence variable pour générer des bips et autres tonalités, mais ce n’est pas franchement le plus simple. D’autant plus que Linux n’étant pas un système temps réel, produire un signal périodique stable dans la bande de fréquence 1 kHz-20 kHz n’est pas réellement possible, sauf à tolérer des jitters importants du fait des latences introduites par le système.
      Pouvez-vous préciser quelle est l’application recherchée et pour quelle raison vous voulez générer un signal audio sur une GPIO plutôt que d’utiliser la sortie audio standard ?

    Répondre à ce message

  • Le 24 avril 2017 à 01:12, par souhir En réponse à : Entrées/sorties GPIO sur Raspberry Pi

    svp je besoin de programme qui donne un signal PWM

    • Le 6 mai 2017 à 11:53, par Eric P. En réponse à : Entrées/sorties GPIO sur Raspberry Pi

      Bonjour,
      La Raspberry n’est pas faite pour générer des signaux précis sur ses GPIO. La raison en est que Linux n’est pas un système temps réel (sauf à utiliser des versions spécialement modifiées en ce sens) et que du fait qu’un certain nombre de process s’exécutent en plus de votre programme, il n’y a aucune garantie quant à la précision et à la stabilité tant de la fréquence du signal que de son rapport cyclique.
      Il faut donc que la RPi délègue cette tâche à un périphérique dédié, en communiquant avec lui pour paramétrer le rapport cyclique si nécessaire. Deux options sont possibles :
       une Arduno dans laquelle tourne un programme qui gère la communication avec la RPi (en série, SPi ou I2C) et la production du PWM sur une des ses IO
       un chip spécialisé pour cela, comme les générateurs de PWM utilisés pour driver des LEDs.
      Je vous conseille vivement la deuxième option car elle marche directement, et on trouve par ailleurs pas mal de petites cartes qui proposent ces chips et leurs composants annexes d’une manière simplifiant la mise en oeuvre. Un bon exemple en est la ServoPi de ABElectronics, décrite dans cet article.
      Cordialement

    Répondre à ce message

  • Le 28 novembre 2016 à 21:34, par vincent j. En réponse à : Entrées/sorties GPIO sur Raspberry Pi

    bonjour,
    les sorties +3,3V & +5V sont-elles alimentées par défaut, ou faut-il les commander ?
    j’ai connecté un ventilateur, fourni avec le boitier, sur chacune des 2 alimentations, et rien ne se passe...
    une idée ?...
    cordialement.

    • Le 18 mars 2017 à 14:03, par Eric P. En réponse à : Entrées/sorties GPIO sur Raspberry Pi

      Les sorties 5V et 3.3V sont reliées respectivement
      * à l’alimentation 5V (en sortie du poly-fuse - fusible réarmable)
      * à la sortie du régulateur 3.3V.
      Elles sont donc alimentées en permanence.
      Comme vous ne dites rien sur les caractéristiques du moteur du ventilateur, impossible de répondre. Ceci étant s’il est censé fonctionner en 12V par exemple, eh bien vous avez l’explication 😕
      Attention : la sortie 3.3V a une capacité en courant très faible (quelques 10aines de mA seulement). Si vous y avez connecté votre ventilateur et que votre RPi fonctionne toujours, vous avez une sacrée veine de ne pas avoir grillé le régulateur 🙂
      Cordialement

    Répondre à ce message

  • Le 8 janvier 2017 à 20:07, par ZILORIC En réponse à : Entrées/sorties GPIO sur Raspberry Pi

    Bonjour,
    Mon robot Husqvana 105 n’étant pas compatible avec l’application Automower disponible sur smartphone, j’aimerai créer un petit programme afin d’être informé quand automower ne rentre pas sur sa base
    je dispose d’un capteur de position a galet collé avec un adhésif spécial extérieur sur la base et un ordinateur monocarte Raspberry Pi 1B qui exécuterai un programme Java qui récupère les événements du capteurs (état 1 = "Robot sur sa Base" ou état 0 = "Robot Sortie").
    Si le robot ne rentre pas dans les 2h après son départ, je le considère perdu dans le jardin,et déclenchement de l’alerte par mail ou texto par l’envoi d’un URL "Alerte Robot non Rentré".
    (D’après mes constatations, il tond au maxi 1h45 et reste sur sa base de charge environ 1h.)
    Merci de me créer ce petit programme et de me dire ou raccorder les fils du contact en entrée sur mon raspberry Pi car je ne connais rien en programmation :(
    Vous pouvez me répondre par email : ziloric@hotmail.fr merci et
    Cordialement, Patrick

    • Le 17 février 2017 à 14:52, par Eric P. En réponse à : Entrées/sorties GPIO sur Raspberry Pi

      Bonjour,
      La solution ne se réduit pas à raccorder le fils sur la Raspberry, et il est nécessaire d’écrire un programme pour gérer le signal récupéré et exécuter les diverses actions.
      Nous ne développons pas de programmes à la demande malheureusement. Nous sommes tous des bénévoles, avec une activité professionnelle par ailleurs, et ne disposons pas du temps disponible pour répondre à ce genre de demande. Nous pouvons aider à le faire, mais cela ne semble pas vraiment correspondre à votre situation si vous n’y connaissez rien à la programmation comme vous le dites.
      Ne serait-ce pas une occasion pour s’y initier ? Ce que vous voulez faire peut être réalisé sans difficulté avec un langage comme Python disponible en standard sur la Raspberry.
      Cordialement

    Répondre à ce message

  • Le 22 septembre 2016 à 16:44, par Léandre En réponse à : Entrées/sorties GPIO sur Raspberry Pi

    Bonjour,
    j’ai depuis quelques temps une Raspberry 2, mais un problème subsiste sur le gpio.
    lorsque j’appelle des broche pour allumer simplement une leds, celle qui s’active n’est pas la bonne.
    exemples :
    la broche 1 dans le programme devient la broche physique 29
    2=>28
    3=>26
    5=>23
    6=>19
    8=>38
    je ne comprends vraiment pas pourquoi, je suis sûr d’avoir bien branché la nappe sur la raspberry.
    Merci de votre aide. :’-(

    • Le 16 octobre 2016 à 16:00, par Eric P. En réponse à : Entrées/sorties GPIO sur Raspberry Pi

      Il y a deux modes d’identification des pins du connecteur GPIO :
       le mode "board", correspondant à la numérotation du connecteur
       le mode "Broadcom", correspondant à la numérotation des pins correspondantes du processeur
      On peut choisir celui qu’on utilise dans le programme via une des fonctions de la lib (setMode ou quelque chose d’approchant).
      Ce qui vous arrive est très certainement causé par le fait que votre programme utilise un mode alors que la lib GPIO est configurée dans l’autre (qui est son mode par défaut si vous n’avez rien fait de particulier sur ce point).

    Répondre à ce message

  • Le 25 janvier 2016 à 19:01, par joel76 En réponse à : Entrées/sorties GPIO sur Raspberry Pi

    bonjour
    j’ai un raspberry pi 2 et j’ai grillé le pin 35 ( gpio19), j’utilise un programme qui me génère des signaux carré I Q sur le pin 12 ( gpio18) et 35 ( gpio 19), et donc le pin 35 ne sort plus rien donc hs, serait-t-il possible de diriger le pin 35 vers 37 par exemple ou autres ? en ligne de commande
    je vous remercie
    Joël

    • Le 25 janvier 2016 à 21:13, par Julien H. En réponse à : Entrées/sorties GPIO sur Raspberry Pi

      Bonjour,
      Non malheureusement, les GPIO sont liées au matériel et certaines fonctions sont spécifiques à certaines pattes donc on ne peut pas recopier logiciellement une fonctionnalité sur une autre patte.
      Mais êtes-vous certain que c’est "grillé" ? Est-ce qu’il n’y a pas plutôt un autre programme qui inhibe le fonctionnement souhaité de la patte 35 ?

    Répondre à ce message

  • Le 22 août 2015 à 22:32, par Nicolas G En réponse à : Entrées/sorties GPIO sur Raspberry Pi

    Bonjour, je n’ai que des rudiments vraiments basiques en prog et en électronique, mais j’aimerais réaliser une interface basée sur le raspberyy pi pour lire des entrées (8), les mouliner dans un programme et piloter des sorties (5) en fonction de cela. j’aimerais adjoindre à ce programme une fonction pour un écran d’affichage.
    Comment faire ? qui consulter ? devant la multiplicité des forums, je m’avoue un peu perdu :S

    • Le 23 août 2015 à 16:52, par Eric P. En réponse à : Entrées/sorties GPIO sur Raspberry Pi

      Oulà, il y a du taf si tu n’as que quelques rudiments basiques, mais ça peut être une bonne occasion pour les transformer en vraie connaissances.
      1/ les entrées-sorties : quelles sont les plages de tension des entrées, des courants à piloter sur les sorties,... ? Cela a une incidence sur les solutions matérielles. Il y a pas mal de cartes d’extension pour la RasPi, et j’ai un petit faible pour les produits de AB Electronics (https://www.abelectronics.co.uk/). Cherche sur notre site les articles qui en parlent.
      2/ l’interface utilisateur : s’il y a un écran connecté sur la RasPi, et qu’on utilise donc l’environnement graphique, nous sommes sous un Linux classique avec serveur X, et donc les outils classiques tels que Qt, vxwidegets,... sont disponibles. Si la RasPi est en config headless (i.e "boite noire") la plupart du temps on y développe une application Web (c’est moins compliqué qu’il n’y parait), et là encore il y a des articles sur notre site qui en parlent). Il y a d’autres options encore, mais ne compliquons pas 😉
      On pourrait écrire des articles entiers sur les sujets que tu mentionnes, et par conséquent impossible de réponse dans un simple commentaire (limité à 500 caractères par-dessus le marché).
      De toute manière, il faut en premier lieu que tu précises un peu mieux le besoin et le contexte de fonctionnement de la RasPi (cf plus haut). On pourra essayer d’approfondir en fonction.
      Bon courage 😐

    Répondre à ce message

  • Le 14 février 2014 à 10:35, par Jean-Claude En réponse à : Entrées/sorties GPIO sur Raspberry Pi

    Bonjour et merci de me lire,

    J’ai en tête de piloter un appareil photo reflex via son entrée telecomande filaire
    j’aurai besoin donc d’un port gpio qui me piloterai le reflex via un transistor
    de façon à faire un "timelapse" une photo toutes les x secondes pendant xx secondes
    je ne me suis pas encore penché sur la programmation python ou autre et je pensai pour le faire
    directement avec un programme linux genre "cron" (je dit peut être une bêtise...)

    qu’en pensez vous ?
    merci d’avance pour votre aide

    Cordialement
    Jean-Claude

    • Le 14 février 2014 à 10:47, par Eric P. En réponse à : Entrées/sorties GPIO sur Raspberry Pi

      Ca peut fonctionner, en sachant que cependant que la résolution temporelle de cron est la minute. Autrement dit, impossible de configurer un délai inférieur à cette valeur et d’utiliser une période non multiple de la minute.

      De plus, le délai réel entre deux actions va inclure celui nécessaire à recréer le process du programme ou du script déclenché par cron. Ce qui peut introduire une variabilité non contrôlable.

      La solution qui donne entière liberté est de gérer le temps au sein même du programme ou du script, au moyen d’une boucle générale utilisant les diverses fonctions permettant de gérer des délais, récupérer l’instant courant, le comparer à l’instant où on souhaite exécuter l’action,...

    Répondre à ce message

  • Le 18 mars 2015 à 11:28, par FY En réponse à : Entrées/sorties GPIO sur Raspberry Pi

    bonjour,
    je veux commander un GPIO via un autre GPIO,
    Le pin 7 par ex reçoit le signal venant du luxmètre, l’autre GPIO (pin 11), commande l’allumage ou extinction lampe suivant ce signal.
    Comment faire pour le réaliser, est-ce possible ?
    merci
    cdt

    • Le 22 mars 2015 à 10:11, par Eric P. En réponse à : Entrées/sorties GPIO sur Raspberry Pi

      Bien sûr que c’est possible :)
      Comment ? En écrivant un programme qui va lire la valeur de la GPIO en entre (le luxmètre ici) et modifier l’état de la GPIO qui pilote la lampe en conséquence.
      Attention avec votre exemple : la Raspberry n’a pas de GPIO faisant fonction d’ADC. Il lui est donc impossible de faire l’acquisition d’un signal analogique, sauf à à adjoindre une extension telles que les cartes AB Electronics dont nous parlons dans certains de nos articles ou autres montage équivalent.

    Répondre à ce message

  • Le 5 juillet 2013 à 00:38, par nathan0407 En réponse à : Entrées/sorties GPIO sur Raspberry Pi

    et la suite

    • Le 5 juillet 2013 à 08:15, par Julien H. En réponse à : Entrées/sorties GPIO sur Raspberry Pi

      Bien ! Donc il y a un message d’erreur à la compilation indiquant qu’il te manque l’I2C sur ta machine. Essaie une recherche sur le nom de la référence inconnue dans Google avec le nom de ton OS ("i2c_smbus Ubuntu" par exemple).

    • Le 5 juillet 2013 à 09:48, par Eric P. En réponse à : Entrées/sorties GPIO sur Raspberry Pi

      Je suggère la lecture des articles qui portent sur la RasPi et l’I2C sur notre site. Le moteur de recherche aidera à les trouver, mais on peut déjà aller faire un tour sur celui-ci : http://www.pobot.org/RasPi-I2C-Python-et-LCD.html

      On y voit par exemple un paragraphe relatif à l’installation du support SMBus, autrement dit System Message Bus, qui n’est d’autre qu’un bus I2C.

    • Le 25 juillet 2013 à 19:28, par nathan0407 En réponse à : Entrées/sorties GPIO sur Raspberry Pi

      bonjour , j ai des probleme avec mon raspbery il me claque toute mes carte sd .
      j en suis a ma 4 eme carte toute de marque differente ( samsung, scan disck ect....)es ce que vous auriez une idée pourquoi
      ps mon alim fait 5v 600 ma

    • Le 25 juillet 2013 à 21:59, par Julien H. En réponse à : Entrées/sorties GPIO sur Raspberry Pi

      Bonjour,

      L’alimentation est en-dessous du courant requis (700 mA minimum). Donc des incidents peuvent plus fréquemment se produite et endommager la carte mémoire.

    • Le 26 juillet 2013 à 09:42, par Eric P. En réponse à : Entrées/sorties GPIO sur Raspberry Pi

      Pour compléter la réponse faite par Julien, ce qui importe avant tout c’est la qualité de la stabilisation de l’alimentation.

      En effet, mesures à l’appui, la consommation de la RasPi est en-dessous des 600mA (sur la mienne j’ai mesuré dans les 430mA, que la session graphique soit utilisée ou non, ce qui indique au passage qu’aucune optimisation n’est faite au niveau de la mise en sommeil du hardware non sollicité).

      Le problème est que la plupart des blocs d’alimentation bon marché ont une stabilisation voisine du néant, et voient leur tension de sortie baisser bien avant d’arriver à la limite en courant indiquée dans leurs caractéristiques.

      C’est la raison pour laquelle on voit préconiser la plupart du temps une alim capable de délivrer 1A, de manière à être très éloigné du point où la courbe de stabilisation va commencer à s’effondrer.

      J’ai pu vérifier tout ceci en alimentant la RasPi avec une alimentation stabilisée de labo, dont j’ai réglé progressivement la limitation du courant jusqu’au seuil d’instabilité. J’étais bien en-dessous de 1A, et à une valeur dans l’ordre de grandeur cité plus haut. Il faut à ce niveau prendre en compte les pics fugitifs de consommation qui peuvent provoquer une chute de tension simultanée si la limite en courant de l’alimentation est en-dessous de leur valeur crête.

    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.