lindev.fr

Aller au contenu | Aller au menu | Aller à la recherche

10 juin 2013

Projet Libérons le cahier Debian

Présentation

Après avoir libéré la traduction anglaise du livre, le but est de boucler la boucle et libérer le livre original, qui est en français.
La proposition est simple: achetez un exemplaire du livre Debian Squeeze, lisez-le tranquillement cet été, décorez votre ordinateur portable avec le magnifique autocollant Debian détouré qui l'accompagnera, et à la rentrée impressionnez vos collègues et amis en montrant tout ce que vous pouvez faire avec Debian (sans avoir déboursé le moindre centime en licences de logiciels) ! :-) 


 

26 avr. 2013

speedometer

Un petit outil que j'ai découvert récemment , qui permet de monitorer le trafic entrant et/ou sortant d'une ou plusieurs de vos interfaces, et le tout sans quitter votre terminal ..

A essayer .. :)

Installation

Testé sous Débian squeeze et wheezy , l'installation se fait simplement par les dépôts officiels

sudo apt-get install speedometer

Et oui, comme vous pourrez le voir c'est du python ...

Utilisation

La doc est on ne peut plus .. clair , pour faire simple quelques exemples

Fronts montant et descendant de l'interface eth0, sur deux lignes

speedometer -rx eth0 -tx eth0

speedometer1.png

Fronts montant et descendant de l'interface eth0, sur deux colonnes

speedometer -rx eth0 -c -tx eth0

speedometer2.png

Fronts montant et descendant de l'interface eth0, et front descendant d'une autre interface ( br0 )

speedometer -rx eth0 -tx eth0 -rx br0

speedometer3.png

Avec un rafraîchissement plus rapide ( 0.25 sec )

speedometer -rx eth0 -tx eth0 -rx br0 -i0.25

speedometer4.png

Bref .. il y a pas mal d'autres petites options sympa ..

Usage: speedometer [options] tap [[-c] tap]...
Monitor network traffic or speed/progress of a file transfer.  At least one
tap must be entered.  -c starts a new column, otherwise taps are piled
vertically.

Taps:
  -f filename [size]          display download speed [with progress bar]
  -r network-interface        display bytes received on network-interface
  -t network-interface        display bytes transmitted on network-interface
  -c                          start a new column for following tap arguments

Options:
  -b                          use old blocky display instead of smoothed
                              display even when UTF-8 encoding is detected
                              (use this if you see strange characters)
  -i interval-in-seconds      eg. "5" or "0.25"   default: "1"
  -k (1|16|88|256)            set the number of colors this terminal
                              supports (default 16)
  -l                          use linear charts instead of logarithmic
                              you will VERY LIKELY want to set -m as well
  -m chart-maximum            set the maximum bytes/second displayed on
                              the chart (default 2^32)
  -n chart-minimum            set the minimum bytes/second displayed on
                              the chart (default 32)
  -p                          use original plain-text display (one tap only)
  -s                          use bits/s instead of bytes/s
  -x                          exit when files reach their expected size
  -z                          report zero size on files that don't exist
                              instead of waiting for them to be created

Note: -rx and -tx are accepted as aliases for -r and -t for compatibility
with earlier releases of speedometer.  -f may be also omitted for similar
reasons.

Conclusion

Ca peut toujours sévir ;)

27 mar. 2013

Ipmi : Intelligent Platform Management Interface

LAN_Cable.jpg

IPMI

Si je cite wikipédia, ipmi est une interface intégrée au matériel ( souvent des serveurs ), qui permet d'effectuer quelques commandes utiles ( reboot, interrupteur on off , console à distance etc .. ), mais aussi de remonter pas mal d'informations sur la plateforme ( température des différents éléments, vitesse de rotation des ventilos, alimentation etc etc ... ).

Alléchant non ?

