Tag Archives: raspberry pi

Bientôt un nouveau RaspBerry Pi 2014!

raspberrypi-lcd

Au début de l’année, Eben Upton, fondateur et créateur du Raspberry Pi, avait annoncé que de nouveaux modèles étaient à l’étude et qu’il y aurait probablement une nouvelle mouture du mini ordinateur.

Malgré l’enthousiasme de la communauté déclenché par l’annonce, très peu d’informations ont filtré…jusqu’à aujourd’hui :-)

En exclusivité (ou presque), ZeM a réussi à obtenir des photos de la prochaine version du Raspberry Pi. Alors attention les yeux.

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

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.

 

Optimiser la consommation CPU et mémoire de votre RaspBerry Pi

raspberrypi

Aujourd’hui j’ai cherché plusieurs façons d’optimiser la consommation de mon RaspBerry Pi.

En effet, votre rpi ne possède pas de ressources illimités, c’est pourquoi il faut absolument gérer sa consommation (mémoire et CPU).

Au fil des pages, j’ai trouvé plusieurs astuces que je regroupe ici.

J’espère que cela vous sera pratique.

Remplacer OpenSSH avec DropBear

Le simple fait de remplacer OpenSSH avec DropBear vous permettra de gagner environ 10Mb de mémoire. Il faut tout de même savoir que cette manipulation supprime le logging SSH ainsi que le port forwarding.

Tout d’abord, on installe le client openssh et DropBear puis on arrête le service SSH

apt-get install dropbear openssh-client
/etc/init.d/ssh stop

Puis on lance DropBear au démarrage du RaspBerryPi

sed -i 's/NO_START=1/NO_START=0/g' /etc/default/dropbear

Optionnel: prevenir des connections root

sed -i 's/DROPBEAR_EXTRA_ARGS=/DROPBEAR_EXTRA_ARGS="-w"/g' /etc/default/dropbear

Optionnel: prévenir des connections et des mots de passe root

sed -i 's/DROPBEAR_EXTRA_ARGS=/DROPBEAR_EXTRA_ARGS="-w -s"/g' /etc/default/dropbear

Optionnel: changer le port d’écoute

sed -i 's/DROPBEAR_PORT=22/DROPBEAR_PORT=2222/g' /etc/default/dropbear

Ensuite il suffit de démarrer DropBear et de supprimer OpenSSH Server

/etc/init.d/dropbear start
apt-get purge openssh-server

Supprimer extra tty / getty

Cette manipulation va désactiver tty2-tty6, vous laissant uniquement tty1 et vous fera gagner environ 4Mb de RAM.

sed -i '/[2-6]:23:respawn:\/sbin\/getty 38400 tty[2-6]/s%^%#%g' /etc/inittab

Optionnel: vous pouvez également désinstaller getty

sed -i '/T0:23:respawn:\/sbin\/getty -L ttyAMA0 115200 vt100/s%^%#%g' /etc/inittab

Remplacer Bash Shell avec Dash Shell

Le fait de remplacer votre shell Bash par le Dash va améliorer les performances de votre machine et vous faire gagner environ 1Mb de mémoire.

De plus, votre RaspBerry démarrera plus rapidement et votre utiliserez moins d’espace disque.

dpkg-reconfigure dash
 
Use dash as the default system shell (/bin/sh)? Yes

Utiliser 512Mb de Swap

Plusieurs tests ont révélés que votre RaspBerry Pi est le plus performant lorsqu’il utilise 512 Mb de swap.

echo "CONF_SWAPSIZE=512" > /etc/dphys-swapfile

Ensuite il suffit de l’initialiser et de l’activer:

dphys-swapfile setup
dphys-swapfile swapon

Optionnel: vous pouvez améliorer les performances de votre swap grâce à la commande suivante:

sed -i 's/sortstrategy = 3/sortstrategy = 0/g'  /etc/preload.conf

Optimiser le montage du système

