Estacion grafica multimedia con Raspberry Pi


En el post de hoy vamos a demostrar gracias a MagdiBlog como hoy en día se pueden hacer interfaces gráficas muy potentes  mostrando información util simplemente usando una Raspberry conectada a un monitor de forma permanente gracias al bajisimo consumo de esta estupenda placa.

En efecto a todos nos gustan las estaciones meteorológicas que muestran una gran cantidad de información,  si es posible ,incluso sensible a la ciudad donde se viva. Ademas si , añade relojes de alta tecnología que hagan de calendario ,muestren  sonido cuando reciba un correo, sirva de marco digital, etcétera..mucho mejor ¿verdad?. Sin embargo, no es fácil encontrar cualquiera de estos dispositivos  (o casi). De hecho,soluciones comerciales  que existen hoy en día son  mucho mas limitadas ,y de todos modos, ,también son  emasiado costosas …

Pues en el proyecto de hoy veremos como gracias a una Raspberry esto es posible añadiendo ademas múltiples funciones tan solo limitadas por la imaginación pues ,por ejemplo el autor ademas de todo lo anterior ,quería tener tener una visión global sobre lo que está pasando en su red de hogar, su ancho de banda, el estado de  servidores y del  NAS, saber quién está conectado a su servidor TeamSpeak o  VPN, etcetera..todo ello ademas mostrando  la fase de la luna y el sol a la tierra durante el día, la hora del amanecer y el atardecer.

Así que este  proyecto relativamente simple (pero muy divertido) aporta una espectacular consola gráfica  que agrupa todos estos datos  de una forma realmente espectacular .

IMG_5393

El equipo necesario

A diferencia de otros proyectos, con una Raspberry Pi y una pantalla son suficientes.. Además, puede utilizar algo que no sea una Pi, incluyendo un viejo eeePC ,un  PC portátil en desuso ,una torre estándar  ,etc.

Simplemente necesita agregar  un soporte de pared para colgar la pantalla en la pared, así como un canal extra plana para ocultar los cables de alimentación (si decide disponer su pantalla por encima de la nevera por ejemplo, ahorrará comprando estos dos accesorios).

Para la pantalla,una opción es  elegir la más barata de tipo LED, pues son pantallas más delgadas,y consumen menos energia  ofreciendo un ángulo más amplio (conveniente cuando caminas en la habitación), así como un mayor brillo.Si quiere colgar  la pantalla  en la pared, debe tener claro el tipo que VESA monta que depende del  del TV monitor qeu vaya a colgar. Tenga en cuenta, sin embargo, que una pantalla de más de 20 – 22″ pantalla se convierte en rápidamente voluminosa… Por ultimo seria recomendable una pantalla de entre 16 y 20, en formato 16: 9 (más estética de 4/3), con un borde fino (siempre por el bien de estética ).

Aquí se  muestra  el detalle del hardware necesario :

  • Un modelo de Raspberyy Pi B 512 MB ( o superior)
  • Una tarjeta de memoria SDHC 8 GB
  • Un adaptador WiFi USB NetGear WNA1000M ( no es necesario con la Raspberry Pi 3)
  • Una pantalla LCD  (por ejemplo una de 8, 5 pulgadas , pero cualquier pantalla puede ser conveniente)
  • Soporte de pared VESA para pantalla
  • Una canaleta de pvc  para esconder los cables

 

 

En detalle

Esta es la lista de información que el autor decidió mostrar en la pantalla conectada  a una Raspberry  :

  • Fase de la tierra con el trazado de las nubes en tiempo real
  • Fase de la luna
  • Hora
  • Fecha
  • El tiempo en hoy
  • Previsión del tiempo para 3 días
  • Estado de servidores y NAS
  • TeamSpeak clientes conectados
  • Clientes VPN conectados
  • Ancho de banda de Internet
  • etc

Incluso es posible añadir  alguna  característica pues todavía hay espacio para mostrar la información: lo importante es que sea visible y legible desde cualquier lugar en la sala.

 

A continuación  el árbol de archivos necesarios para mostrar los diferentes módulos.

  • index.php: página principal que es llamada por el navegador
  • ajax.php: contiene el código que se ejecuta cuando se hacen  peticiones AJAX
  • .inc.php contiene las funciones de PHP
  • javascript.js contiene las funciones de JavaScript
  • hoja de estilo style.css

La estructura es muy fácil como  vemos siendo la página “index.php” la llamada por el navegador.Esta es la encargada de cargar mediante una función JavaScript para ver el contenido de cada módulo en el lugar correcto en la página ,la cual  pide  actualizaciones  automáticamente de la pantalla a intervalos regulares  de 3600s gracias a la sentencia meta incluida en la cabecera :

<Meta http-equiv = "refresh" content = "3600; url = index.php">

 

Nota: Puede descargar todos los archivos en un archivo en el último artículo del proyecto.

index.php

La página de índice se contenta con la posición de laz etiquetas<div>  que se mostrarán en  cada módulo.

En la etiqueta <head>, hay una etiqueta <meta> que tiene como objetivo actualizar la página cada 3600 segundos (cada hora). De este modo, se volverá a cargar la página entera, los contadores de JavaScript de reposición, código actualizadas son tomadas en cuenta, etc …

  <! DOCTYPE HTML PUBLIC "- // W3C // DTD HTML 4.01 Transitional // EN" "http://www.w3.org/TR/html4/loose.dtd">
 <Html>
   <Head>
     <Título> Jarvis </ title>
     <Meta http-equiv = "Content-Type" content = "text / html; charset = UTF-8" />
     <Meta http-equiv = contenido "Content-Language" = "es" />
     <Meta name = "autor" lang = "es" content = "subir" />
     <Meta name = contenido de "derechos de autor" = "subir ©" />
     <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 = "principal">
       ? Jarvis <? Php // fecha de eco ( "Ymd H: i: s') - <div id =" semental ">!?  ?> </ DIV ->
       <Div id = "reloj"> </ div>
       <Div id = "Tiempo"> </ div>
       <Div id = "meteo_black"> </ div>
       <Div id = "TS3"> </ div>
       <Div id = "ping"> </ div>
       <Div id = "análisis"> </ div>
       <Div id = "VPN"> </ div>
       <Div id = "latencia"> </ div>
       <Div id = "tierra"> <img id = "img_earth" src = "PICT / blank.png"> </ div>
       <Div id = "luna"> <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');  analytics de eco ();  ?>

   </ Body>
 </ Html>

Para los módulos que se muestran las imágenes (fases de la tierra y de la luna ancho de banda, gráficos), es apropiado  insertar una imagen en blanco “blank.png” para evitar mostrar un error en la página hasta que el petición AJAX responsable de la visualización de la imagen se ha completado.

ajax.php

Este es el archivo que se llama por peticiones AJAX y es responsable de llamar a la función derecho a ejecutar.

  <? Php

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

   if (isset ($ _ REQUEST [ 'bloque'])) {$ bloque = $ _REQUEST [ 'bloque'];} else {$ bloque = 'none';}

   /////////////////////////////////////////////////
   // LATENCIA
   /////////////////////////////////////////////////

   if ($ == bloque 'latencia') {
     latencia echo ();
   }

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

   else if ($ == bloque 'TS3') {
     eco TS3 ();
   }

   /////////////////////////////////////////////////
   // TIEMPO
   /////////////////////////////////////////////////

   else if ($ bloque == 'Tiempo') {
     eco de tiempo ();
   }

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

   else if ($ == bloque de 'ping') {
     eco ping ();
   }

   /////////////////////////////////////////////////
   // VPN PGWP
   /////////////////////////////////////////////////

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

   /////////////////////////////////////////////////
   // ifstat
   /////////////////////////////////////////////////

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

 ?>

Un bloque de código para cada módulo. Dependiendo del bloque de $ variable pasada como parámetro a la consulta AJAX, llamada la función objetivo.

inc.php

Este archivo contiene las funciones llamadas por el archivo ajax.php. Sigue el mismo principio que los anteriores: un bloque de código para cada módulo.

Básicamente, incluye una función por módulo  cuyos  detalles seria complejo explicar .

