Tag Archives: raspberrypi

Fabriquer une caméra HD de surveillance RaspiCam avec votre RaspBerry Pi

raspberry pi camera

Récemment j’ai pu lire un article de Christoph Buenger qui explique comment réaliser une caméra de surveillance accessible via Internet grâce à un simple RaspBerry Pi Modèle B et à un module caméra.

J’ai tout de suite été attiré par son article car il permet à moindre coût de réaliser votre propre caméra de surveillance haute définition pour à peine plus de 75€. Et çà tombe bien car j’ai justement un RaspBerry Pi qui prend la poussière dans un tiroir et un chat malicieux que j’aimerai bien surveiller :-).

Dans cet article nous allons donc voir comment fabriquer une caméra de surveillance, qu’on appelera RaspiCam, accessible par Internet en utilisant un RaspBerry Pi et un module caméra capable d’enregistrer en haute définition, tout en s’amusant :p

2014, une année de GeeK

2014, une année de GeeK

L’année 2013 a été une année relativement chargée qui nous a permis de voir de nombreuses geekeries. Et 2014 s’annonce déjà d’être encore plus geek, notamment avec tous les objets connectés.

Tout comme l’an dernier je vous propose de passer brièvement sur les thèmes abordés au cours de l’année et d’enchainer sur les projets à venir.

Voici donc une ébauche (méthode agile oblige :p) de notre roadmap à venir.

Bilan de l’année 2012

zem

Voilà l’année 2012 s’achève et il est temps pour nous de faire un petit bilan concernant le Blog.

Ce qui c’est passé en 2012

Tout d’abord le blog ZeM.fr a été lancé en Mars 2012 avec pour objectif de vous faire partager mes geekeries quelle qu’elles soient: programmation, bidouilles, électroniques, bon plans, etc…

En 9 mois, j’ai posté environ 80 articles traitant des nouvelles technologies (Raspberry Pi, Arduino), de programmation (PHP, Dotnet) ou bien encore de systèmes d’exploitation (Linux, Windows).

Le site a mis du temps à se lancer mais je n’ai fait aucune campagne de référencement, et j’ai laissé faire le temps et le référencement naturel, en espérant que la qualité des articles rencontre un certain succès.

Voici l’évolution des visites du site ZeM.fr pour l’année 2012:

zem analytics 2012

 

Comme on peut le voir le site croit lentement mais progressivement, ce qui est très encourageant. Notre blog a été ainsi visité par 15000 personnes qui ont consulté plus de 30000 pages.

Les projets menés en 2012

Plusieurs projets ont été menés en 2012. En voici un bref listing:

  • Sortie d’un logiciel de monitoring de ressources pour Windows. Cette solution, NetSysInfo, a été téléchargée environ 1000 fois et a connu deux sorties majeures.
  • Découverte du RaspberryPi
  • Mise en place de RAID sous Linux
  • Réalisation d’une imprimante 3D
  • Partage de morceau de code dans différents langages
  • Fabriquation d’une alimentation de laboratoire
  • Fabriquation d’une tap Ethernet

Le programme pour 2013

Plusieurs gros projets vont être réalisés en 2013. En voici une liste non exhaustive:

  • terminer notre imprimante 3D RepRap Prusa Mendel v2 afin de pouvoir imprimer des objets en plastique PLA. J’espère être capable d’imprimer des chassis de robots d’ici quelques mois.
  • réaliser un cube 3D composé de 512 leds (8x8x8). Nous verrons comment utiliser un Arduino et des Shift Register 74HC595 pour effectuer du multiplexage de leds.
  • sortir une nouvelle version du logiciel de statistiques système NetSysInfo. Cette version sera orientée Cloud, ce qui permettra l’accès à vos statistiques via Internet. Évidemment cette version sera totalement gratuite.
  • construire un robot autonome (baptisé AntQuad  pour sa première version) à base de arduino et de servos. Ce robot devra être capable de marcher grace à ses 4 pattes et d’éviter les obstacles.
  • intégrer simplement de la domotique dans son appartement ou sa maison. Nous utiliserons des prises télé-commandables et un Arduino (ou un RaspberryPi) pour réaliser l’interface Homme / Machine.
  • partager des exemples de code dans différents langages de programmation: PHP, Dotnet, C++, … Nous découvrirons entre autres un moteur de template pour PHP, des snippets pour Arduino, des classes en VB.Net, …
  • comprendre certaines notions de la web sphère tels que le domaining, le référencement ou bien encore le WebSeo.
  • fabriquer un système Ambilight maison.
  • développement d’un logiciel de calcul de résistances car je ne me souviens jamais comment calculer la puissance des résistances via leur code couleur.

Il y aura évidemment d’autres projets (enfin j’espère :p).
L’année 2013 va s’orienter vers l’électroprogrammation, qui est l’interaction entre l’électronique (voir la robotique) et la programmation (qui est mon cœur de métier).

