Archives par étiquette : raspberry pi

3 – Principe de base

Une page pour les afficher tous

Voici l’arborescence des fichiers nécessaires à l’affichage des différents modules.

  • index.php : page principale qui est appelée par le navigateur
  • ajax.php : contient le code exécuté lors des requêtes AJAX
  • inc.php : contient les fonctions PHP
  • javascript.js : contient les fonctions Javascript
  • style.css : feuille de style

Structure on-ne-peut-plus simple. La page « index.php » est appelée par le navigateur, et une fonction JavaScript se charge d’afficher le contenu de chaque module au bon endroit dans la page et de rafraichir l’affichage à intervalle régulier.

Note : Vous pourrez télécharger tous les fichiers dans une archive dans le dernier article du projet.

index.php

La page d’index se contente de positionner les balises <div> dans lesquelles seront affichés chaque module.

Dans la balise <head>, il y a une balise <meta> dont le but est de rafraichir la page toute les 3600 secondes (soit toutes les heures). Ainsi, toute la page sera rechargée, les compteurs JavaScript réinitialisés, les mise à jour du code sont prises en compte, etc…

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
  <head>
    <title>Jarvis</title>
    <meta http-equiv="Content-Type" content="text/html;charset=utf-8"/>
    <meta http-equiv="Content-Language" content="Fr"/>
    <meta name="Author" lang="fr" content="Torna"/>
    <meta name="Copyright" content="© Torna"/>
    <meta http-equiv="Cache-Control" content="no-cache">
    <meta http-equiv="Pragma" content="no-cache">
    <meta http-equiv="Expires" content="0">
    <meta http-equiv="refresh" content="3600;url=index.php">
    <script type="text/javascript" src="//ajax.googleapis.com/ajax/libs/jquery/1.8.3/jquery.min.js"></script>
    <script type="text/javascript" src="javascript.js"></script>
    <link rel="stylesheet" type="text/css" href="style.css"/>
  </head>
  <body>

    <div id="main">
      <!--div id="etalon">Jarvis <?php //echo date("Y-m-d H:i:s"); ?></div-->
      <div id="horloge"></div>
      <div id="meteo"></div>
      <div id="meteo_black"></div>
      <div id="ts3"></div>
      <div id="ping"></div>
      <div id="analytics"></div>
      <div id="vpn"></div>
      <div id="latency"></div>
      <div id="earth"><img id="img_earth" src="pict/blank.png"></div>
      <div id="moon"><img id="img_moon" src="pict/blank.png"></div>
      <div id="ifstat_oberon_up"><img id="img_oberon_up" src="pict/blank.png"></div>
      <div id="ifstat_oberon_down"><img id="img_oberon_down" src="pict/blank.png"></div>
    </div>

    <?php include('inc.php'); echo analytics(); ?>

  </body>
</html>

Pour les modules qui affichent des images (phases terre et lune, graphique de bande passante), il convient d’insérer une image vide « blank.png » afin d’éviter l’affichage d’une erreur dans la page en attendant que la requète AJAX chargée de l’affichage de l’image soit terminée.

ajax.php

C’est ce fichier qui est appelé par les requètes AJAX et qui est chargé d’appeler la bonne fonction à exécuter.

<?php

  header('Content-type: text/html; charset=utf-8');
  require_once('inc.php');

  if(isset($_REQUEST['block'])){$block = $_REQUEST['block'];}else{$block = 'none';}

  /////////////////////////////////////////////////
  //  LATENCY
  /////////////////////////////////////////////////

  if($block == 'latency'){
    echo latency();
  }

  /////////////////////////////////////////////////
  //  TS3
  /////////////////////////////////////////////////

  else if($block == 'ts3'){
    echo ts3();
  }

  /////////////////////////////////////////////////
  //  METEO
  /////////////////////////////////////////////////

  else if($block == 'meteo'){
    echo meteo();
  }

  /////////////////////////////////////////////////
  //  PING
  /////////////////////////////////////////////////

  else if($block == 'ping'){
    echo ping();
  }

  /////////////////////////////////////////////////
  //  VPN PPTPD
  /////////////////////////////////////////////////

  else if($block == 'vpn'){
    echo vpn();
  }

  /////////////////////////////////////////////////
  //  IFSTAT
  /////////////////////////////////////////////////

  else if($block == 'ifstat'){
    imagickHisto ($_REQUEST['max'], $_REQUEST['eth'], $_REQUEST['up_down']);
  }

?>

