Category Archives: Bidouilles

Utiliser les fonctions Mouse et Keyboard AZERTY d’un Arduino Pro Micro

arduino leonardo

Comme nous l’avons vu dans un précédent article, l’Arduino Pro Micro est équipé d’un ATMega32U4 qui lui permet ainsi d’être reconnu comme un périphérique USB.

Cela signifie donc que vous pouvez utiliser un Arduino Pro Micro pour simuler des touches clavier ou un déplacement de souris.

Dans cet article nous allons voir comment utiliser la fonction Keyboard d’un microcontrôleur Arduino Pro Micro.

Enfin nous verrons une carte microcontrôleur prometteuse qui permet d’utiliser les fonctionnalités liées au clavier et à la souris: la Teensy.

Utiliser votre Arduino pour mesurer la capacité d’un condensateur

arduino condensateur

Aujourd’hui je vais vous faire découvrir une astuce qu’un bon ami m’a enseigné: comment utiliser son Arduino pour mesurer avec précision la capacité d’un condensateur.

Pourquoi mesurer la capacité d’un condensateur alors que c’est écrit dessus ? Tout simplement car si comme moi vous achetez des montagnes de composants en vrac ou en lots, il est fréquent que les inscriptions sur les composants électroniques se soient barrées, ce qui complique alors leur identification et par conséquent leur utilisation.

Grâce à un Arduino seul, vous pourrez alors connaitre et mesurer la capacité de vos condensateurs. Aucun autre composant électronique n’est nécessaire et c’est là tout l’intérêt de cette astuce: rapide et pas chère.

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

Contrôler votre Arduino en Bluetooth

arduino with bluetooth

Dans ce tutoriel, nous allons voir comment utiliser un module Bluetooth afin de communiquer avec votre Arduino. Il sera alors possible de communiquer avec Arduino en utilisant votre pc, votre téléphone ou tout autre équipement disposant de la norme Bluetooth.

Imaginez que vous contrôler votre robot piloté par un Arduino avec votre téléphone. Trop la classe non ? Voilà une piste de début de solution qui vous permettra de communiquer avec votre téléphone portable et votre Arduino :-p.

Ambilight avec Arduino et Boblight

Ambilight with Arduino

Tout le monde connait le système de lumière Ambilight créé par Philips. Ce système permet de rétro éclairé le dos de votre télévision afin de donner de la profondeur à vos films.

Ce système est tout simplement génial et donne réellement la sensation que le mur sur lequel est projeté la lumière est une prolongation de votre télévision.

Nous allons voir comment fabriquer à moindre coût un système Ambilight maison à base d’Arduino, de led RGB et du logiciel Boblight.

#PartyGadget: gagnez un concours en imaginant un gadget électronique

nazduino idiot

Aujourd’hui j’ai été contacté par email pour participer à un concours qui a l’air relativement prometteur.

Ce concours, organisé par RS Components  (vente en ligne de composants électroniques) et BlogNT  (blog sur les nouvelles technologies), est simple: créer un gadget électronique drôle, fun et sympa pour moins de 300€.

Un gadget électronique pour gagner un concours ? J’adore !!!

[DIY] Imprimante 3D pas cher: ma Reprap Prusa Mendel

reprap

Celà fait 4 mois, on parlait de tout et de rien avec des collègues de boulot lorsqu’on est tombé sur un article et sa vidéo concernant les imprimantes 3D. Alors pour ceux qui ne savent pas ce qu’est une imprimante 3D, il s’agit d’une machine capable d’imprimer des objets en 3 dimensions.

On a donc recherché sur le net des informations concernant ces fameuses imprimantes 3D et on s’est vite rendu compte que les modèles disponibles sur le marché sont relativement chers (plusieurs milliers d’euros).

Intrigué par ces nouveaux périphériques capables de créer des objets en plastiques, j’ai continué de chercher sur Internet et c’est la que j’ai trouvé des informations sur une imprimante 3D DIY (Do It Yourself). Cette imprimante a monté soi même se nomme RepRap.

Le principe de la RepRap est simple: capable de réaliser une imprimante à partir d’une imprimante. C’est ce que l’on appelle de la réplication et évidemment cette notion n’est que pure utopie, même s’il est vrai que les imprimantes RepRap sont bluffantes et géniales.