J’espère atteindre plusieurs objectifs au cours de l’année 2013:

  • réussir à attirer 300 visiteurs uniques par jour (soit environ 100000 visiteurs sur l’année).
  • proposer des services gratuits, tel que le futur NetSysInfo orienté Cloud.
  • proposer certains services payants tel que la location de VPN, du développement à la demande ou bien du consulting.
  • optimiser l’intéraction entre ZeM.fr et les réseaux sociaux. Vous pouvez remarquer qu’un popup Facebook apparait une fois par jour sur le site :)
  • améliorer le référencement de ZeM.fr sur certains mots clé ciblés tels que RaspberryPi, Arduino ou bien encore robotique.

Cette année, le blog nous a couté 140€ répartis ainsi:

  • 8€ pour le nom de domaine
  • 132€ pour l’hébergement (11€ TTC par mois)

Pour l’année 2013, nous allons essayer de rendre le blog autonome financièrement. Plusieurs pistes sont en train d’être étudiées:

  • vente de software (sur un mode pro dans NetSysInfo par exemple)
  • vente de VPN
  • publicité non intrusive sur le blog
  • système de donation via Paypal ou Sms

Rassurez vous, cela ne gênera aucunement la navigation sur le site.

Concernant la gestion et le développement du blog, je suis à la recherche d’un co-blogueur afin de m’aider dans la rédaction d’articles. Je cherche une personne motivé avec des compétences en informatique, un débordement de curiosité et un esprit de geek.
Cette fonction n’est évidemment pas rémunérée mais il peut y avoir des contreparties en nature (hébergement, vpn, bouncer, …).

Dans tous les cas, je vous souhaite une excellente année 2013.

Utiliser le composant 74HC595 8 Bit Shift Register avec un Arduino

74HC595_diagram

Introduction

Aujourd’hui j’ai fait des recherches sur les matrices de LED afin de pouvoir faire un LED cube 3D de 512 leds (8x8x8) en me basant sur un Arduino.

Tout de suite je me suis aperçu d’un probème: comment controler 512 Leds individuellement lorsqu’un arduino ne possède que 54 pins au maximum (pour la version Mega2560 par exemple) ?

La première astuce consiste à lier les différentes anodes entre elles par couche. Par contre on est toujours bloqué concernant les cathodes qui sont au nombre de 64 (8×8).

C’est là que j’ai découvert qu’il existe des composants Bit Shift Register et plus particulièrement le composant 74HC595 8-bit Shift Register qui a la particularité d’être pas cher et assez simple à utiliser.

Crédits: je tiens à préciser que l’ensemble des informations ont été trouvée sur le site anglais bildr (dont certains exemples) donc merci à eux.

Qu’est ce que le Shift Register ?

Avant même d’essayer d’utiliser des 74HC595 pour multiplexer des leds, il faut comprendre ce qu’est le Shift Register et comment il fonctionne.

Et ben c’est simple: un composant Shift Register permet tout simplement d’étendre le nombre de sortie digitales d’un microcontrôleur tel qu’un RaspberryPi ou un Arduino.

Ainsi un composant comme les 74HC595 vont permettre de contrôler 8 sorties digitales avec en plus la possibilité de lier plusieurs composants 74HC595 les uns aux autres.

Pour mon cube led 3d de 8x8x8, je vais ainsi pouvoir lier 8 composants 74HC595 entre eux afin de disposer de 64 sorties digitales.

Comment fonctionne le Shift Register ?

Pour comprendre le fonctionnement d’un Shift Register (et notamment le 74HC595), le plus simple est d’imaginer que l’on a une ligne de 8 chaises.

Ces 8 chaises sont soit vides (valeur 0), soit occupées (valeur 1).

Maintenant considérons que toutes les 5 secondes une sonnerie retentit et les personnes assises doivent se déplacer d’une chaise sur leur droite.

Si la chaise la plus à droite était occupée, alors on considère que la personne s’en va. Pour la chaise la plus à gauche, elle peut soit rester vide soit quelqu’un vient y prendre place.

Prenons un cas concret, celui de notre Shift Register 74HC595.

Shift Register

Le composant 74HC595 dispose de 8 pins de sortie (Qa, Qb, Qc, Qd, Qe, Qf, Qg, Qh) qui peuvent soit avoir la valeur 0 (Low) soit la valeur 1 (High).

Lorsque l’on met le pin SRCLK (Serial Clock) en valeur 1 (High, qui est l’équivalent du retentissement d’une sonnerie), alors les 8 pins de sorties se décalent vers la droite.

Alors le dernier Pin (Qh) est supprimé et une nouvelle valeur est définie dans le pin Qa lorsque le pin SER (Serial) a une valeur de 1 (High). Si SER a une valeur de 0 (Low) alors Qa reste à 0.

Exemple de fonctionnement du Shift Register 74HC595

Essayons d’appliquer l’utilisation d’un Shift Register sur 8 Leds.
Imaginons que l’on souhaite allumer les leds 1, 3 et 8.