Un bloc de code pour chaque module. En fonction de la variable $block passée en paramètre de la requète AJAX, on appelle la fonction ciblée.

inc.php

Ce fichier contient les fonctions appelées par le fichier ajax.php. Même principe, un bloc de code pour chaque module.

En gros, une fonction par module 🙂 Le détail de chaque fonction fera l’objet d’un article à suivre.

javascript.js

Ce fichier contient les fonctions JavaScript qui vont lancer les requêtes AJAX à intervalle réuglier.

/* initialisation des fonctions de tous les modules au chargement de la page */
$(document).ready(function() {
   fonction_nom_du_module_1 ();
   fonction_nom_du_module_2 ();
   ...
});

/* initialisation des variables timeout pour chaque module */
var timeout_nom_du_module_1; 
var timeout_nom_du_module_2;
...

/* définition de la fonction pour le module nom_du_module_1 */

function nom_du_module_1 ()
{
  $.ajax({
    async : false,
    type: "GET",
    url: "./ajax.php",
    data: "block=nom_du_module_1",
    success: function(html){
      $("#nom_du_module_1").html(html);
    }
  });

  g = setTimeout("nom_du_module_1()", 10000);
}

Je ne mets ici que la structure gobale du fichier pour expliquer le principe. Le fichier complet sera disponible au téléchargement dans le dernier article.

style.css

Ce fichier contient la feuille de style de la page, c’est elle qui contient toutes les options de mise en forme des éléments de la page (position, taille, couleurs, etc…).

/* init */

body
{
  background-color  : rgba(0, 0, 50, 1);
  font-family       : Verdana, "Courier New", "Lucida Console";
  font-size         : 14px;
  font-weight       : normal;
  padding           : 0px;
  margin            : 0px;
  overflow          : hidden;
}

div, table, tr, td, th, h1, h2, h3, a, span, p, pre, fieldset, input, textarea, form, img, select
{
  font-family       : Verdana, "Courier New", "Lucida Console";
  font-size         : 14px;
  font-weight       : normal;
  padding           : 0px;
  margin            : 0px;
  color             : #FFF;
}

/* main */

div#main
{
  width             : 1366px;
  height            : 768px;
  position          : relative;
  overflow          : hidden;
  background-color  : rgba(0, 0, 0, 1);
  color             : #FFF;
}

La div qui a pour id main est la div qui contient toutes les autres div de chaque module. Ici, je fixe sa taille en pixel à la résolution native de mon écran 1366×768 px.

La couleur de fond (background-color) est fixée au noir mais vous pouvez choisir ce qui vous plaît 🙂

1 – Raspberry Pi Home Dash Screen

J’ai toujours été passionné par la domotique et par tout ce qui touche à l’informatique dans la maison. J’adore les stations météo qui affichent tout un tas d’informations, les horloges high-tech qui font calendrier et qui sonnent quand vous recevez un mail, les cadres photos numériques, etc,… En revanche, vous ne trouverez chez moi aucun de ces appareils (ou presque). En effet, je trouve que ce qui existe aujourd’hui est soit beaucoup trop limités, soit très limités et beaucoup trop chers 😀

En parallèle, j’aime avoir une vue globale sur ce qui se passe sur mon réseau informatique à la maison. Savoir comment se porte ma bande passante, connaitre l’état de mes serveurs et NAS, savoir qui est connecté sur mon serveur TeamSpeak ou sur mon VPN, etc…

J’adore également savoir quelle est la phase de la lune, et connaître l’ensoleillement de la terre au cours de la journée, l’heure du lever et du coucher du soleil… Les écrans de contrôle de la NASA, comme on les voit dans les films, me font un certain effet 😉

Donc voilà, un projet relativement simple mais très fun, un écran tableau de bord pour regrouper toutes ces données 🙂

Bien en vue au dessus du bar qui sépare ma cuisine de mon séjour, voici ce que ça donne :

IMG_5393

Cette photo montre la chose dans sa version finale, proprement installée au mur.

En détail

Voilà la liste des informations qui sont représentées sur cet écran :

  • Phase de la terre avec cartographie des nuages en temps réel
  • Phase de la lune
  • Heure
  • Date
  • Météo du jour
  • Prévisions météo à 3 jours
  • Etat des serveurs et NAS
  • Clients TeamSpeak connectés
  • Clients VPN connectés
  • Bande passante internet

J’ajoute de temps en temps des fonctionnalités, tant qu’il reste de la place pour afficher des informations. L’important c’est que ce soit visible/lisible depuis n’importe où dans la pièce.