Je vais donc vous présenter un peu plus en détail les possibilités de cette interface, ainsi que les variantes en fonction des constructeurs, enfin nous verrons comment nous y connecter à distance via ipmitool.

IPMI BMC IPBMC RMCP

Commençons par débroussailler le terrain,

IPMI est donc une "interface" qui permet de communiquer ( en local ou au travers le LAN ) avec le controller BMC du serveur.
BMC communique avec les différents composants du serveur ( SouthBridge, Alimentation, emplacements PCI, Port série , .... ) via diverses protocoles ( I2C, SMBUS, Série, ... ), il peut même communiquer avec d'autres châssis ( serveurs ), utilisant un controller IPBMC, ce mode de fonctionnement est managé via le Remote Management Control Protocole (RMCP), un protocole spécifique à ce mode de fonctionnent sur le couche IP.

IPMI étant maintenant un protocole standardisé, il nous permet de travailler de la même façon sur des plateformes hétérogènes .

Constructeurs

Selon les constructeurs, vous pourrez entendre des termes différents

  • DRAC (Dell)
  • iLO (HP)
  • SSP (Sun)
  • CIMC (Cisco)

Chacun apportant son lot de différences, mais toujours avec la même base commune .

Activer IPMI

Deux façons de faire,

  1. Via le BIOS
  2. En local, sur le serveur

Via le bios