Tout d’abord, nous allons éteindre toutes les leds (Clear, via le pin SRCLR) en passons tous les registres à 0.

Ensuite, on passe la première valeur en High puis on décale de 4.  Ensuite on passe de nouveau la première valeur en High puis on décale de 1. Enfin on passe de nouveau la première valeur en High.

L’image ci-dessous illustre parfaitement cet exemple

74HC595 Shift Register

Un des avantages des Shift Registers est qu’ils disposent d’un pin appelé RCLK (Register Clock) qui permet de n’effectuer aucune modification tant qu’il est maintenu en LOW.

Ainsi tant que RCLK sera a LOW vous pourrez affecter les valeurs que vous souhaitez aux 8 pins de sortie sans que l’affichage ne change.
Une fois que vous avez mis les bonnes valeurs pour vos pins de sortie, il ne vous reste plus qu’à passer RCLK en High et le Shift Register 74HC595 affichera les modifications.

On peut ainsi modifier nos différents registres plusieurs fois (en 8 étapes par exemple), mais l’on ne verra qu’une seule modification, ce qui laissera penser que tout s’est fait en une seule étape.

Comment connecter le Shift Register 74HC595 ?

Après avoir regardé la documentation technique du 74HC595 disponible ici, il s’avère que le composant 74HC595 est relativement simple à connecter.

Voici le détail de connections des pins:

  • Vcc : alimentation jusqu’à 6V qui doit être la même que celle du microcontroleur.
  • QA à QH: sorties Shift Register.
  • SER (Serial): entrée pour le prochain pin qui sera déplacé.
  • SRCLK (Serial Clock): déplace le registre lorsqu’il est mis à 1 (High).
  • RCLK (Register Clock): doit être mis en High pour valider les nouveaux shifts register.
  • SRCLR (Serial Clear): vide complètement le Shift Register sil est mis en Low. Doit être passé en High pour être activé.
  • OE (Output Enable): ce pin permet d’activer la sortie lorsqu’il est sur la masse (GND) et la désactive lorsqu’il est en High.

Utiliser les Shift Register 74HC595 avec un Arduino

Le schéma suivant vous montre comment connecter un Shift Register 74HC595 à un Arduino Uno.

Connecting 74HC595 Arduino

Quand le signal sur le pin SERCLK devient High, toutes les valeurs sont déplacées vers la droite et les nouvelles valeurs sont settées (si le pin SER est activé).

Après avoir affecté les nouvelles valeurs, il faut passer le pin RCLK en High pour que la mise à jour soit affichée sur les sorties.

Cascade de Shift Register 74HC595 avec un Arduino

Un des points forts des Shift Register 74HC595 est qu’ils peuvent se monter en cascade.

Ainsi l’on peut chainer autant de Shift Register 74HC595 que l’on souhaite.

Comme on l’on vu, le Shift Register 74HC595 supprime la dernière valeur (Qh) lorsque l’on déplace les registres vers la droite. Pour chainer un second Shift Register, il suffirait donc d’utiliser cette valeur dans le registre suivant qui serait le premier registre d’un second composant 74HC595.

On aurait alors 2 composants 74HC595 chainés.

Pour faire cela, on va relier les pins SERCLK entre eux, les pins RCLK entre eux et le pins Qh’ du premier 74HC595 au pins Qa du second 74HC595. Simple non ?

Le schéma suivant illustre parfaitement cela:

Cascading 74HC595 Arduino

Code Arduino pour utiliser les Shift Register 74HC595

Maintenant que la connectique est faite, voici un exemple de code pour utiliser les Shift Register 74HC595 avec votre Arduino Uno :

int SER_Pin = 8;   //pin 14 on the 75HC595
int RCLK_Pin = 9;  //pin 12 on the 75HC595
int SRCLK_Pin = 10; //pin 11 on the 75HC595
 
//How many of the shift registers - change this
#define number_of_74hc595s 1 
 
//do not touch
#define numOfRegisterPins number_of_74hc595s * 8
 
boolean registers[numOfRegisterPins];
 
void setup(){
  pinMode(SER_Pin, OUTPUT);
  pinMode(RCLK_Pin, OUTPUT);
  pinMode(SRCLK_Pin, OUTPUT);
 
  //reset all register pins
  clearRegisters();
  writeRegisters();
}               
 
//set all register pins to LOW
void clearRegisters(){
  for(int i = numOfRegisterPins - 1; i >=  0; i--){
     registers[i] = LOW;
  }
} 
 
//Set and display registers
//Only call AFTER all values are set how you would like (slow otherwise)
void writeRegisters(){
 
  digitalWrite(RCLK_Pin, LOW);
 
  for(int i = numOfRegisterPins - 1; i >=  0; i--){
    digitalWrite(SRCLK_Pin, LOW);
 
    int val = registers[i];
 
    digitalWrite(SER_Pin, val);
    digitalWrite(SRCLK_Pin, HIGH);
 
  }
  digitalWrite(RCLK_Pin, HIGH);
 
}
 