Voici ce que ça donne en détail (cliquez pour agrandir) :

dashscreen_final

Le matériel nécessaire

Contrairement à mes autres projets, ici un Raspberry Pi et un écran suffisent… D’ailleurs, vous pouvez utiliser autre chose qu’un Pi, notamment un vieux eeePC ou PC portable pour rester dans le compacte 🙂 Une tour standard fera également l’affaire si vous pouvez la planquer. J’ai simplement ajouté un dongle WiFi pour connecter le Pi au réseau car aucune prise RJ45 n’arrive à cet endroit. Un support mural pour accrocher l’écran au mur ainsi qu’une goulotte extra plate pour masquer les câbles d’alimentation. Si vous choisissez de poser votre écran au dessus de votre frigo par exemple, vous économiserez l’achat de ces deux accessoires.

Pour l’écran, choisissez le moins cher. Préférez les écrans LED, plus fin et qui consomment moins. Ils offrent généralement un angle de vue plus large (pratique quand on se balade dans la pièce), ainsi qu’une luminosité plus élevée. Si vous souhaitez l’accrocher au mur, il doit biensur disposer des fixations de type VESA. Pour la taille, c’est comme vous voulez, et cela dépend de ce que vous voulez afficher. Sachez toutefois qu’un écran de plus de 20-22″ devient vite encombrant… Je vous conseille donc une écran entre 16″ et 20″, au format 16/9 (plus esthétique qu’un 4/3), avec un bord fin (toujours par souci d’esthétisme 😉 ).

Voici en détail ce que j’ai choisi :

  • Un Raspberry Pi Modèle B 512Mo
  • Une carte mémoire SDHC 8Go
  • Un dongle WiFi USB NetGear WNA1000M
  • Un écran LCD AOC e941Vwa 18,5″ (n’importe quel écran peut convenir)
  • Un support mural VESA pour écranAavara EL1010
  • Une goulotte plate pour cacher les câbles

Dans les prochains articles, j’expliquerai comment procéder pour créer facilement ce type d’écran et je publierai tout mon code source en détaillant le fonctionnement de chaque module.

Comme toujours, et j’insiste, je compte sur vous pour alimenter la chose, partager vos avis et idées d’amélioration. Si vous réalisez quelque chose de ce type, ce pourrait être génial de créer un soft avec une bibliothèque qui regrouperait tous les modules créés. 🙂

IMG_5389

11 – En résumé

IMG_5382Après trois semaines d’utilisation quotidienne de mon Pi JukeBox, je peux vous dire que c’est vraiment génial 🙂 Je rentre dans ma voiture, je démarre, la musique reprend où elle s’était arrêtée. Mon iPhone se connecte automatiquement au réseau wifi créé par le Pi, et je peux prendre la main sur le jukebox via l’application MPoD pour changer de playlist ou zapper une chanson. Dans la pratique, les musiques défilent d’un jour à l’autre sans que j’ai besoin de sortir mon smartphone, car rappelons le, le Pi est autonome, MPoD n’est qu’une sorte de télécommande 🙂 Le son, quant à lui, est très correcte 🙂 La cerise sur le gatêau, c’est que je n’ai plus besoin de transcoder mes FLAC en MP3 pour pouvoir les écouter dans la voiture 🙂

Le truc marrant, c’est que si ma femme n’aime pas la chanson qui passe, elle peut prendre la main sur le jukebox avec son smartphone (ou sa tablette), et choisir ce qui lui plaît 🙂

IMG_5369Un point à optimiser toutefois, à part le rangement dans la boite à gants ;), le temps de démarrage. En effet, entre le moment où je démarre la voiture, et le moment où la musique se met en route, il se passe bien 40 secondes… En gros, le temps qu’il me faut pour arriver au portail et le temps qu’il s’ouvre,…

liporider1Pour le moment, l’extinction se fait à la hussarde, brutalement lorsque je coupe le contact. Après trois semaines d’utilisation en prennant ma voiture entre deux et quatre fois par jour, je n’ai constaté aucun problème. Cependant, à terme, pour éviter de « fatiguer » mon Pi, j’utiliserai probablement un circuit chargeur de batterie de ce type : http://www.evola.fr/product_info.php/chargeur-p-73, comme me l’a suggéré Seb@stien en commentaire 🙂 Merci encore pour l’info 🙂

Voici une petite vidéo de démonstration 🙂

En bref