javascript.js

Este archivo contiene las funciones de JavaScript que pondrá en marcha peticiones AJAX   a un  intervalo regular .

  / * Inicializar las funciones de todos los módulos a cargar la página * /
 $ (Document) ready (function () {
    fonction_nom_du_module_1 ();
    fonction_nom_du_module_2 ();
    ...
 });

 / * Inicializar las variables de tiempo de espera para cada módulo * /
 timeout_nom_du_module_1 var; 
 timeout_nom_du_module_2 var;
 ...

 / * Definición de la función para la nom_du_module_1 módulo * /

 función nom_du_module_1 ()
 {
   $ .ajax ({
     asíncrono: falso,
     del tipo: "GET"
     url: "./ajax.php"
     datos "bloque = nom_du_module_1"
     el éxito: function (html) {
       . $ ( "# Nom_du_module_1") HTML (HTML);
     }
   });

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

No se pone  la estructura de archivos aquí gobal para explicar el principio. El expediente completo estará disponible para su descarga en el final del artículo.

style.css

Este archivo contiene la hoja de estilo de página, que es la que contiene todas las opciones  gráficas de formato de elementos de la página (posición, tamaño, colores, etc …).

  / * * Init /

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

 div, tabla, tr, td, TH, h1, h2, h3, a, lapso, p, pre, fieldset, de entrada, área de texto, la forma, img, seleccionar
 {
   font-family: Verdana "Courier New", "Lucida Console";
   font-size: 14px;
   font-weight: normal;
   padding: 0px;
   margen: 0px;
   Color: #FFF;
 }

 / * Inicio * /

 div mano #
 {
   anchura: 1366px;
   altura: 768px;
   position: relative;
   overflow: hidden;
   background-color: RGBA (0, 0, 0, 1);
   Color: #FFF;
 }

El div id cuya mano es el div contiene todos los demás div de cada módulo. Aquí se fija tamaño en píxeles de resolución nativa de la pantalla 1366 x 768 px.

El color de fondo (background-color) está unido al negro, pero se puede elegir lo que le guste

 

4 – Módulo 1 – Fecha y Hora

Volvamos en el meollo de las cosas con este primer módulo que muestra la fecha y la hora.

reloj1

Este módulo es muy simple, completamente en JavaScript. El módulo se llama: Reloj

index.php

En la página de índice, por lo que este es el <div> con el reloj Identificación del que nos interesa.

  <Div id = "reloj"> </ div>

La etiqueta se queda vacía, y se “llena” por medio de la función de JavaScript.

style.css

Al igual que con todos los módulos, se debe crear un div cuyo id es el nombre del módulo (aquí reloj) que contendrá la información a mostrar y, a continuación, establezer su tamaño y posición en la pantalla.

  / * Reloj * /

 div # reloj
 {
   derecha: 0px;
   top: 0px;
   position: absolute;
   overflow: hidden;
   background-color: RGBA (0, 0, 0, 1);
   Color: #FFF;
   font-weight: bold;
   text-align: center;
 }

 div.horloge_heure
 {
   font-size: 180px;
   background-color: RGBA (0, 0, 0, 1);
 }

 div.horloge_date
 {
   font-size: 50px;
   background-color: RGBA (0, 0, 0, 1);
 }

 span.horloge_grey
 {
   color: # 888;
   font-size: heredar;
 }

javascript.js

Esta función simple se basa en la hora del sistema, y muestra las horas y 24 minutos más o menos, a continuación, justo por debajo del día a día que en el mes, el nombre de mes y año .

  horloge_timeout var;

 función de reloj ()
 {
   dows = [ "Domingo", "Lunes", "Martes", "Miércoles", "Jueves", "Viernes", "Sábado"];
   meses = [ "f é v" "Jan", "Marzo", "Abril", "puede", "Junio", "Julio", "Agosto y ucirc; t", "Seven", "Octubre", "Noviembre" "dE c"];

   ahora = new Date;
   hora = now.getHours ();
   now.getMinutes min = ();
   now.getSeconds sec = ();
   jour_semaine = dows [now.getDay ()];
   día = now.getDate ();
   mes = mes [now.getMonth ()];
   año = now.getFullYear ();

   si (seco <10) {sec0 = "0";} else {sec0 = "";}
   si (min <10) {min0 = "0";} else {min0 = "";}
   si (hora <10) {heure0 = "0";} else {heure0 = "";}

   horloge_heure = hora + ":" + + min0 min;
   horloge_date = "<span class = 'horloge_grey'>" + jour_semaine + "</ span>" + fecha + "" + mes + "<span class = 'horloge_grey'>" + año + "</ span>";
   horloge_content = "<div class = 'horloge_heure'>" + horloge_heure + "</ div> <div class = 'horloge_date'>" + horloge_date + "</ div>";

   $ ( "# Reloj") html (horloge_content).

   horloge_timeout = setTimeout ( "reloj ()", 1000);
 }

Cada 1000 ms, o cada segundo, el contenido del div reloj se actualiza con el contenido de la horloge_content variable. También puede mostrar segundos en la pantalla si lo desea 

Esto en cuanto a este primer módulo muy simple, pero entre los más útiles para visualizar en la pantalla

5 – Módulo 2 – Xplanet

Esta es la utilidad  más vistosas  que mereceria una pantalla por sí misma:la pantalla de la tierra con el mapa fase nubes sol en tiempo real, así como la fase de la luna Este módulo se basa en el software Xplanet para generar imágenes de todos los planetas  y satélites del sistema solar. Puede representar en tiempo real cada vez, todo el sistema solar con la posición de las estrellas y planetas, hacer zoom sobre una o más planetas, etc …

En cuanto a la tierra, se puede ver la posición de las ciudades y una gran cantidad de información, incluyendo el clima. También es posible representar nuestros satélites artificiales con su posición real, órbita, etc …

xplanet

instalación

Xplanet es una aplicación que ha sido … muy larga! Está disponible en los repositorios de Debian, por lo que instalarlo, es simple:

  apt-get install xplanet

los mapas

La base de Xplanet contiene un “mapa” para cada planeta (una imagen que representa la superficie). Se puede, y es recomedable descargar mapas mejor en alta definición. También es interesante  descargar un mapa dedicado a la parte de la superficie de la tierra que no se expone al sol (noche), de lo contrario será simplemente Xplanet el mapa de la jornada.

Aquí se pueden encontrar muchos mapas de la tierra y todos los otros planetas del sistema solar:

Xplanet trabajará para crear una combinación de las dos imágenes para representar la parte soleada de la tierra y la parte en  oscuridad.

La generación de imágenes

Xplanet es en última instancia un generador de imágenes que representa las estrellas en su estado en un momento T y desde cierto punto de vista. Todo sucede en la línea de comandos, y como se puede ver navegando por la página web Xplanet, hay cientos de opciones! Aquí veremos  la configuración que se utiliza para la pantalla.

De hecho,  genera dos imágenes diferentes, una para la tierra y otra para la luna. Aquí está el  archivo de configuración xplanet.conf:

  [Por defecto] # Los valores de esta sección se aplican a todos los cuerpos menos que se modifique a continuación.

 arc_color = blanco
 arc_thickness = 1
 bump_scale = 3
 cloud_gamma = 1
 cloud_ssec = false
 cloud_threshold = 90
 color = {} # 255255255 caja de color de reserva en un mapa de imagen no se encuentra
 draw_orbit = false
 rejilla = false
 grid1 = 6
 Grid2 = 15
 magnificar = 1
 marker_color = rojo
 max_radius_for_label = 3
 min_radius_for_label = 0,01
 min_radius_for_markers = 40
 Órbita = {-. 5, .5,2}
 orbit_color = {} # 255255255 color para la órbita
 random_origin = true
 random_target = true
 sombreado = 30 # 0 = negro, 100 = Sami tiene dayside
 text_color = {} # 255,0,0 color del texto (marcadores de etiquetas y Cuerpo)
 crepúsculo = 6 # mezclan las imágenes para el día y la noche
                                 # Dentro de este píxel Muchos grados de
                                 # El terminador

 [Sol]
 "Sun"
 color = {255 255 166}
 map = / home / Jarvis / xplanet / img / sunmap.jpg
 max_radius_for_label = 0
 sombra = 100

 [Tierra]
 "Tierra"
 color = {28, 82, 110}
 map = / home / Jarvis / xplanet / img / land_ocean_ice_2048.jpg
 night_map = / home / Jarvis / xplanet / img / noche dark.jpg
 cloud_map = / home / Jarvis / xplanet / img / clouds_2048.jpg
 min_radius_for_label = 0

 [Luna]
 "Luna"
 color = {100, 100, 100}
 map = / home / Jarvis / xplanet / img / moonmap2k.jpg

En el [la tierra] por la tierra y [Luna] a la luna, que vea las rutas de acceso a los mapas para el día de “mapa” y “night_map” modo noche.

Las nubes

También vimos el mapa “cloud_map” por la tierra. De hecho, Xplanet permite emular una imagen o mapa de las nubes en la tierra para obtener un resultado muy realiza con la cobertura de nubes visto casi en tiempo real.


Se puede conseguir esta tarjeta nubes o “cloud_map” en diversos sitios. Según las fuentes, que se actualizan entre 1 y 10 veces al día: http://xplanet.sourceforge.net/clouds.php

Debe ser un pequeño script que descarga el último mapa publicado nubes. Una tarea cron se encargará de ejecutar el script a intervalos regulares. Xplanet_cloud.sh es mi guión:

  #! / Bin / sh

 Pat = / home / Jarvis / xplanet / img / # destino de la imagen descargada
 tmp = $ pat nombre de archivo temporal # "tmp_clouds_2048.jpg"
 img = $ pat "clouds_2048.jpg" # nombre del archivo final

 rm $ tmp # borrar el archivo temporal de edad

 $ Wget -O imagen tmp # http://xplanet.sourceforge.net/clouds/clouds_2048.jpg descargado

 if [-f $ tmp];  a continuación, # si el archivo se ha descargado ...
   mogrify -resize 2000x1000 $ tmp # redimenssionne la imagen descargada de manera que sea la misma resolución que el mapa "día"
   $ Mv tmp $ img # sustituye a la antigua imagen con el nuevo
   $ Pat Jarvis chown -R www-data && chmod -R 775 $ pat # cambia los permisos en el archivo
 fi

Recuerde hacer el script ejecutable con chmod 755 xplanet_cloud.sh 

Y eso es tarea CRON asociado que se pueden configurar con el comando crontab -e:

  0 * / 4 * * * /home/jarvis/xplanet/xplanet_cloud.sh

Cada 4 horas, la secuencia de comandos se ejecuta y un nuevo mapa se descargan las nubes 

generar imágenes

El último paso, se inicia xplanet iniciar el sistema para generar imágenes de la tierra y la luna cada N minutos,lo cual se consigue conun pequeño script llamado  Xplanet.sh  que contiene dos controles (uno para la imagen de la tierra y para la imagen de la luna).

Este es el contenido del script:

  #! / Bin / sh

 TIERRA #
 xplanet -conf /home/jarvis/xplanet/xplanet.conf -output /home/jarvis/xplanet/img/xplanet_earth.png -wait 120 tierra -cuerpo -latitud -Longitude 40 10 500x500 y -geometry

 LUNA #
 xplanet -conf /home/jarvis/xplanet/xplanet.conf -output /home/jarvis/xplanet/img/xplanet_moon.png -wait 600 -cuerpo luna -geometry 250x250 y

Veamos al comando xplanet ,el cual soporta los siguientes parámetros:

  • -conf: xplanet.conf el archivo de configuración
  • -output: el archivo de salida
  • -wait: el intervalo de tiempo, en segundos, de espera entre cada uno de generación de imágenes (120 segundos o 2 minutos a la tierra, para poder observar el sol durante todo el día 600 segundos o 10 minutos son. suficiente para la luna, cuya fase varía muy lentamente).
  • -cuerpo: nombre del cuerpo celeste para ver, establecido en el archivo de configuración
  • -geometry: tamaño en píxeles, de la imagen generada
  • -latitud y -Longitude: fija el punto central de la imagen de la tierra. Al elegir la latitud y longitud 40 10, la imagen será más o menos centrado en Italia. No vemos ninguna afinidad particular con este país, es simplemente un ángulo que revela Francia y en Europa, el conjunto de África, gran parte de Rusia, las Américas y el polo norte es bastante! También puede elegir la vista del sol, por ejemplo, para ver siempre el lado soleado de la tierra, que recorrerá un poco y no siempre ver la misma parte del globo 

Entonces sólo tiene que colocar la secuencia de comandos en el directorio /etc/init.d y ejecutar el siguiente comando a ejecutar en cada inicio del sistema:

  update-rc.d xplanet.sh defaults

Hemos hecho la mitad del trabajo  Cada 2 minutos, se genera a partir de la tierra con un mapa nubes actualizados cada 4 horas una nueva imagen (500 x 500 píxeles). Cada 10 minutos, la imagen de la fase de la luna (250 x 250 píxeles) se actualiza.

index.php

En la página de índice, se añaden dos etiquetas <div>, cada uno con una etiqueta <img>, uno para la tierra y otro para la luna.

  <Div id = "tierra"> <img id = "img_earth" src = "PICT / blank.png"> </ div>
 <Div id = "luna"> <img id = "img_moon" src = "PICT / blank.png"> </ div>

Para evitar mostrar un error al cargar la página se debe inicializar las fuentes de <img> etiquetas con un blank.png imagen en blanco.

style.css

La hoja de estilo para este módulo es muy simple, ya que sólo tiene que definir la posición y el tamaño de la div que contiene las imágenes que se muestran.

  / * Tierra * /

 div # Tierra
 {
 anchura: 500px;
 altura: 500px;
 left: 0px;
 top: 0px;
 position: absolute;
 overflow: hidden;
 background-color: RGBA (0, 0, 0, 1);
 }

 / * * Luna /

 div # luna
 {
 anchura: 250 píxeles;
 altura: 250 píxeles;
 izquierda: 500px;
 top: 0px;
 position: absolute;
 overflow: hidden;
 background-color: RGBA (0, 0, 0, 1);
 }

javascript.js

Es simplemente para reemplazar la imagen mostrada por la nueva imagen generada. El problema es que el nombre del archivo no cambia, el navegador tenderá a mostrar la imagen que ya está almacenada en su caché. Para superar este problema vamos a añadir una marca de tiempo (fecha y hora expresada en número de segundos transcurridos desde el primer Janver 1970) en la ruta de la imagen. De esta manera, el navegador va a pensar que se trata de una nueva imagen cada vez.

En aras de la fluidez, también es necesario para precargar las imágenes antes de sustituto en la pantalla. y la imagen se evita cargar cuanto a su pantalla.

  / * * Xplanet /

 xplanet_timeout var;

 función xplanet () {

 var ahora = new Date () getTime ().

   / * * Carga previa de imágenes /
 img_earth var = $ ( "<img />").attr("src", "xplanet / img / xplanet_earth.png?" + ahora);
 img_moon var = $ ( "<img />").attr("src", "xplanet / img / xplanet_moon.png?" + ahora);

   / * Mostrar nuevas imágenes a la pantalla * /
 . $ ( "# Img_earth") attr ( "src", "xplanet / img / xplanet_earth.png?" Ahora +);
 $ ( "# Img_moon") attr ( "src", "xplanet / img / xplanet_moon.png?" Ahora +).

 xplanet_timeout = setTimeout ( "xplanet ()", 120000);
 }

La función se ejecuta cada 120000ms (es decir, cada 2 minutos) que en última instancia se desplaza sol de la tierra y de la luna durante todo el día 🙂

 

6 – Módulo 3 – El Tiempo

Ahora veremos  el módulo de tiempo que muestra el tiempo actual y la previsión de 3 a 5 días.

jarvis_screenshot_meteoEste módulo es particularmente difícil porque es muy difícil de personalizar. De hecho, es el uso de “widgets” puestos a disposición por los sitios especializados que ofrecen opciones de configuración limitadas.

 

Reproductores

Al menos  tres sitios que ofrecen widgets de tiempo más o menos completa y más o menos bonita: my-meteo.fr , tameteo.com y meteocity.com

Todas las ofertas para personalizar la información que se muestra, el número de días pronosticar, colores de los elementos y estilos de iconos Una vez que las opciones seleccionadas, el sitio genera el código HTML para copiar / pegar en su página.

Aquí se  muestran algunos sites que ofrecen este tipo de servicios:

  • my-meteo.fr
  • tameteo.com
  • meteocity.com

Las opciones propuestas por el widget de meteocity son un poco más amigables  . Aparte de la información sobre la humedad y el viento, el resto  de información es fácil de leer a distancia,pero vamos a tener que utilizar trucos para ocultar la información innecesaria 

index.php

Añadimos a nuestro archivo index.php una simple etiqueta <div> se deja vacío por ahora.

 <Div id = "Tiempo"> </ div>

Como todos los módulos de este dashscreen es una función de JavaScript que cargará insertar el contenido que se mostrará en el div del módulo.

style.css

Caso particular de este módulo,  no tiene la posibilidad de actuar directamente sobre el código CSS proporcionada por el sitio de tiempo. Así que sólo tenemos que colocar el div que contendrá información sobre el clima.

 / * El tiempo * /

 div # meteo
 {
   derecha: 0px;
   top: 300px;
   position: absolute;
   overflow: hidden;
   background-color: RGBA (0, 0, 0, 1);
   Color: #FFF;
   font-weight: bold;
   text-align: center;
 }

javascript.js

La función JavaScript de este módulo es feliz de enviar una petición AJAX e introduzca el resultado de la consulta en el div adecuado.

 / * El tiempo * /

 meteo_timeout var;

 función meteo ()
 {
   $ .ajax ({
     asíncrono: falso,
     del tipo: "GET"
     url: "./ajax.php"
     datos "bloque = meteo"
     el éxito: function (html) {
       $ ( "# Tiempo") HTML (HTML).
     }
   });

   meteo_timeout = setTimeout ( "Tiempo ()", 3.600.000);
 }

la información del tiempo cada hora (cada ms 3600000) es más que suficiente.

inc.php

En este módulo necesitamos una función PHP que devuelve el código generado por el widget. Esto nos da una función muy sencilla en la que simplemente copiar / pegar el código HTML que ha generado el sitio Tiempo

 /////////////////////////////////////////////////
 // tiempo
 /////////////////////////////////////////////////

 función meteo () {
   $ Tiempo = 'pegar aquí el código HTML generado por el sitio de tiempo';
   devolver $ meteo;
 }

Ocultar información innecesaria

Si desea ocultar cierta información proporcionada por el widget, simplemente añadir un <div> en negro por encima de los elementos que desea ver desaparecer.

Añadir un <div> en el archivo index.php justo por debajo del tiempo div:

 <Div id = "Tiempo"> </ div>
 <Div id = "meteo_black"> </ div>

A continuación, edite el archivo style.css añadiendo el siguiente código en la sección del tiempo:

 div # meteo_black
 {
   derecha: 0px;
   top: 420px;
   anchura: 600px;
   altura: 100px;
   position: absolute;
   z-index: 9999;
   background-color: RGBA (0, 0, 0, 1);
 }

Por supuesto, tendrá que ajustar la posición y el tamaño del div para satisfacer sus necesidades pero el resultado, es muy fácil de leer y  el diseño es muy elegante 

Con estos primeros tres módulos de reloj , xplanet y el tiempo, ya es posible hacer una hermosa pantalla  con todos estos elementos. Esta información puede ser valiosa y útil para todo el mundo todos los días 

Como extra aparte de todos los módulos de hora ,el tiempo y las fases lunares  el diseñador decidió añadir algunas funciones  de “monitoreo”, cuya función es supervisar los servidores y redes..

 

 

 

8 – Módulo 5 – TeamSpeak

Si usted no sabe TeamSpeak , se trata de un software de conferencia de audio que permite a varias personas chatear a través de Internet (para más información http://fr.wikipedia.org/wiki/TeamSpeak ). Este módulo se utiliza para mostrar el estado del servidor de TeamSpeak (on / off) y la lista de las personas que están conectados a él.


Para obtener esta información se utiliza TeamSpeak 3 framework PHP que es una descarga gratuita. Esta gran  libreria PHP  proporciona acceso a todas las funciones del servidor de TeamSpeak3.

Sólo tiene que descargar y descomprimir TeamSpeak 3 framework PHP a su directorio web raíz.

index.php

Al igual que con otros módulos, sólo un <div> suficientes. Se empieza a acostumbrarse 

 <Div id = "TS3"> </ div>

La etiqueta se queda vacía, y se “llena” de la función de JavaScript …

style.css

Es la hoja de estilo minimalista para este módulo:

 / * * Ts3 /

 div # TS3
 {
 izquierda: 340px;
 parte inferior: 10px;
 position: absolute;
 overflow: hidden;
 background-color: RGBA (0, 0, 0, 1);
 Color: #FFF;
 font-weight: bold;
 text-align: center;
 }

 td.ts3_user
 {
 text-align: left;
 font-size: 30px;
 padding-left: 10px;
 }

javascript.js

Una vez más, una aplicación AJAX fácil de recuperar información a mostrar.

 / * * TS3 /

 ts3_timeout var;

 función TS3 ()
 {
 $ .ajax ({
 asíncrono: falso,
 del tipo: "GET"
 url: "./ajax.php"
 de datos "de bloque = TS3"
 el éxito: function (html) {
 $ ( "# Ts3") HTML (HTML).
 }
 });

 ts3_timeout = setTimeout ( "TS3 ()", 10000);
 }

El período de actualización se establece en 10 segundos para ver rápidamente los cuales conecta / desconecta el servidor.

ajax.php

Eso habla por sí mismo …

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

 if ($ == bloque 'TS3') {
 eco TS3 ();
 }

.inc.php

Aquí se utiliza TeamSpeak 3 framework PHP .

Primero se abre un socket en el puerto 30033 (como para el módulo 4 – Servidor de ping ) para verificar que el servidor de TeamSpeak esta funcionando bien. Si es así, entonces se puede mostrar la bandera del servidor (la imagen triton_ts3.png), entonces se usa TeamSpeak 3 Marco de PHP para recuperar la lista y el estado de los usuarios conectados .

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

 función TS3 () {

 $ Host_ip = '10 .0.0.1 ';
 $ Host_port = '30033';
 $ Zócalo = 0;
 $ Socket = @fsockopen ($ host_ip, $ host_port, $ errno, $ errstr, 3);
 $ Html = '';

 if ($ socket &&! $ errno) {
 require_once ( "./ TS3_PHP_Framework-1.1.12 / bibliotecas / TeamSpeak3 / TeamSpeak3.php");
 $ Ts3_ServerInstance = TeamSpeak3 :: factory ( "ServerQuery: // nombre de usuario: [email protected]: 10011 /");
 $ = $ Ts3_VirtualServer ts3_ServerInstance-> serverGetById (1);

 $ Html = '<img width = "200 px" src = "/ triton_ts3.png PICT" estilo = "margin-bottom: 10px;">' ;.
 . $ Html = '<table cellspacing = "0px" cellpadding = "0px">';
 foreach ($ ts3_VirtualServer-> clientList () como cliente $) {
 if ($ cliente [ "client_unique_identifier"] == 'serveradmin') {continúe;}
 $ Html = '<tr>'.
 $ Html = '<td valign = "middle">'.
 $ Html = '<estilo img =. "Width: 20px;"  src = "./ TS3_PHP_Framework-1.1.12 / images / espectador /'.$ cliente-> getIcon () 'png" alt = "">';
 $ Html = '</ td>.';
 $ Html = '<td valign = "middle">'.
 $ Html = '' .htmlspecialchars ($ cliente).
 $ Html = '</ td>.';
 $ Html = '</ tr>'.
 }
 $ Html = '</ table>'.
 }

 devolver $ html;
 }

Este módulo es muy fácil de conseguir con la lib TeamSpeak 3 framework PHP 

 

 

7 – Módulo 4 – servidor Ping

Si tiene servidores, NAS, o cualquier otro tipo de máquina que desee conocer el estado (encendido / apagado, o disponible / no disponible), este tipo de módulo, de nuevo es muy simple pero de gran uso 


La idea es mostrar los servidores verdes que responden correctamente al módulo solicitaciones, y en rojo los que no responden. Para enfatizar la naturaleza alarmante de una máquina que no responde, vamos a añadir una animación para resaltar este resultado:

de ping

index.php

Al igual que con otros módulos, sólo un <div> suficientes.

  <Div id = "ping"> </ div>

La etiqueta se queda vacía, y se “llena” de la función de JavaScript.

style.css

Para este módulo, la hoja de estilo es un poco más larga:

  / * * Ping /

 div # ping
 {
 left: 0px;
 parte inferior: 0px;
 position: absolute;
 overflow: hidden;
 background-color: RGBA (0, 0, 0, 1);
 }

 td.ping
 {
 font-size: 30px;
 text-align: left;
 border-radius: 10px;
 padding: 5px 10px;
 font-weight: bold;
 }

 td.ping_up
 {
 color: # 00DD00;
 }

 td.ping_down
 {
 Imagen de fondo: url ( 'PICT / warning.gif');
 color: # DD0000 ;;
 }

Los nombres de la máquina se muestran en una tabla <table> que cada célula <td> puede o bien utilizar el estilo “ping_up” si la máquina cumple o “ping_down” si la máquina no responde. En este último caso, vamos a utilizar una imagen de un gif animado, a modo de  “flash” en un cuadro rojo con el mes,para dar un mayor resalte

javascript.js

Javascript función de este módulo hace sólo una petición AJAX, y muestra el resultado en el index.php div:

  / * * PING /

 var PING_TIMEOUT;

 función ping ()
 {
 $ .ajax ({
 asíncrono: falso,
 del tipo: "GET"
 url: "./ajax.php"
 datos "bloque = ping"
 el éxito: function (html) {
 $ ( "# Tabla") HTML (HTML).
 }
 });

 PING_TIMEOUT = setTimeout ( "ping ()", 30000);
 }

Es importante tener una visión en tiempo real del estado de las máquinas, por lo que estamos estableciendo el tiempo de refresco a 30 segundos. Se puede reducir este tiempo para que se adapte a sus necesidades, pero asegúrese de que sigue siendo mayor que el tiempo que tarda la función de PHP para poner a prueba todas sus máquinas. En promedio, se puede tardar de 4 a 5 segundos para poner a prueba todas las máquinas. Sin embargo, no es raro que se tarde  hasta 20 segundos! Así que si se ajusta a 30 segundos ,esta puede ser una buena opción para el tiempo de espera entre cada actualización del módulo.

ajax.php

Sólo tiene que añadir unas pocas líneas a ajax.php archivo para la función correcta se llama:

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

   if ($ == bloque de 'ping') {
     eco ping ();
   }

inc.php

En este archivo vamos a declarar la función de ping () que es responsable del lanzamiento de las aplicaciones en diferentes servidores, y luego construir la tabla HTML que se mostrará.

En general, para supervisar el estado de un servidor, se utiliza el comando ping que simplemente indica si la máquina objetivo satisface las peticiones ICMP. Esto plantea varios problemas. De hecho, es probable que el tráfico ICMP está bloqueado por un servidor cortafuegos por  arriba que distorsione el resultado. Además, si desea supervisar un servidor web, por ejemplo, es muy posible que la máquina responda bien a los pings, pero que el servicio web no está disponible. Haciendo ping por lo tanto tienen poco interés …

La idea es bastante sencilla si los servicios que se ejecutan en nuestras máquinas están disponibles. Para ello, sólo tendremos que abrir un socket con la función de PHP fsockopen () . Si la abertura del pipe no  es posible  eso significara  que el servicio no está disponible 

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

   función ping () {
     $ Hosts = array ();
     // Definición de máquinas de prueba
     $ Hosts_ip = array (
                     Oberon => array ('10 .0.0.1 '' 22 '), // SSH
                     'Triton' => array ('10 .0.0.2 '' 15915 '), // TeamSpeak
                     'Ananke' => array ('10 .0.0.3 '' 2049 '), // NFS
                     'DS110j' => array ('10 .0.0.4 '' 2049 '), // NFS
                     'DS210j' => array ('10 .0.0.5 '' 2049 '), // NFS
                     'DS212j' => array ('10 .0.0.6 '' 2048 ') // NFS
                 );

     // para cada máquina de abrir un socket se prueba en el puerto especificado
     // almacenamos el resultado 'arriba' o 'abajo' en las variables $ anfitriones
     foreach ($ hosts_ip como $ host => $ host_data) {
       $ = $ Host_ip host_data [0];
       $ = $ Host_port host_data [1];
       $ Zócalo = 0;
       $ Socket = @fsockopen ($ host_ip, $ host_port, $ errno, $ errstr, 3);
       if ($ && $ errno toma!) {$ anfitriones [$ nombre de host] = 'arriba';}
       else {$ anfitriones [$ nombre de host] = 'abajo';}
     }

     // Construir la tabla HTML
     // para cada máquina probado, que muestra su nombre y el estilo se fija 'ping_up' o 'ping_down' la etiqueta td
     $ Html = '';
     . $ Html = '<table cellspacing = "10px">';
     $ C = 0;
     foreach ($ anfitriones como $ host => $ host_status) {
       if ($ c == 0) {$ html = '<tr>'} ;.
       $ Html = '<td class = "ping ping _' $ host_status .. '">' $ nombre de host </ td> '...;
       $ C ++;
       if ($ c == 2) {$ c = 0;  $ Html = '</ tr>'} ;.
     }
     if ($ c! = 0) {$ html = '</ tr>'} ;.
     $ Html = '</ table>'.

     devolver $ html;
   }

El $ hosts_ip variable contiene la lista de equipos para poner a prueba y la pantalla. El nombre que se muestra, la dirección IP y el puerto TCP servicio a ensayar se almacena allí. Debe adaptar los nombres, direcciones IP y número de puerto para sus necesidades.

Como se puede ver en los comentarios de código, dependiendo de la máquina de prueba, abro un zócalo en servicios tales como SSH, NFS y TeamSpeak. Esto también funciona muy bien en FTP, HTTP, POP3, etc … hasta que el servicio a prueba de escucha en un puerto TCP, que funcionará 

Nota: Es posible optimizar esta función PHP paralelización de sockets abiertos en cada máquina. De hecho, esta función prueba las máquinas de uno en uno, que puede ser largo … En “bifurcan” la tarea con la función pcntl_fork PHP (), es posible ejecutar todas las peticiones a la vez, reduciendo así el tiempo total que se pone la función para devolver la tabla HTML que se vea. Siéntase libre de dejar un comentario si quieres más detalles sobre este procedimiento 

Optimización mediante el fork

El principio es simple: Para cada máquina a ensayar, vamos a crear un proceso a través del hijo función de PHP fork_pcntl () que pondrá en marcha fsockopen (). A medida que el proceso hijo y el proceso padre no puede compartir las variables (por lo menos el uso de técnicas de memoria compartida …), debe almacenar los resultados en una pequeña base de datos SQLite  El proceso padre espera a todos proceso hijo se completa ir a leer el contenido de la base de datos SQLite (que contiene el estado de cada máquina). El resto permanece sin cambios, construimos la tabla HTML para mostrar como en la función inicial de ping () A saber, el fork sólo es posible desde la línea de comandos, será necesario adaptar el archivo ajax.php de esta manera:

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

   if ($ == bloque de 'ping') {
     eco shell_exec ( 'php5 fork.php');  // fork.php es el archivo en el que se encuentra la función ping_fork ();
   }

Aquí la versión “fork” de la función de ping (), se puede utilizar directamente copiando un archivo fork.php:

  función ping_fork () {

   $ Hosts_ip = array (
                     Oberon => array ('10 .0.0.1 '' 22 '), // SSH
                     'Triton' => array ('10 .0.0.2 '' 15915 '), // TeamSpeak
                     'Ananke' => array ('10 .0.0.3 '' 2049 '), // NFS
                     'DS110j' => array ('10 .0.0.4 '' 2049 '), // NFS
                     'DS210j' => array ('10 .0.0.5 '' 2049 '), // NFS
                     'DS212j' => array ('10 .0.0.6 '' 2048 ') // NFS
                 );

   $ PIDS = array ();

   // Conectar con el SQLite base de datos y la creación de la tabla hosts_status si no existe todavía
   $ Db = new SQLite3 ( 'ifstat / hosts.sqlite');
   $ Db-> exec (CREATE TABLE SI NO EXISTE hosts_status (nomb_sist_pral VARCHAR (10), host_status VARCHAR (5)); ');

   // Para cada máquina, hemos creado un proceso hijo
   foreach ($ hosts_ip como $ nomb_sist_pral => $ host) {
     $ PIDS [$ nombre_host] = pcntl_fork ();
     if (! $ PID [$ nomb_sist_pral]) {
       $ Socket = @fsockopen ($ host [0], $ host [1] $ errno, $ errstr, 3);
       if ($ && $ errno toma!) {$ status = 'arriba';} else {$ status = 'abajo';}
       // esperamos hosts_status la tabla ya no está bloqueado por un acceso potencial competidor
       if ($ db-> busyTimeout (5000)) {
         $ Db-> exec ( "INSERT INTO VALORES hosts_status ( '$ nomb_sist_pral' '$ status');");
       }
       exit ();
     }
   }

   // el proceso padre debe esperar hasta que todos los procesos se han completado hijo
   foreach ($ PID como $ nomb_sist_pral => $ pid) {
     pcntl_waitpid ($ pid, estado $, WUNTRACED);
   }

   Resultados $ = $ db-> query ( 'select * from hosts_status;');

   $ Html = '';
   . $ Html = '<table cellspacing = "10px">';
   $ C = 0;
   while ($ host = $ Resultados> fetchArray (SQLITE3_ASSOC)) {
     if ($ c == 0) {$ html = '<tr>'} ;.
     . $ Html = '<td class = "ping ping _' $ Anfitrión [ 'host_status']. '">' $ Anfitrión [ 'nomb_sist_pral'] '</ td>' ..;
     $ C ++;
     if ($ c == 2) {$ c = 0;  $ Html = '</ tr>'} ;.
   }
   if ($ c! = 0) {$ html = '</ tr>'} ;.
   $ Html = '</ table>'.

   $ Db-> exec ( "BORRADO DE hosts_status;");

   devolver $ html;
 }

 eco ping_fork ();

El tiempo de espera fsockopen () aquí se establece en 3 segundos, lo que significa que uno debe esperar por lo menos tres segundos antes de declarar el equipo de destino como “abajo” (no disponible). En la versión no fork del ping () si un equipo no contesta, tuvo que esperar 3 segundos antes de probar la máquina siguiente, y así sucesivamente. Con mis 6 máquinas, si nadie contesta, él tendría que esperar 6 x 3 = 18 segundos antes de que el resultado final. Con la versión 6 fork solicitudes se envían simultáneamente. Cualquiera que sea el número de máquinas a ensayar, vamos a tener una respuesta dentro de 3 segundos como máximo

 

 

 

9 – Módulo 6 – Gráfico de ancho de banda

Por diversas razones, puede ser interesante tener si nuestro ancho de banda de Internet está saturado o no. Este módulo muestra una historia de unos 5 minutos utilizando el ancho de banda aguas abajo (descarga) y aguas arriba (carga). De esta manera, se puede ver de un vistazo si algo anormal está sucediendo en su red.

 

introducción

Este módulo es el más complicado de todo por la borda. Por un lado, tenemos que recuperar el caudal instantáneo utilizado por la interfaz de red de la pasarela que está conectado al router. A continuación, tendrá que pasar estos datos en Pi para ejecutarlos en  el dashscreen. Por último, se creará un gráfico para representar esta información …

De hecho,se   ha optado por no utilizar suave tipo mrtg que se especializan en este tipo de cosas instalando el software mínimo y utilizando algunos comandos básicos. Para hacer algo simple (como el ancho de banda de visualización en el gráfico), sin necesidad de sacar la gran artillería  Y entonces … si no nos complicamos la vida, que sería mucho menos divertido, ¿verdad? 

Ancho de Banda

ifstat es una pequeña herramienta desde la línea de comandos que muestra las estadísticas de uso de una interfaz de red. En un terminal, escriba el siguiente comando:

  ifstat -n -i eth0

Y se obtiene continua, algo en el género:

  eth0       
  KB / s en KB / s hacia fuera
     0,45 0,06
     0,71 0,39
     2,85 0,76
     0,57 0,06
     1,86 0,19
     0,45 0,06
     0,45 0,06
     0,45 0,06
     0,57 0,06
     0,59 0,13
     0,45 0,06
     0,45 0,06
     0,59 0,26
     0,57 0,06
     1,74 0,13
     ...

Como vemos se obtiene cada segundo el flujo instantáneo (casi) en Kbytes / s, es decir, en KB / s Esto es exactamente lo que necesitamos ahora  debe enviar esta información continuamente a nuestra pantalla.

Transmitir los datos a través de la red Pi

La forma más fácil de transmitir información desde un ordenador a otro es enviarlos en paquetes UDP … El comando netcat es totalmente apropiado para este tipo de operación. En una máquina que hace el papel de servidor de hecho:

  nc -u -l 12345
  • -u: Para utilizar UDP
  • -l: para cambiar al modo de escucha (servidor)
  • 12345: un número de puerto découte

A continuación, en una máquina B que actúa como un cliente, hacer:

  n -p 8888 -u 10.0.0.1 12345
  • -p 8888: un puerto de origen
  • -u: Para utilizar UDP
  • 10.0.0.1 dirección IP de la máquina A (servidor)
  • 12345: Oyente Una máquina (servidor)

 

Para transmitir los datos devueltos por el comando ifstat través netcat, vamos a utilizar una tubería . Aquí hay dos scripts completos (cliente / servidor) para realizar esta operación:

  • servidor de secuencia de comandos para ejecutar en el nc_ifstat_srv.sh Pi:
  ### COMENZAR INIT INFO 
 # Proporciona: nc_ifstat_srv 
 # Required-Start: 
 # Requerido-Stop: 
 # Default-Start: 2 3 4 5 
 # Default-Stop: 0 1 6 
 # Corto Descripción: ifstat para Jarvis 
 # Descripción: Habilitar el servicio proporcionado por el demonio. 
 ### END INIT INFO

 dst_port = 12,345
 dst_dir = / home / Jarvis / ifstat
 dst_file = eth0.log

 nc -l -u $ dst_port >> dst_dir $ / $ & dst_file
  • script de cliente para funcionar en su nc_ifstat_clt.sh gateway / router de:
  ### COMENZAR INIT INFO
 # Proporciona: nc_ifstat_clt
 # Required-Start:
 # Requerido-Stop:
 # Default-Start: 2 3 4 5
 # Default-Stop: 0 1 6
 # Corto Descripción: ifstat para Jarvis
 # Descripción: Habilitar el servicio proporcionado por el demonio.
 ### END INIT INFO

 src_port = 8888
 dst_port = 12,345
 dst_host = 10.0.0.2
 eth = eth0

 nc_ifstat ()
 {
     mientras [ "true"]
     hacer
         -i -n ifstat $ eth |  n -p -u src_port $ $ $ dst_host dst_port
         sueño 5
     por lo tanto
 }

 case "$ 1" en
         parada)
         echo "parando ifstat para Jarvis ..."
                 killall ifstat
         killall nc
         ;;
         empezar)
         echo "A partir de ifstat Jarvis ..."
         nc_ifstat y
         exit 0    
                 ;;
         *)
                 la salida 1
                 ;;
 esac

 exit 0