//set an individual pin HIGH or LOW
void setRegisterPin(int index, int value){
  registers[index] = value;
}
 
void loop(){
 
  setRegisterPin(2, HIGH);
  setRegisterPin(3, HIGH);
  setRegisterPin(4, LOW);
  setRegisterPin(5, HIGH);
  setRegisterPin(7, HIGH);
 
  writeRegisters();  //MUST BE CALLED TO DISPLAY CHANGES
  //Only call once after the values are set how you need.
}

Vous noterez que cet exemple gère le cascading (le chainage des 74HC595). Il vous suffit d’éditer la ligne:

#define number_of_74hc595s 1

J’espère que cet article vous aura aidé. Rendez-vous dans un prochain poste pour la construction du cube 3D.

 

Utiliser Screen sous votre Linux RaspBerry Pi

linux screen

Aujourd’hui, nous allons apprendre à utiliser Screen sous notre RaspBerryPi mais ce tutoriel est valable pour tout système linux.

A quoi sert Screen ?

Screen est une application qui permet d’exécuter d’autres applications en tâche de fond, ce qui laisse le terminal disponible pour effectuer d’autres informations.

Comme je prends le contrôle à distance sur mon RaspBerry Pi en utilisant putty et SSH, Screen me permet d’exécuter plusieurs tâches en parallèle sans pour autant devoir ouvrir plusieurs terminaux.

Comment installer Screen ?

Pour installer Screen, il suffit d’exécuter la commande suivante:

apt-get install screen

 Les principales commandes de Screen

Voici la liste des principales commandes de Screen:

  • screen -ls : Affiche les screens ouvert
  • screen -dr : Récupérer un screen ouvert
  • ctrl+a : Commande principale
Et voici la liste des options disponible pour la commande ctrl+a:
  • “ : Affiche la liste des screens
  • w : Nous informe sur quel screen nous sommes
  • d : Détache le screen actuel
  • c : Créer un nouveau Screen
  • shift+A : Renomme le Screen courant

Utiliser Screen

Pour utiliser Screen, c’est tout simple. Ouvrez un terminal et tapez la commande suivante:
screen

Ceci va “ouvrir un terminal” en “screen” (tâche de fond).

Vous pouvez alors exécuter toutes les commandes que vous souhaitez (top, ntop, bw-g, …)

Une fois cette commande tapée, il faut appuyer sur “ctrl+a” puis “d” afin de se détacher de ce screen (de cet écran). Vous aurez alors un message de ce genre:

[detached from 11199.pts-0.jhdserver]

En tapant la commande “screen -ls” dans un terminal, vous obtiendrez la liste de tous les screens en cours d’exécution:

root@jhdserver:/home/jhd# screen -ls
There is a screen on:
        11199.pts-0.jhdserver   (10/12/2012 09:37:30 PM)        (Detached)
1 Socket in /var/run/screen/S-root.

Pour récupérer un screen, il suffit de lancer la commande “screen -dr pid”.

Pour fermer un screen, il suffira alors de lancer la commande “exit”.

 

RaspBerry Pi et afficheur LCD Hitachi HD44780 1602 [PART 2]

raspberrypi-lcd

Voici la suite du tutoriel sur l’intégration et l’utilisation d’un afficheur LCD HD44780 sur un RaspBerry Pi.

Pour ceux qui n’ont pas lu la première partie, je vous conseille de le faire.

Montage LCD sur RaspberryPi

Un schéma étant souvent plus évocateur que de longs discours, j’ai préparé tout le câblage sur grâce au logiciel fritzing.

Le montage suivant permet la connection d’un écran LCD HD44780 sur votre RaspBerry Pi. N’hésitez pas à cliquer sur l’image pour l’agrandir.

Le pin RW (Pin 5 du LCD) permet de spécifier à l’afficheur si on souhaite envoyer ou recevoir des données. Dans notre cas, on souhaite uniquement recevoir des données provenant du RaspBerry Pi, c’est pourquoi je l’ai relié directement à la masse.

De plus, il faut savoir que votre RaspBerry Pi ne supportera pas 5V en entrée sur les ports GPIO. Le fait de relier le pin RW à la masse m’assure donc que je n’enverrai pas du 5V à mon RaspBerry Pi, ce qui pourrait l’endommager.

Vous noterez également que le pin 3 de l’afficheur LCD est directement branché à la masse. Sa tension qui doit se situer entre 0V et 5V permet de définir le contraste de l’afficheur LCD. Comme expliqué dans la première partie du tutoriel, il est possible de connecter un potentiomètre afin de régler le contraste (le point suivant illustre cela).

Vous noterez également que le pin 15 de l’afficheur LCD HD44780 est relié à une résistance. Je l’ai mise car ce pin qui sert au backlight est alimenté en 5V et je n’ai voulu prendre aucun risque.