C’est un système très sympa qui permet d’étendre les fonctionnalités de votre autoradio, sans défigurer votre tableau de bord. L’utilisation d’un smartphone et de l’application MPoD pour commander le jukebox, permet d’avoir une interface tactile avec visualisation des infos sur la musique en cours de lecture (groupe, album, titre, pochette d’album, paroles, etc,…), gestion des playlists etc,… L’ensemble reste très discret (tout est planqué dans la boite à gants), et m’a permis de conserver mon autoradio d’origine 🙂

Le matériel complet, environ 155€

 Technos et logiciels utilisés

  • Linux, Raspbian
  • MPD
  • MPoD
  • hosapd
  • CURL
  • Script Bash

Sommaire

Forums de discussion

10 – Un boitier en Légos

J’aime beaucoup les Légos, les possibilités sont sans limites, et c’est très pratique pour réaliser de petits boitiers fonctionnels et sur mesures 🙂 En attendant que les imprimantes 3D deviennent abordables, je n’ai pas trouvé mieux 🙂

image

Comme vous pouvez le constater sur la photo ci-dessus, la carte du Pi correspond, à 1 mm près, à 7 x 11 plots de Légo. Ce qui fait que la carte tient parfaitement en place, avec très peu de jeu. Le circuit Velleman VM188 occupe lui 6 x 10 plots. L’ensemble tient tout juste sur une hauteur de 3 rangées de Légo. On pourrait penser que ça a été fait pour 😉

Il ne reste qu’à placer le couvercle, et à positionner le régulateur de tension 🙂

imageIMPORTANT : Lorsque l’on abaisse une tension comme ici, en passant de 12V à 5V, il y a une partie de l’énergie qui est « absorbée » par le circuit. Pour connaître la puissance absorbée ou « dissipée » en Watt par le circuit, il faut faire la différence entre la puissance du courant de sortie et celle du courant d’entrée P diss = P out – P in. On obtient la puissance en faisant le produit de la tension et de l’intensité du courant P = U x I. Si on considère que le Pi tire environ 700 mA, soit 0,7 A, on obtient P diss = 12 x 0,7 – 5 x 0.7 = 4,9 W. Sur ces 4,9 W de puissance dissipée, une partie sera convertie en chaleur, c’est l’effet Joule. Ce qui veut dire que le module va chauffer ! C’est pour cela que le régulateur de tension  KEMO M015N est équipé d’une patte en métal qui sert de radiateur, et  qui peut être vissé à un radiateur plus grand en cas de besoin. Sur la datasheet du régulateur de tension  KEMO M015N il est précisé qu’au-delà de 3W dissipé, il est conseillé de laisser respirer le module et de ne pas l’enfermer. Au-delà de 6W, il est vivement recommandé d’utiliser un radiateur pour refroidire le module.

Comme le régulateur de tension  KEMO M015N risque de chauffer, je vais le positionner au dessus du boitier, en laissant bien respirer la patte en métal. Voici le résultat final :

image

Tout à fait à gauche, le domino qui fera le lien avec le faisceau électrique de l’allume-cigare. A droite, la carte son prête à être connectée à l’autoradio 🙂

Baptisé Carpo (en référence à une lune de Jupiter), le module est presque complet. Il me reste le circuit capacitif pour l’extinction du dispositif à ajouter 🙂

8 – Alimentation du Pi dans la voiture 2/3 – Allumage

Au démarrage de la voiture

Le problème

Si nous branchons simplement le Pi sur un abaisseur de tension, que se passe-t-il lorsque nous entrons dans notre voiture et démarrons le moteur :

  1. On entre la clé, et on met le contact (petit pique de tension)
  2. A ce moment là, du courrant est disponible sur le circuit électrique et le Pi boot
  3. On tourne la clé à fond pour démarrer le moteur (grosse chute de tension + parasites)
  4. Là, l’appel de courant du démarreur est tel que plus rien n’est disponible pour le Pi, qui s’éteint, privé de courant
  5. Le moteur tourne (tension relativement stable selon usage des équipements de la voiture)
  6. Du courant est à nouveau disponible, et le Pi boot à nouveau

Pour faire simple, notre pauvre Pi s’en prend plein les carreaux… Subissant piques et chutes de tension, parasites, multiple boots et extinctions sauvages… On peut s’attendre à réduire considérablement la durée de vie du Pi, voir à sérieusement l’endommager dès les premières utilisations.

La solution