Para ejecutar el script en el arranque de la máquina, colocarlo en /etc/init.d continuación, ejecute el comando:

  incumplimientos update-rc.d nom_du_script.sh

En este punto, usted debe tener un archivo en el Pi en la que, cada segundo, el ancho de banda instantáneo se anexa al archivo  Sigue siendo para nosotros leer este archivo con un script PHP, y dibujar el gráfico para representar los datos que contiene 

creación gráfico con PHP

Una vez más, se podría haber utilizado una librería gráfica en PHP, JavaScript o cualquier otra cosa. Pero en lugar de  operar asi el autor decidio crear su propia función de gráficos en PHP. Verá que es mucho más simple que se puede imaginar 

Aquí está mi función imagickHisto ():

  imagickHisto función (máx $ $ ETH = '', $ UP_DOWN = 'abajo') {

   Datas $ = parseData ( "eth0.log" $ UP_DOWN);

   $ Width = 304;  // anchura de la gráfica
   $ Altura = 100;  // altura del gráfico
   Relleno $ = 1;
   Las garrapatas $ = 5;
   $ Background_color = '# 000';  // color de fondo
   $ Axes_color = '# 555';  // ejes de color

   si ( 'abajo' $ UP_DOWN ==) {
     $ Data_color = '# 1D1';  // carta de colores para descargar
   }
   else {
     $ Data_color = '# D11';  // gráficos en color para la carga
   }

   $ = $ Nb_values ancho - 2 * $ acolchado - 2;
   $ MAX_VALUE $ height = - 2 * $ acolchado - 4;

   $ Nb_datas = sizeof ($ datas más);
   $ = Trim $ nb_values - $ nb_datas;

   if ($ recortar <0) {$ recortar = 0;}

   $ Imagen = nueva Imagick ();
   $ Imagen -> newImage (ancho $, $ altura, nuevo ImagickPixel ($ background_color));
   Dibuje $ = new ImagickDraw ();
   N ° de dibujo $> setStrokeColor (nueva ImagickPixel ($ axes_color));

   $ = $ Xx1 de relleno;
   $ Xy1 $ height = - $ acolchado - 1;
   $ XX2 width = $ - $ acolchado - 1;
   $ = $ Xy2 xy1;
   $ = $ Yx1 XX1;
   $ = $ Xy1 YY1;
   $ = $ Yx2 yx1;
   $ = $ Acolchado YY2;
   $ Half_y = $ altura / 2;
   $ Half_x = $ ancho / 2;

   N ° de dibujo $> línea ($ XX1, xy1 $, $ xx2, $ xy2);
   N ° de dibujo $> línea ($ yx1, yy1 $, $ yx2, $ YY2);

   N ° de dibujo $> línea ($ yx1, YY2 $, $ + $ yx1 garrapatas, $ YY2);
   N ° de dibujo $> línea ($ yx1, half_y $, $ + $ yx1 garrapatas, $ half_y);

   N ° de dibujo $> setStrokeColor (nueva ImagickPixel ($ data_color));

   $ First_x XX1 = $ 1 + $ + asiento;
   $ = $ Last_x xx2 - 1;
   $ = $ First_y xy1 - 1;
   $ = $ Last_y YY2 + 1;

   for ($ i = 0; i $ <$ nb_values; $ i ++) {
     if (isset ($ datas más [$ i])) {
       $ Valor = $ $ datas más [i] * $ MAX_VALUE / $ max;
       $ Value_y first_y = $ - $ valor;
       $ = $ $ Value_x first_x + i;
       N ° de dibujo $> línea ($ value_x, first_y $, $ value_x, $ value_y);
     }
   }

   $ Imagen-> drawImage ($ dibujar);

   $ Text_draw ImagickDraw = new ();
   $ Text_draw-> setFillColor ($ axes_color);
   $ Text_draw-> setFontSize (12);
   $ Imagen-> annotateImage (, $ half_x-20, $ $ acolchado text_draw + 10, 0, "eth $ - $ UP_DOWN");

   $ Imagen-> setImageFormat ( "PNG");
   header ( 'Content-Type: image / png ");
   echo $ imagen;
   salida;
 }

En resumen, la función toma tres parámetros:

  • $ Max: máximo (en KB) para limitar el gráfico. Por ejemplo, un rendimiento máximo real alcanza 1.800 KB / s. Así que se ha seleccionado max = $ de 2000.
  • $ ETH: Nombre de la interfaz (por ejemplo, eth0)
  • $ UP_DOWN “arriba” o “abajo” para especificar el color del gráfico y los datos que se mostrará después de ifstat

La función lee una matriz de datos devuelto por la función parseData (), a continuación, se representa el gráfico una barra ancha de 1 píxel por datos. Con un ancho de 300 px, para que puedas ver 5 minutos de datos históricos 

Aquí parseData (), cuya función es la función para leer el archivo que contiene los datos de la orden ifstat:

  parseData función ($ stat_file, $ UP_DOWN) {
     $ Datas = array ();
     si (filemtime ($ stat_file) <time () - 10) {return $ datas más;}
     Estadísticas = $ fopen ($ stat_file, 'r');
     while ((línea $ = fgets ($ estadísticas))! == false) {
       $ Explode_line = str_word_count (línea $, 1, "0123456789.");
       si ( 'abajo' $ UP_DOWN ==) {
         $ Datas [] = $ explode_line [0];
       }
       else {
         $ Datas [] = $ explode_line [1];
       }
     }
     fclose ($ estadísticas);
     Datas $ = $ array_slice (datas más, -300);
     devolver $ datas más;
   }

Esta función tiene dos parámetros:

  • $ Stat_file: analizador de archivos
  • $ UP_DOWN “arriba” o “abajo” para distinguir la carga de datos y descarga,

En lo que sigue, reprensenta el mismo enfoque que para los otros módulos 

index.php

Se necesita un div por gráfico; Así que agregamos dos para el archivo index.php, uno para subir y otro para su descarga.

  <Div id = "ifstat_eth0_up"> <img id = "img_eth0_up" src = "PICT / blank.png"> </ div>
 <Div id = "ifstat_eth0_down"> <img id = "img_eth0_down" src = "PICT / blank.png"> </ div>

En cuanto al módulo de Xplanet , es conveniente iniciar la fuente de las etiquetas de imagen <img> con un blank.png imagen en blanco.

style.css

Basta con colocar nuestros dos <div>:

  / * * Ifstat /

 div # ifstat_oberon_up
 {
 derecha: 20px;
 parte inferior: 20 píxeles;
 position: absolute;
 overflow: hidden;
 background-color: RGBA (0, 0, 0, 1);
 }

 div # ifstat_oberon_down
 {
 derecha: 340px;
 parte inferior: 20 píxeles;
 position: absolute;
 overflow: hidden;
 background-color: RGBA (0, 0, 0, 1);
 }

javascript.js

Una simple petición AJAX para recuperar la pantalla gráfica.

  / * * Ifstat /

 ifstat_timeout var;

 ifstat function () {

 var ahora = new Date () getTime ().

 url_down var = "bloque = ajax.php ifstat y eth = & UP_DOWN wan = down & max = 2.000 y hora =" + ahora;
 img_eth0_down var = $ (url_eth0_down "<img />").attr("src");
 $ ( "# Img_eth0_down") attr ( "src", url_eth0_down).

   url_up var = "bloque = ajax.php ifstat y eth = & UP_DOWN wan = up & max = 150 y hora =" + ahora;
 img_eth0_up var = $ (url_eth0_up "<img />").attr("src");
 . $ ( "# Img_eth0_up") attr ( "src", url_eth0_up);

 ifstat_timeout = setTimeout ( "ifstat ()", 5000);
 }

Igual que para el módulo Xplanet , debe pre-cargar las imágenes y las muestra.En este caso el tiempo de actualización es de 5 segundos, lo cual es suficiente.

ajax.php

El código para agregar este archivo permanece tan elemental para los otros módulos. Sin embargo, no se olvide de tener en cuenta los parámetros de la imagickHisto () Función:

  /////////////////////////////////////////////////
 // ifstat
 /////////////////////////////////////////////////

 if ($ == bloque 'ifstat') {
 imagickHisto ($ _REQUEST [ 'max'], $ _REQUEST [ 'eth'], $ _REQUEST [ 'UP_DOWN']);
 }


inc.php

En este archivo, simplemente copia y pega el imagickHisto () y parseData () que se describieron anteriormente 

Esta es la representación final de primer plano, cuando el ancho de banda es de alta demanda

10 – Módulo 7 – VPN

Si  usa un pequeño servidor VPN PPTP para sus  amigos para poder   intercambiar fácilmente archivos o jugar juegos en red , es muy fácil de configurar tanto en el lado del servidor mediante la instalación del paquete de pptpd que el lado del cliente, ya que ‘ se forma nativa compatible con Windows.

Este módulo permite mostrar una lista de personas que están conectadas con el servidor PPTP VPN.


No se detalla en este artículo cómo instalar y configurar PGWP. Aquí hay un tutorial para ayudarle a implementar este tipo de VPN https://help.ubuntu.com/community/PPTPServer

El servidor pptpd está instalado en el router , proceda de la misma manera que el módulo de ancho de banda de gráficos para transferir datos utilizando netcat Pi. Lo único nuevo aquí es el comando last  permitiendo recuperar información de conexión de cliente VPN.

Transferir los datos a la Pi

lado Pi (servidor netcat):

 #! / Bin / bash

 ### COMENZAR INIT INFO
 # Proporciona: nc_vpn_srv
 # Required-Start:
 # Requerido-Stop:
 # Default-Start: 2 3 4 5
 # Default-Stop: 0 1 6
 # Corto Descripción: VPN para Jarvis
 # Descripción: Habilitar el servicio proporcionado por el demonio.
 ### END INIT INFO

 dst_port = 12,346
 dst_dir = / home / Jarvis / VPN
 dst_file = vpn_oberon.log

 nc_vpn ()
 {
   mientras [ "true"]
   hacer
     n q 1 -u -l 12346> $ dst_dir / $ dst_file </ dev / null
     sueño 5
   por lo tanto
 }

 case "$ 1" en
         parada)
                 echo "vpn parando para Jarvis ..."
                 killall VPN
                 killall nc
                 ;;
         empezar)
                 echo "A partir de VPN para Jarvis ..."
                 nc_vpn y
                 exit 0
                 ;;
         *)
                 la salida 1
                 ;;
 esac

 exit 0