Vous voyez il est relativement simple de connecter un afficheur LCD HD44780 à votre RaspBerry Pi.

Montage LCD sur RaspberryPi avec Potentiomètre

L’utilisation d’un potentiomètre va vous permettre de régler le contraste en jouant sur le pin 3 de votre afficheur LCD. Le reste de la connectique est identique au schéma précédent.

Premier branchement du LCD sur votre RaspBerry Pi

Je vous conseille de souder déjà les cables avec votre afficheur LCD:

Vous remarquerez que j’ai utilisé exactement les mêmes coloris de câbles que dans mon schéma. C’est important pour éviter de se perdre dans les fils.

Vu que je suis sympa çà me gène pas si vous vous moquez de mes soudures (j’en avais pas refait depuis 12 ans :-)).

Ensuite effectuez toutes les connexions sur votre breadboard:


Vous pouvez ensuite effectuer les connexions vers votre RaspBerry Pi.

ATTENTION: Ne branchez que le pin d’alimentation 5V que si vous êtes sûr de votre montage.

Une fois votre afficheur LCD HD44780 correctement branché sur votre RaspBerry Pi, vous devriez avoir quelque chose comme çà:

Afficher du texte sur votre LCD HD44780

L’intérêt d’avoir un afficheur LCD connecté à votre RaspBerry Pi est d’y afficher du texte.

Pour pouvoir faire cela, nous allons utiliser le langage Python et la bibliothèque RPi-GPIO qui permet d’envoyer des commandes ou des données via les pins de votre RaspBerry Pi.

Installation de RPi-GPIO

Téléchargez RPi-GPIO:

wget http://pypi.python.org/packages/source/R/RPi.GPIO/RPi.GPIO-0.3.1a.tar.gz

Extraire l’archive puis naviguer dans le répertoire créé:

tar zxf RPi.GPIO-0.3.1a.tar.gz
cd RPi.GPIO-0.3.1a

Installez la bibliothèque RPi-GPIO puis supprimer les fichiers inutiles:

python setup.py install
cd ..
rm -rf RPi.GPIO-0.3.1a/

 Afficher du texte sur le LCD en Python

Voici le code Python qui me sert à afficher des informations systèmes sur mon afficheur LCD connecté à mon RaspBerry Pi:

#!/usr/bin/python
 
############################
# Imports                  #
############################
import threading
import RPi.GPIO as GPIO
from time import sleep
import subprocess
 
############################
# Class de controle du LCD #
############################
class HD44780(threading.Thread):
	######################
	# Variable Shared    #
	######################
	_PULSE = 0.00005
	_DELAY = 0.00005
 
	######################
	# Constructeur       #
	######################
	def __init__(self, pin_rs=7, pin_e=8, pins_db=[25, 24, 23, 18], lcd_width=16):
		self.message = ""
		self.currentmessage = "azertyuiop"
		self.stop = False
		self.lcd_width = lcd_width
		self.pin_rs = pin_rs
		self.pin_e = pin_e
		self.pins_db = pins_db
		GPIO.setmode(GPIO.BCM) 				# Use BCM GPIO numbers
		GPIO.setup(self.pin_e, GPIO.OUT)
		GPIO.setup(self.pin_rs, GPIO.OUT)
		for pin in self.pins_db:
			GPIO.setup(pin, GPIO.OUT)
 
		self.Clear()
		threading.Thread.__init__(self)
 
	######################
	# Demarrage du Thread# 
	######################
	def run(self):
		while self.stop == False:
			if self.message != self.currentmessage:
				self.currentmessage = self.message
				self.LcdMessage()
			sleep(1)
 
	######################
	# Arret du Thread    # 
	######################	
	def Stop(self):
		self.stop = True
 
	######################
	# Initialisation LCD # 
	######################
	def Clear(self):
		""" Blank / Reset LCD """
		self.LcdByte(0x33, False) # $33 8-bit mode
		self.LcdByte(0x32, False) # $32 8-bit mode
		self.LcdByte(0x28, False) # $28 8-bit mode
		self.LcdByte(0x0C, False) # $0C 8-bit mode
		self.LcdByte(0x06, False) # $06 8-bit mode
		self.LcdByte(0x01, False) # $01 8-bit mode
 
	######################
	#Execution sur le LCD# 
	######################
	def LcdByte(self, bits, mode):
		""" Send byte to data pins """
		# bits = data
		# mode = True  for character
		#        False for command
 
		GPIO.output(self.pin_rs, mode) # RS
 
		# High bits
		for pin in self.pins_db:
			GPIO.output(pin, False)
		if bits&0x10==0x10:
			GPIO.output(self.pins_db[0], True)
		if bits&0x20==0x20:
			GPIO.output(self.pins_db[1], True)
		if bits&0x40==0x40:
			GPIO.output(self.pins_db[2], True)
		if bits&0x80==0x80:
			GPIO.output(self.pins_db[3], True)
 
		# Toggle 'Enable' pin
		sleep(HD44780._DELAY)    
		GPIO.output(self.pin_e, True)  
		sleep(HD44780._PULSE)
		GPIO.output(self.pin_e, False)  
		sleep(HD44780._DELAY)      
 
		# Low bits
		for pin in self.pins_db:
			GPIO.output(pin, False)
		if bits&0x01==0x01:
			GPIO.output(self.pins_db[0], True)
		if bits&0x02==0x02:
			GPIO.output(self.pins_db[1], True)
		if bits&0x04==0x04:
			GPIO.output(self.pins_db[2], True)
		if bits&0x08==0x08:
			GPIO.output(self.pins_db[3], True)
 
		# Toggle 'Enable' pin
		sleep(HD44780._DELAY)    
		GPIO.output(self.pin_e, True)  
		sleep(HD44780._PULSE)
		GPIO.output(self.pin_e, False)  
		sleep(HD44780._DELAY) 	
 
	######################
	#Affichage sur le LCD# 
	######################	
	def LcdMessage(self):
		""" Send string to LCD. Newline wraps to second line"""
		self.Clear()
		text = self.currentmessage
		self.LcdByte(0x80, False)
		for c in text:
			if c == '\n':
				self.LcdByte(0xC0, False) # next line
			else:
				self.LcdByte(ord(c),True)
 
	######################
	#Definir le message  # 
	######################
	def LcdSetMessage(self, text):
		self.message = text.ljust(self.lcd_width," ")
 