Pour ceux qui souhaiteraient plus d’informations sur les différentes imprimantes 3D DIY inspirées de la RepRap, je vous invite à aller sur le site de RepRap, leur wiki étant une mine d’informations.

Notez également qu’il existe un salon IRC francophone sur la RepRap (Serveur: Freenode, Salon: #Reprap.fr) sur lequel une dizaine de passionnés se feront un plaisir de vous aider et de vous guider. J’en profite d’ailleurs pour remercier arthur et hexamail qui m’ont énormément aidé pour le montage et le paramétrage de mon imprimante 3D Reprap Prusa Mendel.

Dans la suite de ce billet, je vais essayer de mettre les différentes étapes et problèmes que j’ai rencontré, en espérant que mon retour d’expérience vous aidera ou vous donnera envie de monter vous même votre propre imprimante 3D RepRap.

Quelle imprimante 3D choisir ?

N’ayant pas énormément d’argent, j’ai directement oublié l’idée d’acheter une imprimante 3D professionnelle et j’ai donc décidé de fabriquer moi même mon imprimante 3D. Je parcours donc les forums de RepRap et leur Wiki et là je m’aperçois qu’il existe plusieurs modèles d’imprimantes 3D DIY.

En effet, il existe un dizaine de modèles dont les plus connus sont: la Wallace, la Prusa Mendel et le Huxley.

Et là, première erreur à éviter: se précipiter! En effet, une des difficultés dans la réalisation d’une imprimante 3D basée sur une RepRap est de trouver un certain nombre de pièces qui permettra de la fabriquer. Je lis donc des centaines de pages sur les forums et du coup il m’a semblé évident que je devais partir sur une RepRap Prusa Mendel v2.

Le choix s’est porté sur une RepRap Prusa Mendel v2 car c’est un modèle bien documenté pour lequel on trouve facilement les différentes pièces assurant sa fabrication.

Voilà à quoi ressemble une
 assemblée issue d’un kit “tout fait” que l’on peut se procurer pour environ 900€:

RepRap Prusa Mendel V2

 

Plutôt sympa non :) par contre 900€ ce n’est pas mon budget.

Une RepRap Prusa Mendel v2 pour 500€

Pour ceux qui ont un peu d’argent et qui n’ont pas envie de s’embêter à trouver le matériel nécessaire, il existe des kits complets pour lesquels il ne reste que l’assemblage à faire. Ces kits sont de bonne qualité mais reste onéreux. Compter environ 900€ pour un kit tel que celui de la photo précédente.

Ne disposant pas d’une telle somme, j’ai donc décidé d’essayer de faire ma propre imprimante 3D pour un budget de 500€, ce qui ne sera pas chose facile vous verrez.

J’ai donc listé tout le matériel dont j’allais avoir besoin, puis j’ai essayé de trouver les prix les plus bas du net, frais de port inclus. Pour trouver tout le matériel nécessaire pour une Prusa Mendel v2, j’ai dû passer de nombreuses heures sur Ebay et Google, mais j’y suis parvenu.

Une Reprap Prusa Mendel se compose de plusieurs éléments dont voici les principaux:

  • de la quincaillerie et de la visserie (qu’on trouve chez Castorama ou Bricovis)
  • d’un kit de pièces plastiques spécifiques (trouvé sur Ebay)
  • de 5 moteurs Nema17 (trouvé sur Ebay)
  • d’un lit chauffant (trouvé sur Ebay)
  • d’une buse chauffante (trouvé sur Ebay)

Comme je suis sympa, je vous donne la liste complète du matériel acheté, ainsi que les liens vers les différents vendeurs:

Désignation Prix
Kit pièces metriques Prusa V2 70
12 LM8UU 8mm Linear Ball Bearing Bush Bushing 10
8 roulements 608ZZ Abec 5 8
2 inch Threaded and 20mm Smooth Rod 6
PCB Heatbed MK2 Deluxe Kit 56
T2.5 Timing Belt + 2 Pulleys + grubscrews 29
5 NEW HYBRID NEMA 17 STEPPER MOTORS REPRAP 51
3 Tubes Rond acier étiré verni Ø 8 mm, 1 m 13
Visserie + Tiges fileté 38
MK4 MKIV J-Head Hot End 0.4mm nozzle 3mm filamnet 53
New Nice 1PCS ATmega2560-16AU Board with USB Cable 14
10 PCS AC 125V 1A 1NO 1NC Mini Micro Switch w Lever 2
RAMPS 1.4 electronics + SD RAMPS and cables 52
4 x A4988 stepper driver 42
PLA filament 3mm, 0,5kg 18
10mm 1.0cm X 33m 100ft Kapton Tape High Temperature 2
5 led 0805 2
100x SMD/SMT 0805 Resistor 0-1k Ohm 3
WD40 lubrifiant 5
Alimentation
Black Heat Shrink Tubing Set Pack (0.8/1.5/2.5/3.5/4.5mm) 3
Gold Tone Aluminum Case Resistors 25W Power 10 Ohm 3
5x 5 Color Binding Post Speaker Cable 4mm Banana Plug 4
DIGITAL HANDHELD LCD DVM VOM MULTIMETER VOLTMETER 4
Polyolefin Heat Shrink Heatshrink Tubing Tube Sleeve 2
TOTAL   490

Pour ceux que celà intéresse, le fichier Excel est téléchargeable ici et il intègre les liens vers tous les vendeurs.

Comme on peut le voir dans le tableau ci-dessus, le budget pour monter mon imprimante 3D s’élève à 490€. Mais autant vous le dire tout de suite, je suis plus proche des 600€ car j’ai une carte Arduino qui a cramé, ma buse qui a fondu et j’ai dû acheté quelques bricoles à coté. Cela dit, cela reste relativement correct et je suis plutôt satisfait de moi sur ce coup là.

Mon imprimante 3D

Je vous passe les différentes étapes de montage car je me suis inspiré de ce guide d’instructions qui est super bien fait avec de nombreux schémas.

Notez tout de même que suivant votre Kit plastique de pièces pour Prusa Mendel, vous serez sûrement amené à faire quelques modifications.

Voici à quoi ressemble mon imprimante 3D assemblée:

reprap prusa mendel low cost

 

reprap prusa mendel v2

Vous noterez que je n’ai pas branché le plateau chauffant car pour imprimer avec du plastique PLA ce n’est pas obligatoire (et car je n’ai plus de fil électrique sécurisé :p).

Et voici une vidéo de ma première impression (désolé pour la qualité je n’ai qu’un téléphone pourri):

Et voilà le résultat de ma première pièce 3D imprimée:

RepRap First Print

Pas vraiment réussi n’est-ce pas? Je me conforte en me disant que j’ai un souci de buse, que l’imprimante 3D n’est pas étalonnée ni paramétrer.

Je vous donne rendez vous dans un prochain sujet pour de nouvelles aventures avec ma RepRap.

 

[DIY] Recycler votre vieille alimentation ATX en alimentation de laboratoire

thumb_mercury-power-supply

Tout geek a forcément une vieille alimentation ATX (ou autre format) qui traîne dans le fond de sa chambre.

Souvent très poussiéreuse, cette alimentation ATX ne vous sert plus mais ce n’est pas pour autant que vous êtes résigné à la jeter.

Aujourd’hui je vous propose donc de recycler cette alimentation ATX pour en faire une alimentation de laboratoire, en dépensant une quinzaine d’euros.

Qu’est ce qu’une alimentation de laboratoire ?

Une alimentation de laboratoire est une alimentation qui peut délivrer toute sorte de courant (continu, alternatif) de différentes puissantes. Ces alimentations coûtent relativement cher (plusieurs centaines d’euros) et ressemble à celà:

Evidemment, nous n’aurons pas une alimentation de laboratoire avec toutes les options présentes dans les modèles commerciaux, mais notre alimentation de laboratoire low cost permettra d’utiliser du courant 3.3V, 5V, -5V, -12V ou bien encore 12V en sortie et cela pour 15€ seulement.

Le matériel pour réaliser une alimentation de laboratoire