lado de puerta de enlace (cliente netcat):

 #!  / Bin / bash

 ### COMENZAR INIT INFO
 # Proporciona: nc_vpn_clt
 # Required-Start:
 # Requerido-Stop:
 # Default-Start: 2 3 4 5
 # Default-Stop: 0 1 6
 # Corto Descripción: VPN para Jarvis
 # Descripción: Habilitar el servicio proporcionado por el demonio.
 ### END INIT INFO

 src_port = 8889
 dst_port = 12,346
 dst_host = 10.0.0.1

 nc_vpn ()
 {
         mientras [ "true"]
         hacer
                 última |  ppp grep |  grep "conectado" |  n q 1 -p -u src_port $ $ $ dst_host dst_port
                 sueño 5
         por lo tanto
 }

 case "$ 1" en
         parada)
                 echo "vpn parando para Jarvis ..."
                 killall VPN
                 killall nc
                 ;;
         empezar)
                 echo "A partir de VPN para Jarvis ..."
                 nc_vpn y
                 exit 0
                 ;;
         *)
                 la salida 1
                 ;;
 esac

 exit 0

Ejecute  estas secuencias de comandos en el inicio del sistema en la compactación en el directorio /etc/init.d a continuación, ejecutar el siguiente comando:

  update-rc.d nom_du_script.sh defaults