################################
# Class Informations Systeme   #
################################
class SysInfo(threading.Thread):
	######################
	# Constructeur       #
	######################
	def __init__(self):
		self.count = 0
		self.lcd = HD44780()
		self.stop = False
		threading.Thread.__init__(self)
 
	######################
	# Demarrage du Thread# 
	######################
	def run(self):
		self.lcd.start()
		while self.stop == False:
			if self.count == 0: #UPTIME
				self.lcd.LcdSetMessage("Uptime:\n"+self.SysUptime())
			elif self.count == 1: #LOAD
				self.lcd.LcdSetMessage("Load:\n"+self.SysLoadAvg())
			elif self.count == 2: #CPU
				self.lcd.LcdSetMessage("Cpu:\n"+self.SysCpu())
			elif self.count == 3: #MEMORY
				self.lcd.LcdSetMessage("Memory:\n"+self.SysMemory())
			elif self.count == 4: #DRIVE
				self.lcd.LcdSetMessage("Disk Root:\n"+self.SysDisk())
			else:
				self.lcd.LcdSetMessage("ZeM.fr    ZeM.fr\nRoxXxXxXxXxXxXxX")
			self.count += 1
			if self.count == 6:
				self.count = 0
			sleep(5)
 
	######################
	# Arret du Thread    # 
	######################
	def Stop(self):
		self.lcd.Stop()
		self.stop = True	
 
	######################
	# Memory             # 
	######################		
	def SysMemory(self):
		try:
			command="free -h"
			process=subprocess.Popen(command, shell=True, stdout=subprocess.PIPE)
			stdout_list=process.communicate()[0].split('\n')
			for line in stdout_list:
			  data=line.split()
			  try:
				  if data[0]=="Mem:":
					  total=str(data[1])
					  used=str(data[2])
					  free=str(data[3])
			  except IndexError:
				  continue	
		except:
			return "Error"
		return str(used)+ " / "+str(total)
 
	######################
	# Disk              # 
	######################		
	def SysDisk(self):
		try:
			command="df -H /"
			process=subprocess.Popen(command, shell=True, stdout=subprocess.PIPE)
			stdout_list=process.communicate()[0].split('\n')
			for line in stdout_list:
			  data=line.split()
			  try:
				  if data[len(data)-1]=="/":
					  total=str(data[1])
					  used=str(data[2])
			  except IndexError:
				  continue	
		except Exception, e:
			print e
			return "Error"
		return str(used)+ " / "+str(total)
 
	######################
	# CPU                # 
	######################	
	def SysCpuGetTimeList(self):
		statFile = file("/proc/stat", "r")
		timeList = statFile.readline().split(" ")[2:6]
		statFile.close()
		for i in range(len(timeList))  :
			timeList[i] = int(timeList[i])
		return timeList
	def SysCpu(self):
		try:
			x = self.SysCpuGetTimeList()
			sleep(2)
			y = self.SysCpuGetTimeList()
			for i in range(len(x)):
				y[i] -= x[i]
			cpuPct = 100 - (y[len(y) - 1] * 100.00 / sum(y))
		except:
			return "Error"
		return str('%.2f' %cpuPct)+"%"
 
	######################
	# Load Average       # 
	######################
	def SysLoadAvg(self):
		try:
		 f = open( "/proc/loadavg" )
		 contents = f.read().split()
		 f.close()
		except:
			return "Error"
		return contents[0]+" "+contents[1]+" "+contents[2];		
 
	######################
	# Systeme Uptime     # 
	######################
	def SysUptime(self):
		try:
			f = open( "/proc/uptime" )
			contents = f.read().split()
			f.close()
			total_seconds = float(contents[0])
			MINUTE  = 60
			HOUR    = MINUTE * 60
			DAY     = HOUR * 24
			days    = int( total_seconds / DAY )
			hours   = int( ( total_seconds % DAY ) / HOUR )
			minutes = int( ( total_seconds % HOUR ) / MINUTE )
			seconds = int( total_seconds % MINUTE )
			string = ""
			if days > 0:
				string += str(days) + "d "
			if len(string) > 0 or hours > 0:
				string += str(hours) + "h "
			if len(string) > 0 or minutes > 0:
				string += str(minutes) + "m "
			string += str(seconds) + "s "
		except:
			return "Error"
		return string;	
 