La première chose à faire est de choisir un régulateur de tension continue stabilisé et anti-parasite. Ceci permettra d’absorber les variations importantes du courant pour fourrnir une tension propre et stable au Pi.

imageLe régulateur de tension  KEMO M015N disponible chez Conrad notamment, répond à ces exigeances. Il permet de choisir la tension de sortie voulue (5V pour  le Pi), et accepte une tension d’entrée entre 6V et 28V (parfait pour les 12V fournis par la prise allume cigare).

Ensuite, il faut empêcher le Pi de booter lorsque l’on met le contact avant de démarrer le moteur, et le démarrer seulement une fois que le moteur tourne. Pour cela, il convient d’ajouter un petit circuit de tempo équipé d’un relais, qui n’autorisera l’arrivée du courrant au Pi qu’au bout de quelques secondes.

ar-module-vm188-377C’est alors que j’ai repensé au circuit de tempo Velleman VM188 que j’aurais pu utiliser pour mon projet Pi TimeLapse. En effet, ce petit circuit alimenté en 12V (comme c’est pratique 😉 ), peut être utilisé de plusieur façons, et notamment, déclancher le relais après un nombre de secondes déterminé. En déclenchant le relais au bout de 10 secondes, le Pi ne sera pas alimenter entre le moment où vous mettez le contact et le moment où vous démarrez le moteur.

Un mot sur le circuit de tempo Velleman VM188 : Quelque soit votre projet, si vous avez besoin d’une minuterie à sortie sur relais, c’est LE kit qu’il vous faut ! Vous pouvez le trouver entre 15€ et 20€ (pas donné mais très fonctionnel…), et faire fonctionner sur des temps allant de 1 seconde à 60 heures selon 4 modes :

  • démarrage avec impulsion (démarre allumé)
  • démarrage avec pause (démarre éteint)
  • activation et désactivation unique (s’allume ou s’éteint après un certain temps)
  • fonctionnement cyclique (s’allume puis s’éteint en boucle, on peut choisir la durée d’allumage et la durée de coupure pour chaque cycle)

Le relais équipé est prévu pour des courants de 230V sur 16A, vous avez donc de quoi programmer l’alimentation tout ce que vous souhaitez dans votre maison, voiture, panneaux solaires,…

Voici le schéma complet du montage :

UntitledAvec ce montage, j’assure à mon Pi une alimentation propre, sans danger pour ma voiture 🙂

Reste à gérer la coupure brutale de courant lorsqu’on éteint le moteur…

 

7 – Alimentation du Pi dans la voiture 1/3

Comme pour le projet Pi TimeLapse l’alimentation du Raspberry Pi est le point le  plus problématique. Décidemment, il n’existe pas de solutions simples et universelles…

463372_10151013958851148_2123947142_o_art-8-19403

Présentation du contexte

Je souhaite brancher mon Pi JukeBox sur le circuit électrique de ma voiture. De nos jours, les prises allume-cigares présentes dans les voitures sont prévues pour fournir du courant ; d’ailleurs, même s’il s’agit toujours d’une prise dite « allume-cigare », cela fait déjà quelques années qu’on ne trouve plus la résistance permettant d’allumer une cigarette… A la place, un jolis capuchon en plastique avec la mention « 12V« , preuve qu’il s’agit maintenant plus d’un circuit d’alimentation qu’autre chose. D’ailleurs, les fusibles ont été adaptés et il y a un système d’économie d’énergie qui met « en veille » la voiture au bout d’un certain temps lorsque du courant est tiré sur la batterie moteur éteint. Les derniers modèles de voiture ne s’embarassent même plus de se type de prise, et proposent directement une prise USB… Comme ça c’est clair 🙂

Branchement sur le faisceau électrique 12V

Il convient de faire un montage discret, sans monopoliser la prise allume-cigare qui pourra servir pour autre chose.

Dans ma voiture, il m’a suffit de démonter la console centrale pour accéder au faisceau électrique de la prise allume-cigare. Grâce à un domino, je fais une dérivation (un branchement en parallèle) et fais passer le câble derrière l’autoradio jusque dans la boîte à gants où sera logé l’ensemble du dispositif. Une fois la console centrale remise en place, on ne voit rien du tout 🙂

image

Nous avons donc une source d’alimentation continue 12V à porté de main. Il suffit donc d’un simple abaisseur de tenstion 12V -> 5V pour alimenter le Pi 🙂

Sauf que… c’est loin d’être aussi simple si on veut faire les choses proprement ! En effet, l’allumage de la voiture et son arrêt peuvent poser problème…