index.php

Un simple <div> Simplemente porque sólo queremos mostrar una lista de usuarios:

 <Div id = "VPN"> </ div>

style.css

Un poco de formato de mirar bastante 

 / * * VPN /

 div # VPN
 {
   izquierda: 550px;
   parte inferior: 10px;
   position: absolute;
   overflow: hidden;
   background-color: RGBA (0, 0, 0, 1);
   Color: #FFF;
 }

 td.vpn
 {
   text-align: left;
   font-size: 30px;
   padding: 5px;
 }

 img.vpn
 {
   anchura: 20 píxeles;
   altura: 20 píxeles;
 }

javascript.js

Una simple petición AJAX para recuperar los datos a mostrar.

 / * * VPN /

 vpn_timeout var;

 función vpn ()
 {
   $ .ajax ({
     asíncrono: falso,
     del tipo: "GET"
     url: "./ajax.php"
     datos "bloque = vpn"
     el éxito: function (html) {
       $ ( "# VPN") HTML (HTML).
     }
   });

   vpn_timeout = setTimeout ( "VPN ()", 5000);
 }

ajax.php

Nada específico para este módulo:

 /////////////////////////////////////////////////
   // VPN PGWP
   /////////////////////////////////////////////////

   if ($ == bloque 'VPN') {
     vpn echo ();
   }