######################
# MAIN STARTER       # 
######################	
if __name__ == '__main__':
 
	si = SysInfo()
	si.start()
	q = str(raw_input('Press ENTER to quit program'))
	si.Stop()

Ce script Python contient 2 classes:

  • la classe HD44780 qui permet de contrôler l’afficheur LCD
  • la classe SysInfo qui permet de récupérer certaines informations propres au système

Le script contient également un lanceur afin d’exécuter le main.

Voici une vidéo montrant le résultat produit par ce script:

RaspBerry Pi et afficheur LCD Hitachi HD44780 1602 [PART 1]

raspberrypi-lcd

Comme vous le savez j’ai récemment récupéré un RaspBerry Pi et du coup je me suis dis pourquoi ne pas essayé d’intéragir avec les pins GPIO (General Purpose Input Output).

Je me suis donc donné pour projet de réaliser un petit programme qui affiche des informations systèmes sur un écran LCD connecté via les ports GPIO de mon RaspBerry Pi.

Les GPIO du RaspBerry Pi

Un RaspBerry Pi possède 26 pins GPIO qui permettent de connecter une multitude d’équipement et périphériques: LED, transistor, radio, cerveeau, afficheur lcd, dalle tactile, …

Le schéma suivant détail l’utilisation de chacun des pins.

La première chose à voir est la numérotation des ports GPIO. Celle-ci est relativement importante notamment lorsqu’on commencera à programmer dessus.

On note donc qu’il y a 2 pins servant à l’alimentation électrique (en 3.3V et en 5V) et un pin servant à la masse (en noir sur le schéma).

Les pins en blanc ne doivent JAMAIS être utilisé.

Les pins en vert sont les ports GPIO utilisables. Il y en a 8 en tout.

Les pins en violet sont des ports SPI (Serial Peripheral Interface) qui sont utilisables dans certains cas précis.

Il en est de même pour les ports jaunes UART (Universal Asynchronous Receiver Transmitter) et les ports bleu I²C.

Vous allez me dire que c’est dommage que seuls 8 ports GPIO soient utilisable directement. Rassurez vous, il est tout à fait possible de reconfigurer les ports UART, I²C et SPI afin de pouvoir utiliser les 17 ports GPIO de votre RaspBerry Pi.

Ainsi la librairie WiringPi, permet de les utiliser facilement.

Choisir un afficheur LCD pour RaspBerry Pi ?

Il existe une infinité de références d’afficheur LCD. Il en existe de toutes les tailles, toutes les formes et tous les prix.

Après plusieurs recherches, j’ai porté mon choix sur un afficheur LCD Hitachi HD44780 1602.

J’ai choisi cet afficheur LCD car le contrôleur HD44780 est un des plus couramment utilisé, il y a donc énormément de documentation technique.
De plus il ne nécessite pas énormément de pins pour être connecté et il fonctionne en 5V.

Et enfin, il est relativement peu coûteux (j’ai trouvé le mien à 3€ livré sur Ebay :-))

A la découverte du LCD HD44780 1602

Présentation du LCD HD44780 1602

L’afficheur est d’une taille compacte (ce qui est pratique pour l’intégrer dans un boitier de RaspBerry Pi).

Il dispose de deux lignes de 16 caractères chacune. Il existe également des versions à 3 lignes et 4 lignes.

Le brochage du LCD HD44780 1602

Une des notions fondamentales lorsque l’on souhaite utiliser un afficheur LCD est la connexion et le brochage.

Le chipset HD44780 étant relativement simple, les afficheurs se basant dessus utilisent en général 16 broches, la branche 1 étant la broche la plus a gauche.