Pour convertir notre alimentation ATX en alimentation de laboratoire, il faut acheter du petit matériel. Personnellement j’ai tout commandé sur Ebay:

  • une résistance de 25W puissance de 10 ohms (3€)
  • des tubes à chauffer (5€)
  • 5 fiches bananes (4€)
  • 1 LED + 1 résistance (1€)

On arrive donc avec les frais de ports à environ 15€ de matériel.

A celà, vous devrez ajouter de l’étain, un fer à souder, une perceuse, un voltmètre (pas nécessaire).

 Réalisation de votre alimentation de laboratoire

  • Tout d’abord décarennez votre alimentation.
  • Percez 5 trous et fixez y les fiches bananes
  • Coupez les fils puis regroupez les par couleur.
  • Soudez un fil vert à un noir, puis un noir et un rouge à la résistance 25 Watts 10 ohms.
  • Ensuite souder par groupe de couleur sur chaque fiche banane.
  • Mettez du chatterton sur les fils restants (violet, gris).
Il ne vous reste plus qu’à recaréner votre alimentation et votre alimentation de laboratoire sera opérationnelle et prête à fonctionner.

 

 

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:

[DIY] Fabriquer un tap Ethernet pour moins de 20€

tap_ethernet

Qu’est-ce qu’un Tap Ethernet ?

Un tap réseau, ou tap Ethernet, est un équipement physique (ordinateur, sonde, …) qui se branche entre plusieurs équipements (serveurs, ordinateurs, routeurs, imprimantes, …) afin de pouvoir capturer le trafic.

Dans la majorité des cas, un tap permet de capturer le trafic entre deux points d’un réseau afin de pouvoir l’analyser pour trouver des anomalies (intrusion, virus), pour enregistrer des données VoIp, pour sniffer des paquets, pour faire de la détection d’intrusion (IDS) ou bien encore pour recetter une installation (adsl bien calibré).

Un tap est généralement utilisé avec des logiciels de monitoring et de supervision de réseau. Personnellement j’utilise WireShark et TCPDump (sur lesquels je définis des filtres).

Un tap sera utilisé afin d’améliorer la sécurité de votre architecture réseau. En effet, un tap est non intrusif, indétectable sur le réseau car aucune adresse ip ne lui est assignée.

Un tap peut être utilisé pour:

  • capturer le trafic entre 2 équipements de votre réseau informatique (bypass et passthrough)
  • agréger les données provenant de plusieurs équipements

Il existe plusieurs sortes de tap: fibre, ethernet, usb, etc…

Personnellement j’ai eu l’occasion de tester un ProfiTap qui se connecte en USB sur le pc d’analyse et qui prend 2 ports Ethernet en entrée. Ce type de sonde est simple à utiliser et fonctionne bien mais contrairement à des sondes plus performante, elle se limite à du 100Mb.

Parmis toutes les sondes professionnelles, c’est une des moins chers mais il faudra quand même déboursé 1000€.

Bien sûr, ce n’est pas grand chose comparé à certaines probes (sondes) fibres peuvent être vendues plusieurs dizaines de milliers d’euros.