Si vous avez la possibilité de couper votre machine, alors cette méthode peut vous convenir, souvent dans le BIOS , au niveau des paramètres avancés vous trouverez une ligne BMC ou IPMI activable.
L'activation vous permettra certainement de définir une adresse IP pour prendre le contrôle à distance ( Cette IP sera dédié à IPMI , elle n'est donc pas identique à celle de votre machine Pour tester, l'interface doit répondre au PING ).
Enfin, il est possible ( ce n'est pas toujours le cas ex : Lenovo TD100 ) de définir un login et mot de passe pour la connexion distante.

Pour ceux qui cherchent, le login et mot de passe par défaut pour les serveurs Lenovo, c'est respectivement :

  • LOGIN : USERID
  • PASSWORD : PASSW0RD ( ATTENTION : ce n'est pas un O mais un zero )

En local

Le mode le plus simple je trouve, car il permet d'activer IPMI sans avoir redémarrer la machine ( pratique pour un serveur en prod ).

Les modules

Commençons par vérifier que nous possédons les modules suivants

  • ipmi_si
  • ipmi_devintf
modprobe ipmi_si
modprobe ipmi_devintf

ipmitool

Enfin, nous allons installer notre utilitaire ipmi, nommé ipmitool

apt-get install ipmitool

Test en local

Pour tester le bon fonctionnement, nous pouvons faire une requête simple, interroger le status du châssis

ipmitool chassis status

qui doit vous retourner quelque chose dans ce genre :

System Power         : on
Power Overload       : false
Power Interlock      : inactive
Main Power Fault     : false
Power Control Fault  : false
Power Restore Policy : previous
Last Power Event     : 
Chassis Intrusion    : inactive
Front-Panel Lockout  : inactive
Drive Fault          : false
Cooling/Fan Fault    : false
Sleep Button Disable : allowed
Diag Button Disable  : allowed
Reset Button Disable : allowed
Power Button Disable : allowed
Sleep Button Disabled: false
Diag Button Disabled : false
Reset Button Disabled: false
Power Button Disabled: false

Configuration du réseau

Pour configurer le réseau, nous allons le faire en 4 étapes, respectivement :

  1. définition de l'adresse IP propre à IPMI
  2. définition du mask de sous réseau
  3. définition de la passerelle
  4. activation de l’accès distant
ipmitool lan set 1 ipaddr 10.0.0.231
ipmitool lan set 1 netmask 255.255.255.0
ipmitool lan set 1 defgw ipaddr 10.0.0.254
ipmitool lan set 1 access on

Voilà pour le réseau, passons à l'authentification .

Credential

Nous allons ici simplement définir un nouvel utilisateur et son mot de passe, pour l’accès distant .

ipmitool user set name 1 admin
ipmitool user set password 1 motdepasseadmin

Si nous souhaitons ajouter un autre utilisateur, il faut alors incrémenter le chiffre 1 ex :

ipmitool user set name 2 autreadmin
ipmitool user set password 2 motdepasseautreadmin

Parfait ! Notre serveur est maintenant disponible via IPMI sur le réseau.

Exemples ipmitool

Voyons quelques exemples pratiques

Status du serveur ( qu'il soit allumé ou éteint )

ipmitool -H10.0.0.231 -Uadmin -Pmotdepasseadmin chassis status 

Capteurs du serveur

remontons les constantes de notre machine

ipmitool -H10.0.0.231 -Uadmin -Pmotdepasseadmin sensor

ce qui donne quelque chose comme :

...
PCI Reset        | 0x0        | discrete   | 0x0080| na        | na        | na        | na        | na        | na        
CPU0 Fan R0      | 2768.549   | RPM        | ok    | na        | inf       | na        | na        | 1000.400  | na        
CPU1 Fan R0      | na         | RPM        | na    | na        | inf       | na        | na        | 1000.400  | na        
Rear Sys Fan1    | 1608.752   | RPM        | ok    | na        | inf       | na        | na        | 1000.400  | na        
Front Sys Fan1   | 1434.309   | RPM        | ok    | na        | inf       | na        | na        | 1000.400  | na        
System 12V       | 11.984     | Volts      | ok    | na        | na        | na        | na        | na        | na        
System 5V        | 5.078      | Volts      | ok    | na        | na        | na        | na        | na        | na
...

Pour n'avoir que les températures

ipmitool -H10.0.0.231 -Uadmin -Pmotdepasseadmin sdr type "Temperature"

ce qui me donne :

CPU0 Dmn 0 Temp  | 22h | ok  |  3.0 | 18 degrees C
CPU0 Dmn 1 Temp  | 23h | ok  |  3.0 | 16 degrees C
CPU1 Dmn 0 Temp  | 24h | ns  |  3.1 | Disabled
CPU1 Dmn 1 Temp  | 25h | ns  |  3.1 | Disabled
DIMM Rear Temp   | 26h | ok  |  0.0 | 24 degrees C
Inlet Amb Tem    | 27h | ok  |  0.0 | 15 degrees C
PCI Amb Temp     | 28h | ok  |  0.0 | 31 degrees C
CPU Prochot0     | 36h | ok  |  3.0 | Limit Not Exceeded
CPU Prochot1     | 37h | ns  |  3.1 | No Reading
CPU VRM hot0     | 38h | ok  |  3.0 | Limit Not Exceeded
CPU VRM hot1     | 39h | ns  |  3.1 | No Reading

Les ventilateurs uniquement :

ipmitool -H10.0.0.231 -Uadmin -Pmotdepasseadmin sdr type "Fan"

ce qui me donne

CPU0 Fan R0      | 41h | ok  |  3.0 | 2736.73 RPM
CPU1 Fan R0      | 43h | ns  |  3.1 | No Reading
Rear Sys Fan1    | 45h | ok  |  0.0 | 1608.75 RPM
Front Sys Fan1   | 47h | ok  |  0.0 | 1434.31 RPM

Alimentation

Eteindre proprement la machine

ipmitool -H10.0.0.231 -Uadmin -Pmotdepasseadmin power soft

Pour l’éteindre "violemment"

ipmitool -H10.0.0.231 -Uadmin -Pmotdepasseadmin power off

Et enfin pour la rallumer :

ipmitool -H10.0.0.231 -Uadmin -Pmotdepasseadmin power on

Et voilà, un outil bien pratique de plus présenté sur lindev.fr :)
N'hésitez pas à commenter .

Ch.

Sources :

17 mar. 2013

Pyinotify - surveillez votre FS

monitoring_search.png Surveillez les événements de votre système de fichier sous linux grâce à Pyinotify.

Le but de cet article est de vous faire connaître ( si ce n'est déjà le cas ) un outil qui peut s'avérer bien pratique, Pyinotify, module python qui implémente inotify.

Pour vous donner un exemple d'utilisation, l'on ma demandé récemment la possibilité de notifier par mail, tout ajout de fichier/répertoire à un endroit bien précis.

C'est alors que Pyinotify module python basé sur la "feature" inotify, ( ajoutée dans le noyau linux depuis la V 2.6.13 ) entre en jeu.

Extrêmement simple à mettre en œuvre, ce module permet de surveiller une flopée d’événements sur une ou plusieurs cible(s) ( répertoire(s) ) .

Installation

Avant toute chose, il faut être certains d'être sur une distribution linux ayant au minimum un kernel >= 2.6.13 et une version de python >= 2.4

Pour vérifier :

uname -r
2.6.32-5-amd64

python -V
Python 2.6.6

C'est ok pour moi ;)

VirtualEnv ( Non obligatoire )

Pour les tests, il est conseillé de travailler avec virtualenv et virtualenvwrapper afin d'avoir un environnement "sain" sans effet de bord dû à d'autres modules python. Je ne vais pas expliquer dans ce billet comment installer ces deux outils, ( peut être dans un prochain billet ), en attendant voici une marche à suivre.

mkvirtualenv pyinotify-test

FIN de l'étape facultative --

Pyinotify

Ensuite, comme beaucoup de modules python l'installation se fera via PIP

pip install pyinotify

Humm ... rien d'autre à dire sur ce point .

Tests

Pour tester notre module fraichement installé, nous allons créer un répertoire qui sera par la suite, LE répertoire à surveiller

mkdir /home/dirmonitored

Et pour tester Pyinotify, nous allons lancer cette commande, puis effectuer des actions dans notre répertoire test ( ajout de fichiers, création de répertoires, renommage, lecture de fichier etc ... )

python -m pyinotify -v /home/dirmonitored

Vous devriez voir ce genre de choses

[2013-03-17 15:06:05,045 pyinotify DEBUG] Start monitoring ['/home/dirmonitored'], (press c^c to halt pyinotify)
[2013-03-17 15:06:05,045 pyinotify DEBUG] New <Watch wd=1 path=/home/dirmonitored mask=4095 proc_fun=None auto_add=None exclude_filter=<function <lambda> at 0xb713d80c> dir=True >
[2013-03-17 15:06:13,995 pyinotify DEBUG] Event queue size: 32
[2013-03-17 15:06:13,996 pyinotify DEBUG] <_RawEvent cookie=0 mask=0x100 name=indamix wd=1 >
<Event dir=False mask=0x100 maskname=IN_CREATE name=indamix path=/home/dirmonitored pathname=/home/dirmonitored/indamix wd=1 >
[2013-03-17 15:06:13,996 pyinotify DEBUG] Event queue size: 32
[2013-03-17 15:06:13,996 pyinotify DEBUG] <_RawEvent cookie=0 mask=0x20 name=indamix wd=1 >
<Event dir=False mask=0x20 maskname=IN_OPEN name=indamix path=/home/dirmonitored pathname=/home/dirmonitored/indamix wd=1 >
[2013-03-17 15:06:13,996 pyinotify DEBUG] Event queue size: 32
[2013-03-17 15:06:13,997 pyinotify DEBUG] <_RawEvent cookie=0 mask=0x4 name=indamix wd=1 >
<Event dir=False mask=0x4 maskname=IN_ATTRIB name=indamix path=/home/dirmonitored pathname=/home/dirmonitored/indamix wd=1 >
[2013-03-17 15:06:13,997 pyinotify DEBUG] Event queue size: 32
[2013-03-17 15:06:13,998 pyinotify DEBUG] <_RawEvent cookie=0 mask=0x8 name=indamix wd=1 >
<Event dir=False mask=0x8 maskname=IN_CLOSE_WRITE name=indamix path=/home/dirmonitored pathname=/home/dirmonitored/indamix wd=1 >
[2013-03-17 15:06:56,626 pyinotify DEBUG] Event queue size: 32
[2013-03-17 15:06:56,626 pyinotify DEBUG] <_RawEvent cookie=0 mask=0x40000100 name=new wd=1 >
<Event dir=True mask=0x40000100 maskname=IN_CREATE|IN_ISDIR name=new path=/home/dirmonitored pathname=/home/dirmonitored/new wd=1 >
[2013-03-17 15:06:56,627 pyinotify DEBUG] Event queue size: 32
[2013-03-17 15:06:56,627 pyinotify DEBUG] <_RawEvent cookie=0 mask=0x40000100 name=rep wd=1 >
<Event dir=True mask=0x40000100 maskname=IN_CREATE|IN_ISDIR name=rep path=/home/dirmonitored pathname=/home/dirmonitored/rep wd=1 >

Bien maintenant que nous sommes certains que cela fonctionne, nous allons pouvoir créer un petit script pour surveiller notre répertoire et agir aux événements souhaités.

main.py

Commençons par créer notre fichier principal, et voici son contenu

#!/usr/bin/python
#-*- coding:utf-8 -*-


import pyinotify

wm = pyinotify.WatchManager() # Watch Manager
mask = pyinotify.IN_MOVED_TO | pyinotify.IN_CREATE    # watched events
directory = '/home/dirmonitored'


class EventHandler(pyinotify.ProcessEvent):


    def process_IN_MOVED_TO(self, event):

        if event.dir:
            print "Copie de répertoire :", event.pathname
        else:
            print "Copie de fichier :", event.pathname

    def process_IN_CREATE(self, event):

        if event.dir:
            print "Création de répertoire :", event.pathname
        else:
            print "Création de fichier :", event.pathname


handler = EventHandler()
notifier = pyinotify.Notifier(wm, handler)
wdd = wm.add_watch(directory, mask, rec=True, auto_add=True)

notifier.loop()

Voici les grandes étapes du code ci-dessus:

  1. importation du module pyinotify
  2. Création du "manager" pyinotifi
  3. Déclaration des Événements à surveiller
  4. Déclaration du répertoire à surveiller
  5. Création de la classe qui va gérer les actions en fonction des événements levés
  6. Code à exécuter si l’événement IN_MOVED_TO est remonté
  7. Code à exécuter si l’événement IN_CREATE est remonté
  8. Mise en relation de notre Manager / Gestionnaire d’événements
  9. Ajout du répertoire à surveiller de façon récursive, sur le masque d’événements "mask" avec l'activation automatique de la surveillance des nouveaux répertoires crées.
  10. Démarrage du monitoring

Testons ce bout de code

python main.py

Et voilà ce que ça donne après avoir créé un répertoire et un fichier dans notre directory surveillé

(pyinotify-test)cdsl@debian6:~$ python main.py 
Création de fichier : /home/dirmonitored/Nfichier
Création de répertoire : /home/dirmonitored/Ndirectory

Les actions de notre script ci-dessus ne fait qu'afficher un message, mais vous pouvez y coller n'importe quoi d'autre ( notification pas mail, impression, traitement du fichier puis déplacement .. etc .. ) bref Pynotify peut être utilisé pour beaucoup de choses .

Sources

Le dépôt Pyinotify API Pyinotify

Conclusion

Pyinotify , un module python à mettre entres toutes les mains, développeurs ou administrateur système .

10 mar. 2013

Surveillance de température d'une salle réseau

Comme tout bon passionné en IT, vous avez certainement acheté ou tout au moins entendu parler de cette fameuse carte "Raspberry PI". Un système complet arm avec un accélérateur graphique compatible FullHD !
De mon coté, le FullHD ne m'interesse pas vraiment ( tout du moins pour cet article ), en effet l'idée est de fixer cette carte prés de ma baie serveurs et de mesurer la température ambiante de façon constante, afin de m'avertir ( dans un premier temps par mail ) en cas de dépassement de seuil.

La carte étant alimentée via un onduleur, ce dernier doit tenir suffisamment longtemps pour remonter un incident de température en cas de panne générale.

Le matériel

Très succinct et peu onéreux, nous commençons par la raspberry pi, disponible chez farnell ( Autant prendre le model B )

SC12590_SONY-40.jpg

Et le capteur de température qui va bien et qui coute rien, temp02 disponible chez sparkfun

09418-01.jpg

Préparer la raspberry

Je pars du principe que la raspberry est fonctionnelle avec le système de base raspbian

La sonde de température fonctionne sur le bus I2C, nous allons donc commencer par installer et activer les modules qui vont bien

sudo apt-get install i2c-tools
sudo vim /etc/modules

Et y ajouter

snd-bcm2835
i2c-bcm2708
i2c-dev

Enfin ajouter l'utilisateur courant au groupe i2c pour pouvoir lire sur ce bus

sudo adduser pi i2c

Bien voilà notre système ready . Passons maintenant au capteur.

Le capteur TMP02

Quelques soudures nous attendent ... mais rien de compliqué je vous rassure tout de suite.

Bien regardons la doc, voici les points à relier ( souder ) aux PIN GPIO de notre raspberry

TMP02

Capture_d_ecran_2013-03-10_a_14.24.53.png

GPIO ( Raspberry )

raspberry-pi-rev-1-gpio-pin-out1.jpg

Liaisons

Capture_d_ecran_2013-03-10_a_14.38.20.png

Résultat

IMG_20121218_095323.jpg

Lecture des données

Bien aprés cette séance de techno ( ça me rappelle des souvenirs ) nous pouvons re-démarrer notre raspberry et tenter de detecter notre capteur, pour ce faire nous allons utiliser la commande i2cdetect

Selon le model de raspberry, il faut lister le BUS i2c 0 ou 1:

scan du BUS 0

i2cdetect -y 0
     0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f
00:          -- -- -- -- -- -- -- -- -- -- -- -- -- 
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
70: -- -- -- -- -- -- -- --        

Rien ici ... regardons le BUS 1

i2cdetect -y 1
     0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f
00:          -- -- -- -- -- -- -- -- -- -- -- -- -- 
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
40: -- -- -- -- -- -- -- -- 48 -- -- -- -- -- -- -- 
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
70: -- -- -- -- -- -- -- --  

Il y a de la vie à l'adresse 0x48
Tentons de lire à cette adresse :

i2cget -y 1 0x48 0x00 w

ce qui nous donne une valeur en hexadécimal:

0x3015

Si je regarde bien la doc le premier mot de 8bits correspond à la température en °C entière

0x15 = 21(dec)

0x03 = 3 et 3 x 0.0625 = 0.1875

Ce qui nous donne une température de 21.1875°C
Je vous laisse lire de DataSheet du capteur, qui détaille comment transformer les deux mots de 8bits en valeur décimale . ( Page 6 du document )

Programmation

Bon très bien, le capteur est reconnu, nous arrivons à lire la température, maintenant j'aimerais mettre en place un petit programme qui se chargera de lire la température à des intervalles réguliers, et de m'envoyer un mail en cas de dépassement de seuil .

Python

Hé oui, c'est mon langage préféré, il fallait s'y attendre :p .
Nous allons utiliser le module SMBus ( disponible par défaut) pour lire sur le bus i2c ainsi que le module smtplib pour l'envoi de mails.

Commençons par créer un répertoire qui contiendra notre petit projet.

mkdir check_temp
cd check_temp/

mailer.py

Commençons par créer notre module qui s'occupera d'envoyer des mails en cas de dépassement de seuil.

vim mailer.py

Voici le contenu

#-*- coding:utf-8 -*-

# Import smtplib for the actual sending function
import smtplib


def send_mail():

	# Import the email modules we'll need
	from email.mime.text import MIMEText
	
	# Open a plain text file for reading.  For this example, assume that
	# the text file contains only ASCII characters.
	fp = open('mail.txt', 'rb')
	# Create a text/plain message
	msg = MIMEText(fp.read())
	fp.close()
	
	# me == the sender's email address
	# you == the recipient's email address
	msg['Subject'] = 'ALERTE : Température Salle Serveurs'
	msg['From'] = 'raspberry@mondomaine.fr'
	msg['To'] = 'service-informatique@mondomaine.fr'
	
	# Send the message via our own SMTP server, but don't include the
	# envelope header.
	s = smtplib.SMTP('localhost')
	s.sendmail('raspberry@mondomaine.fr', [msg['To']], msg.as_string())
	s.quit()

Il vous faut adapter les lignes suivantes à votre convenance:

msg['Subject'] = 'ALERTE : Température Salle Serveurs'
msg['From'] = 'raspberry@mondomaine.fr'
msg['To'] = 'service-informatique@mondomaine.fr'

La fonction send_mail() va lire un fichier texte nommé mail.txt et envoyer son contenu à/aux adresse(s) paramétrée(s) dans msg'To'.

get_temp.py

Maintenant le fichier principal qui va s'occuper de lire la valeur du capteur, et de déclencher l'alerte mail si un seuil est dépassé .

#!/usr/bin/python
#-*- coding:utf-8 -*-
import smbus
import mailer
from time import sleep

def get_temp(bus):
   """
   Récupération et transformation des données
   """
   address = 0x48
   tmp = bus.read_word_data(address , 0 )
   Lo = (tmp & 0xff00) >> 8 ;    Hi = (tmp & 0x00ff)
   temp  = ((( Hi * 256 ) + Lo) >> 4 ) * 0.0625      
   return temp


#Connexion au bus 1
bus = smbus.SMBus(1)
while 1==1:
	temp =  get_temp(bus)
	
	if( temp > 24 ):
		fp = open('mail.txt', 'w')
		fp.write("Dernier relevé : "+str(temp))
		fp.close()
		mailer.send_mail() 

	sleep(600)

Le script ci-dessous commence par se connecter sur le bus i2c 1, grâce à la méthode smbus.SMBus(1), puis il entame une boucle infinie, qui toutes les 10 minutes ( 600 secondes ) va lire la valeur du capteur, via la méthode get_temp().

Si la température est supérieure à 24°C ( dans mon cas ), alors :

  1. le fichier mail.txt est créé
  2. le script y indique la température relevée
  3. le mail est envoy, via la méthode mailer.send_mail()

Démarrage automatique

On commence par rendre le fichier get_temp.py executable:

chmod +x get_temp.py

Puis j'ajoute les deux lignes suivantes dans le fichier /etc/rc.local

cd /home/pi/check_tmp
nohup ./get_temp.py >/dev/null &

C'est tout !

Au démarrage de votre carte, le monitoring démarrera automatiquement.
Vous pouvez surveiller ce process par le service MotdStat ( vu dans un précédent article )
Je vous l'accorde, il y a plus propre, mais le but ici est d'avoir un résultat fonctionnel à la fin du tuto.
De nombreux point peuvent être améliorés - Le script ( le rendre paramétrable, gérer une levée de défaut plus aboutit, une gestion de logs etc ... ) - Faire un vrai script de démarrage du process - Y intégrer un module GSM pour une alerte par SMS serait le Top :p

Voilà pour aujourd'hui, n'hésitez pas à me faire vos retours sur cet article, et bon amusement avec votre raspberry Pi.

- page 2 de 9 -