Voici le détail de l’utilisation de chaque broche:

  • la broche 1 (VSS) sera reliée à la masse.
  • la broche 2 (VDD) sera reliée à l’alimentation positive de 5V.
  • la broche 3 (V0) est une entrée analogique qui permet de régler le contraste de l’afficheur. Il faut savoir qu’une tension de 5V correspondra au contraste le plus faible alors qu’une mise à la masse correspondra au contraste le plus élevé. Je vous conseille d’utiliser un potentiomètre pour gérer le contraste (nous verrons cela plus tard).
  • la broche 4 (RS pour Register Select) est une entrée numérique qui sert à sélectionner le registre. Cela permettra à l’afficheur de déterminer si une commande (signal niveau bas) ou une donnée (signal niveau haut) lui est envoyée.
  • la broche 5 (R/W pour Read/Write) est une entrée numérique qui sert à lire (niveau haut) ou écrire (niveau bas).
  • la broche 6 (E pour Enable) est une entrée numérique qui valide la lecture ou l’écriture. La validation est active sur le front descendant d’une impulsion, dont la durée de l’état haut doit être au moins de 450 ns.
  • les broches 7 à 14 sont des entrées numériques. Ce sont des bus de données bidirectionnels qui servent à envoyer ou à recevoir les données ou les commandes via l’afficheur LCD.
  • les broches 15 et 16 servent à alimenter le rétroéclairage (backlight). La broche 15 (l’anode) doit être alimentée en +5V et la broche 16 (la cathode) doit être mise à la masse.

Les modes d’utilisation du LCD HD44780 1602

Il existe deux modes possibles pour utiliser le LCD HD44780 1602:

  • le mode 8 bits où les données et les commandes sont envoyées grâce aux broches D0 à D7 (broches 7 à 14).
  • le mode 4 bits qui limite le nombre de broches nécessaire pour commander l’afficheur. Juste les broches D4 à D7 sont utilisées sur le LCD, les broches D3 à D0 étant mises à la masse.

Personnellement je vous conseille d’utiliser le mode 4 bits car le RaspBerry Pi est limité en ports GPIO.

En effet, le mode 4 bits demande sept broches (voire six si l’on ne fait qu’écrire) alors que le mode huit bits en requiert 11.

Pour envoyer les différents bits représentant les caractères, on transmet séquentiellement les quatre bits de poids forts suivis des quatre bits de poids faibles.

Une impulsion de minimum 450 ns séparant chaque demi-octet est envoyée sur l’entrée E pour valider ces derniers.

Les mémoires et registres du LCD HD44780 1602

Les afficheurs basé sur le chipset HD44780 utilisent 2 types de mémoire:

  • La DDRAM qui stocke les caractères que l’on veut afficher à l’écran.
  • La CGRAM qui contient le jeu de caractères affichables. Elle permet d’afficher 200 caractères différents dont huit peuvent être définis par l’utilisateur.

Les afficheurs basé sur le chipset HD44780 utilisent 3 types de registre:

  • le registre d’instruction (unidirectionnel) qui reçoit des commandes venant de l’utilisateur. Il est utilisable uniquement en écriture et permettra de déplacer le curseur ou effacer l’afficheur.
  • le registre d’état (unidirectionnel) qui est utilisé uniquement en lecture et qui sert à indiquer lorsque l’afficheur est prêt à recevoir une instruction ou une donnée. La demande d’état se fait grâce à la broche R/W (R/W = 0, lorsque l’on écrit et R/W = 1, lorsque l’on veut lire l’état).
  • le registre de données (bidirectionnel) qui permet de recevoir les caractères à afficher ou à envoyer les caractères stockés dans la DDRAM.

 

Mise à jour du firmware de votre Raspberry Pi

raspberrypi

Voilà comment procéder pour mettre à jour votre RaspBerry Pi sans risquer d’endommager votre Rpi.

sudo apt-get install ca-certificates git-core
sudo wget http://goo.gl/1BOfJ -O /usr/bin/rpi-update
sudo chmod +x /usr/bin/rpi-update
sudo rpi-update

Si vous rencontrez une erreur n’y pretez pas attention, ce n’est pas gênant.

Il ne vous reste plus qu’à exécuter les commandes suivantes:

sudo ldconfig
sudo rpi-update

Pour terminer la mise à jour du firmware de votre RaspBerry Pi, il ne vous reste plus qu’à le redémarrer.

Optimisez votre Raspberry Pi pour une utilisation en serveur

raspberrypi

J’ai acheté récemment un RaspBerry Pi (RPI) sur lequel je me suis mis à développer des scripts python afin de faire de l’analyse de trames réseau.

N’ayant pas besoin du mode graphique, j’ai trouvé plusieurs astuces afin d’optimiser mon RaspBerry Pi qui tourne sur une version de Debian.

Après avoir installé un serveur SSH, vous pouvez donc désinstaller certains paquets servant uniquement à l’utilisation graphique.

sudo apt-get update
sudo apt-get -y remove aspell hunspell-en-us iptraf libaspell15 libhunspell-1.2-0 lxde lxsession lxtask lxterminal squeak-vm whiptail zenity gdm
sudo apt-get -y autoremove

De plus si lorsque vous vous logguez en SSH, la connection prend 10 secondes, vous pouvez desactiver la résolution DNS:

echo UseDNS no >> /etc/ssh/sshd_config
service ssh restart