N’ayant pas un budget illimité (malheureusement :-(), j’ai décidé de me lancer dans la réalisation d’un tap ethernet homemade et low cost.

Fabriquer un Tap Ethernet: difficile ?

En me lançant dans ce projet, j’étais plutôt pessimiste car je suis novice en électronique, et pas forcément super manuel.

J’ai donc effectué plusieurs recherches et j’ai trouvé toutes les informations nécessaires à la réalisation d’un tap Ethernet.

Parmis toutes mes lectures, l’élément le plus important est sans aucun doute le schéma suivant (trouvé sur Snort).

Ce schéma est très simple à comprendre. On dispose de 2 hosts et de 2 taps qui permettent de monitorer chacun des hosts.

On notera que 2 paires de fils (4-5 et 7-8) ne passent pas par les taps. C’est tout à fait normal car les câbles éthernet n’utilisent que 2 paires de fils: (1-2 pour transmettre les datas et 3-6 pour recevoir les datas).

C’est pourquoi pour pouvoir monitorer les transmissions de chaque host, il nous faudra une tap par host (une pour le traffic entrant et une pour le trafic sortant).

Le tap que nous allons fabriquer sera conforme à ce schéma: 2 ports pour les hosts et 2 ports pour les tap.

J’ai tout de même essayé de faire un tap à 3 ports (2 hosts et 1 tap) en mirrorant les fils sur les 3 connecteurs éthernet mais j’ai eu un résultat bizarre au niveau de WireShark.

Fabriquer un Tap Ethernet pour moins de 20€

Vous l’aurez compris: mon objectif est de fabriquer un tap ethernet avec un budget relativement bas. Comme je suis assez maniac, j’ai opté pour des composants de qualité mais il est possible de faire un tap ethernet avec uniquement 2 câbles éthernet, un fer à souder et un peu de patience.

Tout d’abord voici le matériel nécessaire:

  • 4 RJ45 KeyStone Jack Catégorie 5: 8€
  • 1 Wall Plate 4 ports RJ45: 5€
  • 1 Back Plate: 5€
  • 1 câble éthernet catégorie 5 de 20cm: 2€ (vous pouvez utiliser un vieux câble)

On arrive donc à un total de 20€. Les frais de ports sont inclus et tout le matériel a été acheté sur Ebay car ce sont les meilleurs tarifs que j’ai trouvé.

La première étape consiste à couper le câble ethernet, le dénuder puis séparer les 4 paires de fils:

Rangez les câbles par paires de couleur:

 

Vous remarquerez que sur chaque keystone, il y a un code couleur qui va vous aider dans votre cablage:

Désormais nous allons cabler le Host A. Prenez un keystone puis connectez les 8 fils en vous aidant d’un puncher (trouvable sur Ebay à 2€) ou d’un petit tournevis plat:

Coupez l’excédent au ciseau à ras bord du keystone puis mettez les bouchons de fixations:

Prenez un second keystone qui sera notre Host B puis connectez y les paires bleues et marrons:

A présent nous allons connecter le Host A à la tap A puis à l’Host B. Nous allons donc prendre un troisième keystone, y brancher les cables orange et orange rayés. Ensuite l’excédent sera branché sur l’Host B.

Puis l’on fera la même chose avec le quatrième keystone et les câbles vert puis on branche les keystones sur le wall plate:

Je vous conseille de tester si les connexions fonctionnent avant de mettre les caches de keystones.

Il ne vous reste plus qu’à mettre le tout dans le back plate et votre tap éthernet sera terminée:

 

 

 

Comment utiliser le Tap Ethernet ?

Pour utiliser le Tap éthernet c’est simple: il suffit de brancher deux équipements sur les ports de Hosts (par exemple une freebox sur HostsA et un routeur sur HostB).

Ensuite, brancher TapA ou TapB ou les deux sur votre machine d’analyse (dans mon cas un RaspBerryPi), configurer vos interfaces en mode promiscuous puis lancer votre outil de capture (Snort, Wireshark ou TCPDump par exemple).

Pour passer une interface en mode promiscuous, il faut taper la commande suivante:

ifconfig eth0 promisc

Pour supprimer le mode promiscuous, il faut utiliser la commande:

ifconfig eth0 -promisc

Si vous souhaitez analyser le trafic entrant et le trafic sortant simultanément, il faudra brancher les taps sur une machine disposant de 2 ports éthernet et lancer 2 outils de capture.

Dans le cas où vous souhaiteriez capturer les 2 taps avec un seul WireShark, il vous faudra créer un pont (Bridge) entre vos 2 interfaces.

Pour cela, il faut installer le paquet bridget-utils:

apt-get install bridge-utils

Puis créer le pont avec la commande suivante (br0 est le nom de l’interface de bridge):

brctl addif br0 eth0 eth1

Enfin pensez que si vous souhaitez connecter votre ordinateur de capture sur votre réseau de manière classique (afin de se connecter en ssh par exemple), alors il vous faudra un troisième port ethernet.

Si vous souhaitez utiliser le tap éthernet sous Windows, il faut faire quelques modifications dans les paramètres de votre carte Ethernet: il faut supprimer l’ip fixe si vous en avez une et désactiver le contrôle de flux:

Il ne vous reste plus qu’à lancer WireShark pour capturer le trafic :)

Vous voila désormais prêt à vous lancer dans l’aventure de la réalisation d’un Tap Ethernet Homemade :).