.inc.php

Se requieren dos funciones de este módulo:

  • vpn_parseData (): analizar el archivo enviado a través netcat
  • VPN (): crear una tabla HTML con los nombres de usuarios conectados
 /////////////////////////////////////////////////
   // VPN PGWP
   /////////////////////////////////////////////////

   función vpn () {

     Datas $ = vpn_parseData ( "/home/jarvis/vpn/vpn_oberon.log");

     $ Html = '';

     if (sizeof (Datas $)> 0) {
       . $ Html = '<table cellspacing = "0px">';
       foreach ($ Datas como $ data) {
         $ Html = '<tr>'.
         $ Html. = '<Td valign = "middle"> <img class = "VPN" src = "PICT / vpn.png"> </ td> <td class = "VPN">'. $ Data [0]. </ td> ';
         $ Html = '</ tr>'.
       }
       $ Html = '</ table>'.
     }

     devolver $ html;
   }

   vpn_parseData función ($ stat_file) {
     $ Datas = array ();
     si (filemtime ($ stat_file) <time () - 10) {return $ datas más;}
     Estadísticas = $ fopen ($ stat_file, 'r');
     while ((línea $ = fgets ($ estadísticas))! == false) {
       $ Explode_line = str_word_count (línea $, 1, "0123456789.");
       $ Datas [] = $ explode_line;
     }
     fclose ($ estadísticas);
     devolver $ datas más;
   }

