Faire clignoter une LED sur un raspberry pi

Publié le par
Répondre

Avoir un raspberry pi c’est bien… Le faire fonctionner c’est mieux ! 😀

Comme première prise en main, je vous propose un petit montage simple permettant de faire clignoter une LED avec le Raspberry pi.

Avant de commencer, quelques petites précautions s’imposent… Je ne veux pas cramer mon raspberry ! :p Un petit tour sur les spécifications du GPIO nous apprend que :

  • Les broches du GPIO délivrent un courant de 3,3V
  • Une broche ne peut pas délivrer plus de 16 mA (intensité réglable programmatiquement entre 2 mA et 16 mA par pas de 2 mA)
  • La broche P1 (3,3V) ne délivre pas plus de 50 mA
  • De manière générale, la somme des intensités utilisés des broches du GPIO ne doit pas dépasser 50 mA.
  • Il est possible d’utiliser la broche P2 (5V), mais dans ce cas, il faut que l’alimentation du raspberry délivre au moins 700 mA + la consommation du circuit branché sur la broche

Toute ces informations sont décrites sur ce lien : http://www.mosaic-industries.com/embedded-systems/microcontroller-projects/raspberry-pi/gpio-pin-electrical-specifications

Comme une broche du raspberry ne pourra pas délivrer plus de 16 mA, il est possible de brancher en directe une LED sur la broche… Mais je ne le conseil pas ! Il est toujours préférable de placer une résistance pour limiter l’intensité. Dans ce cas, il suffit d’utiliser une résistance de 3.3V / 0.01 A = 330 ohms. La diode sera alimentée par un courant de 10 mA.

Maintenant, je vais vous proposer un petit montage simple permettant d’utiliser moins d’1 mA sur une broche tout en pilotant l’allumage d’une diode. Pour ce faire, nous aurons besoin d’un transistor (2N2222 – un classique :p) et d’une résistance de plus.

Voici le schéma (les explications sont incluses dans le schéma) :

Schéma pour piloter une LED via une broche du GPIO

Schéma pour piloter une LED via une broche du GPIO

Une fois le schéma réalisé, il ne reste plus qu’à créer un petit programme pour faire clignoter la LED. Voici un exemple en python (La broche utilisée est la P11 nommée GPIO_17) :

import RPi.GPIO as GPIO
import time
# blinking function
def blink(pin):
        GPIO.output(pin,GPIO.HIGH)
        time.sleep(1)
        GPIO.output(pin,GPIO.LOW)
        time.sleep(1)
        return
# to use Raspberry Pi board pin numbers
GPIO.setmode(GPIO.BOARD)
# set up GPIO output channel
GPIO.setup(11, GPIO.OUT)
# blink GPIO17 50 times
for i in range(0,50):
        blink(11)
GPIO.cleanup()

Premiers pas avec les microcontrôleurs AVR

Publié le par
Répondre

Pour ce retour après plus d’un an, je me suis décidé à faire un article sur mes premiers pas avec les microcontrôleurs AVR.

J’ai débuté avec l’ATtiny48PU. Ce dernier est en support PDIP 28 broches (je ne suis pas fan des composants CMS car je n’ai pas le matos pour les souder… Et encore moins pour graver les PCB avec des pistes aussi fines !). Bref, ce microcontrôleur est a mon sens très bien pour débuter pour plusieurs raisons :

  • Pas trop onéreux
  • Support du protocole SPI
  • Support du protocole TWI (ou I2C)
  • Possède plusieurs ADC (Analogique Digital Converter)
  • 4 Ko de mémoire flash
  • 64 bytes d’EEPROM
  • 256 bytes de SRAM
  • Programmation ISP (In System Programmable)
  • Etc…

Je ne vais pas faire toute la liste des trucs sympas, Atmel l’a déjà fait pour moi : http://www.atmel.com/Images/doc8008.pdf.

Après avoir fait quelques essais de programmation en assembleur (faire clignoter une LED), j’ai très vite basculé dans un univers plus connu pour moi : Le langage C. En effet, l’assembleur ne m’est pas familier et je n’ai pas le désire aujourd’hui d’apprendre ce langage.