Pour optimiser le temps de montage du système installé sur votre RaspBerry Pi, vous pouvez utiliser la commande suivante:

sed -i 's/defaults,noatime/defaults,noatime,nodiratime/g' /etc/fstab

Désactiver IPv6

Si vous n’utilisez pas les fonctionnalités d’IPv6, vous pouvez le désactiver ce qui économisera les ressources de votre RaspBerry Pi et qui améliorera ses vitesses de connection.

echo "net.ipv6.conf.all.disable_ipv6=1" > /etc/sysctl.d/disableipv6.conf
echo 'blacklist ipv6' >> /etc/modprobe.d/blacklist 
sed -i '/::/s%^%#%g' /etc/hosts

Pensez à redémarrer votre RaspBerry:

shutdown -r now

Remplacer le Deadline Scheduler avec le NOOP Scheduler

Le plannificateur NOOP est plus approprié lorsque l’on utilise un disque SSD ou une carte Flash pour stocker le système d’exploitation:

sed -i 's/deadline/noop/g' /boot/cmdline.txt
shutdown -r now

Remplacer rsyslogd par inetutils-syslogd

Le remplacement de rsyslogd par inetutils-syslogd et la suppression des logs inutiles permet la consommation mémoire et l’utilisation cpu.

apt-get -y remove --purge rsyslog
apt-get -y install inetutils-syslogd 
service inetutils-syslogd stop

Vous pouvez supprimer les fichiers de logs obsolètes:

for file in /var/log/*.log /var/log/mail.* /var/log/debug /var/log/syslog; do [ -f "$file" ] && rm -f "$file"; done
for dir in fsck news; do [ -d "/var/log/$dir" ] && rm -rf "/var/log/$dir"; done

Il faut ensuite créer une fichier de configuration puis de démarrer le service:

echo -e "*.*;mail.none;cron.none\t -/var/log/messages\ncron.*\t -/var/log/cron\nmail.*\t -/var/log/mail" > /etc/syslog.conf
 
mkdir -p /etc/logrotate.d
echo -e "/var/log/cron\n/var/log/mail\n/var/log/messages {\n\trotate 4\n\tweekly\n\tmissingok\n\tnotifempty\n\tcompress\n\tsharedscripts\n\tpostrotate\n\t/etc/init.d/inetutils-syslogd reload >/dev/null\n\tendscript\n}" > /etc/logrotate.d/inetutils-syslogd
service inetutils-syslogd start

Passer en IP Fixe et supprime le DHCP-Client

Passer en IP Fixe réduira votre consommation mémoire et cpu.

Tout d’abord créez un fichier de backup:

cp -f /etc/network/interfaces /etc/network/interfaces.dhcp-backup

Ensuite éditez le fichier /etc/network/interfaces et remplacez:

iface eth0 inet dhcp

par:

iface eth0 inet static
#set your static IP below
address 192.168.1.107
#set your default gateway IP here
gateway 192.168.1.1
netmask 255.255.255.0
network 192.168.1.0
broadcast 192.168.1.255

Pour que les changements soient effectifs, il suffit de redémarrer votre RaspBerry Pi:

shutdown -r now

Overclocker la CPU, RAM et GPU de votre RaspBerry Pi

raspberrypi

Voici une petite astuce pour overclocker la cpu, la ram et la puissance GPU de votre RaspBerry Pi sans pour autant en augmenter le voltage.

echo -e "arm_freq=800\nsdram_freq=450\ncore_freq=350" >> /boot/config.txt

Notez que pour utiliser la commande suivante, il est préférable d’utiliser un dissipateur thermique sur la puce de votre RaspBerry. On peut en trouver pour 3€ sur ebay :)

echo -e "arm_freq=850\nsdram_freq=500\ncore_freq=450" >> /boot/config.txt

Pour que les modifications prennent effet, il suffit de redémarrer votre RaspBerry Pi:

shutdown -r now

 

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