Esto en cuanto a este último módulo es muy simple

 

 

Como vemos el trabajo de MagdiBlog es   impresionante mostrando en una pantalla de forma espectacular  la hora y la  fecha  de una forma fácil de leer  La visualización del tiempo es también información útil todos los días. En cuanto a la tierra y la luna , resulta muy agradable (si eso no es lo suyo, puede reemplazar fácilmente estas imágenes con fotografías, añadir una función de “marco de fotos digital” integrado a los dashscreen ,etc)

Otros módulos como  ping , TeamSpeak , ancho de banda y VPN   pueden ser útiles para controlar lo que está sucediendo en cualquier red y recibir avisos de averías y otros problemas que puedan surgir.

Justo por encima del módulo de gráficos de ancho de banda,el autor  incluso añadió  un gráfico del número de visitas diarias usando GAPI para recuperar las estadísticas de Google Analytics y JSAPI (Gráficos de Google) para crear el gráfico.

Como vemos las posibilidades son inmensas sujetas tan solo a la creatividad de cada persona.  Para los módulos, el principio es siempre el mismo:

  1. un <div> con un ID en el archivo index.php
  2. una hoja de estilo style.css para colocar el div en cuestión y gestionar el formato de los datos que
  3. una función de JavaScript en el archivo javascript.js que se ejecuta una petición AJAX a intervalos regulares
  4. una línea en el archivo para llamar ajax.php buena función de PHP
  5. función de PHP en el archivo .inc.php para generar el código HTML para que se muestren las imágenes

Fuentes de descarga

Puede descargar todas las fuentes aquí: PiHomeDashScreen

Nota: tendrá que adaptar el código a sus necesidades.

 

 

Fuente http://www.magdiblog.fr/boa-pi-homedashscreen/3-principe-de-base/

Anuncios

Un comentario el “Estacion grafica multimedia con Raspberry Pi

  1. Sensui dice:

    te estan robando el contenido, un tarado que se cree bueno hace rato copia contenido y lucra con el

    Me gusta

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s