Un point très sympa avec les microcontrôleurs est que les outils de développement sont gratuits ! Il y en a à foison sur Internet… Personnellement, je ne me suis pas embêté, j’ai pris l’outil de développement proposé directement par Atmel : http://www.atmel.com/tools/ATMELSTUDIO.aspx. Il s’agit d’Atmel Studio 6. Cet outil permet d’écrire du code en assembleur, en C ou en C++ pour tous les microcontrôleurs AVR. Pour ceux qui ont l’habitude d’utiliser Visual Studio, je recommande vraiment Atmel Studio 6 qui est en fait un Visual Studio décoré version Atmel.

Enfin, pour programmer un microcontrôleur, il faut un programmateur… Là encore, il existe une foison d’outils sur le net… Et là encore, je n’ai pas cherché midi à quatorze heure, j’utilise simplement le programmateur ISP d’Atmel : http://www.atmel.com/tools/AVRISPMKII.aspx. Honnêtement, je trouve que le coût de ce programmateur n’est pas si excessif que ça, il est automatiquement reconnu par Atmel Studio, et permet de programmer tous les AVR disposant d’une interface ISP (donc tous les AVR d’Atmel…).

Voilà, avec tout cela, je peux démarrer un premier projet très simple : Faire clignoter une LED !

Suite au prochain post…

Il court il court le hamster : Fin du montage !

Publié le par
2

Et voilà, la boite est faite ! Je passe les détails sur la réalisation car il ne s’agit ici que de percer des trous et coller quelques éléments.

Voici quelques photos :

Vue de face

Le chat qui se demande ce que c'est...

Vue de côté

Il ne reste plus qu’à aller dans le centre de la France pour installer le boitier sur la roue de Shoeur 😀

Sire, on peut passer quand ??? 😀

Il court encore et toujours ce hamster ! (Mais c’est bientôt fini…)

Publié le par
Répondre

Ça y est, les plaques sont gravées ! Plusieurs nouveautés par rapport à ce mes habitudes :

  • Plusieurs pistes de 0.8 mm espacées de 0.5 mm existent… Je suis d’habitude au dessus du millimètre…
  • Je test une nouvelle marque de plaques pré-sensibilisés (donc les temps d’insolations / gravure sont forcément différent)
  • Je test également l’application d’un vernis pour que le circuit s’oxyde moins rapidement… J’utilise une bombe de vernis vert KF 1451… Il parait qu’on peut encore souder dessus après application…

Et bien en fait, malgré ces nouveautés, je suis content du résultat obtenu. Voyez plutôt :

Gravure circuit d'allimentation + comptage

 

Gravure des afficheurs

 

Alimentation et compteur percé

Allez, juste pour le fun, vérifions que je ne me suis pas trop planté sur les mesures des afficheurs 7 segments :

Classe non ? 😀

Bon, alors là je passe pas mal de détails… Car en fait, j’ai loupé les dimension du transfo… Donc j’ai un peu plus d’un millimètre à rattraper… J’ai cherché longuement la visserie pour fixer le fusible sur le circuit… Et je cherche toujours la visserie pour le bouton de remise à zéro !!

Bref, j’ai avancé le soudage des composants sur le circuit… Autant dire que j’en est chier grave sa mère (si si, là j’ai le droit de le dire…) !! Alors, pour les composants de bases rien à dire c’est facile… Et le vernis ne gène pas. Donc pour les réalisations qui doivent tenir quelques années, je conseil l’utilisation du KF 1451 🙂 Par contre les liaisons des afficheurs, c’est trop galère ! La prochaine fois, je me trouve des embases pour CI. C’est trop chiant de faire passer ces foutus câbles dans des trous de 0,5 mm. Rien que ça j’ai du y passer plus d’une heure !! Et les pistes de 0,8 mm ça tient pas longtemps la chaleur… J’en ai bousillé une d’ailleurs :'( Mais au final, ça marche pas si mal !

J’ai pas pu résister à l’envie de tester le montage :

Dernier test avant mise sous boitier...

Et voilà ! Moi je trouve que ça le fait quand même 😀 On est jamais trop fier de ces créations 😉

Bon et bien il ne reste plus que la boite à finir… Percer les trous pour le câble d’alim, pour le bouton de remise à zéro, pour le réglage de l’intensité lumineuse, pour le capteur et pour les afficheurs… Bon ok, il y a encore un peu de boulot pour la finition. Mais ça vient bon !! 😀