martes, 11 de junio de 2019

Gráficas de datos metereológicos. Python. Generar página web.

Página principal

Gráficas de datos metereológicos.
Python.
Generar página web.


Continuamos con la serie de artículos sobre servidor web.
En el último artículo había creado un visualizador de temperatura, humedad y presión. Además de visualizar los datos, creaba un registro diario de los datos.
El archivo de los datos está bien, pero su visualización e interpretación es poco útil si no se ven los datos gráficamente.
En este artículo se representan los datos en dos gráficas, una de temperaturas por horas, y en la otra la representación de humedad y temperatura en función de la hora.
Aunque no soy muy partidario del lenguaje python, he de reconocer que se hace muy fácil trabajar con el debido a la gran cantidad de librerías que existen para casi cualquier cosa.
Para este programa hacemos uso de la librería matplotlib. Esta librería se emplea para hacer todo tipo de gráficas. La librería está muy extendida, además de disponer de mucha documentación y una excelente página web.
Con esta librería creamos las gráficas anteriormente mencionadas, para luego exportarlas como imágenes con formato  *.png. Las imágenes creadas será luego las que se visualizaran en la página web.

Lo primero que debemos hacer para crear una gráfica es tener los datos, estos datos los obtenemos del fichero diario con el nombre:
"Temp"+ time.strftime("%y_%m_%d")+".cvs"
Creamos una matriz donde se almacenan todos los datos de temperatura, humedad y presión, donde se ordenan por horas y minutos.
Debo de anotar que crear matrices en python es un poco peculiar, no existe la creación de matrices como en otros lenguajes, debemos crearlas añadiendo datos, es de lo mas frustrante, aunque tiene otras ventajas este lenguaje.

Crear una gráfica de cada minuto de las 24 horas del día es innecesario, lo he reducido a 10 datos cada hora, o lo que es lo mismo cada 6 minutos.
Creo otras listas con los datos que realmente voy a utilizar para la gráfica. En total serán 10 muestras por hora, y como son 24 horas, el total de datos representados serán 240.
Las listas de datos son la siguientes:
    listaTemp , listaHume, listaPres
Estas son las lista de datos que voy a proporcionar a la librería  matplotlib para que cree las gráficas.


Código de creación de la gráfica de temperatura.
fig = plt.figure()                                                              
ax = fig.add_subplot(1,1,1)
major_ticks = np.arange(0, 240, 30)                                             
ax.set_xticks(major_ticks)
ax.grid(which='major', alpha=1)

plt.xlabel("Temperatura DIA "+ time.strftime("%d_%m_20%y"))
plt.plot(listaTemp,color='red')
plt.xlim(0,240)
plt.ion()

my_dpi=75
plt.savefig("gra2.png",dpi=my_dpi)


Código de creación de la doble gráfica de humedad y presión.
fig, (ax1, ax2) = plt.subplots(2, sharex=True,)

plt.xlim(0,240)
ax1.plot(listaHume,color='blue')
ax1.set(ylabel='Humedad %')

plt.xlim(0,240)
ax2.plot(listaPres,color='green')
plt.setp(ax2.get_xticklabels(), fontsize=9)

major_ticks = np.arange(0, 240, 30)                                             
ax2.set_xticks(major_ticks)

ax2.set(ylabel='Bares')
plt.xlabel("HORA "+time.strftime("%H:%M"))

my_dpi=75
plt.savefig("gra1.png",dpi=my_dpi)

En las siguientes imágenes se pueden ver los gráficos creados.


  Gráficas pertenecientes a Palencia, ESPAÑA

Se puede estudiar las gráficas y observar el cambio de presión preludio de lluvia.
Después de la lluvia observamos también como aumenta la humedad en el ambiente.
Estas dos imágenes son las que se incorporan en la página web para hacer mucho mas intuitiva el estudio de los datos.

Para ejecutar el programa en python he creado un programa en bash llamado gratem.sh que se ejecuta cuando se inicia el ordenador.
gratem.sh
#!/bin/bash
echo "GENERANDO GRAFICOS"
cd $HOME/www/webcam
$HOME/www/webcam/gratem.py
Ya tenemos el script creado, pero nos falta que el script se ejecute cada 10 minutos.
Para esta tarea utilizaremos cron.  El comando cron es un administrador regular de procesos en segundo plano que viene de serie en linux.
Para añadir el comando que se debe ejecutar en segundo plano, utilizaremos el comando crontab -e  .
Editaremos de la siguiente forma:

    */10 * * * * /home/seta/www/webcam/gratem.sh > $HOME/tmp/cron.log 2>&1

De esta forma el script  de generación de gráficas se ejecutará cada 10 minutos.

Podéis comprobar el resultado en mi página:
http://seta43.duckdns.org/seta/webcam/gradia.html
http://seta43.ddns.net/seta/webcam/gradia.html
Espero que os guste este artículo, y que os sirva para vuestros proyectos.

PROGRAMAS

Saludos
Juan Galaz

Bibliografía:
https://matplotlib.org/index.html
https://claudiovz.github.io/scipy-lecture-notes-ES/intro/matplotlib/matplotlib.html
https://github.com/japp/Computacion-Cientifica/blob/master/graficos.rst



miércoles, 5 de junio de 2019

Sensores-Tratamiento de datos metereológicos con Python - Generar página web con temperaturas

Página principal

Sensores

Tratamiento de datos metereológicos
con
Python
Generar página web de temperaturas


Este artículo es una continuación de una serie de artículos sento.html , oracam.html, serora.html .
El propósito de este artículo es capturar los datos que manda un módulo ( en este caso un arduino con sensores) a través del puerto serie ( /dev/ttyUSB0', '/dev/ttyUSB1','/dev/ttyACM0','/dev/ttyACM1'....) y procesarlos para guardarlos en un fichero ( ejemplo: Temp2019_06_04.csv ).
Además de todo lo anterior, creará una página web donde se visualizarán los datos a través de un servidor web.
No soy muy partidario de Python, pero al estar muy implantado en todas la plataformas del tipo Raspberry o Orange-PI,  que es donde se va montar el servidor, la programación se va a realizar en este lenguaje. Deberéis perdonar lo mal que sé programar en Python, soy novato en este lenguaje de programación, normalmente programo en C/C++ o Básic.

Lo primero es saber el formato que tienen los datos que transmite el modulo de sensores (arduino) a través del puerto serie.
Formato de datos
INICIO
Temperatura,14.0
Humedad,32
#presion,923
#Temperatura,26.1
FINAL
Como podéis observar el formato es bastante simple:
Dos cadenas INICIO y FINAL, y en medio datos.
Cada línea de datos está compuesto del tipo de dato y el valor, separados por una coma.

Lo primero que hace el programa es buscar el módulo en todos los puertos serie posibles.
Al escanear los puertos, si existe el módulo, responderá el módulo con la palabra SENSORTOTAL empezándose a ejecutarse la rutina principal del programa.

En la rutina principal del programa, se lee continuamente el puerto serie hasta que encuentra datos a procesar.
Cuando encuentra datos, los almacena en las variables  dTemperatura, dHumedad, dPresion.
La visualización en tiempo real se realiza en consola.


Cada minuto se van almacenando las variables en un fichero con el formato TempAÑO_MES_DIA.csv  .
Ejemplo : Temp2019_06_04.csv
Esto se realiza con los comandos en python:
nombreFichero="Temp20"+time.strftime("%y_%m_%d")+".csv"
f = open(nombreFichero,'a')
f.write(time.strftime("%H,%M"))
f.write(',')
f.write(dTemperatura+','+dHumedad+','+dPresion+','+'\n')
f.close()

Como podéis observar cada día se crea automáticamente un fichero de datos.
Formato del fichero de datos metereológicos
00,00,21.6,25,924,
00,01,21.6,25,924,
00,02,21.6,25,924,
00,03,21.6,25,924,
00,04,21.5,25,924,
Lo bueno de este formato es que se puede importar con una hoja de cálculo para su tratamiento.

El programa, cada 41 segundos o cada vez que recibe datos del módulo de sensores, actualiza el fichero  index.html que es el que se representa en la página web.
El código python que se utiliza para crear la página web es el siguiente:
            print "Crear pagina"
            fw = open('index.html','w')

            mensajeWeb = """
<html>
<head>
    <meta http-equiv="refresh" content="115">
    <title>PALENCIA</title>
</head>
<body bgcolor="#ffff99">
<h2>Palencia, Spain
<hr size="2" width="100%">
<img  alt="" src="web.jpg" height="480" width="640"><br>
<hr size="2" width="100%">
"""
            mensajeWeb = mensajeWeb + time.strftime("%d/%m/%y") +"  "+ time.strftime("%H:%M:%S")
            mensajeWeb = mensajeWeb + """<br>"""
            mensajeWeb = mensajeWeb + mensaje
            mensajeWeb = mensajeWeb + """
<h2><a href="gradia.html">GRAFICOS</a><br>
<img  alt="" src="mapa.png" >
</h2>           
</body>
</html>"""

            fw.write(mensajeWeb)
            fw.close()
Como había veces que los navegadores utilizaban la cache, y para que se actualizase cada 2 minutos, añadí en la cabecera del fichero html :  <meta http-equiv="refresh" content="115">
Con lo que obliga al navegador a actualizar automáticamente la página web.
El resultado es el siguiente:


Podéis comprobar el resultado en mi página:
http://seta43.duckdns.org/seta/webcam/index.html
http://seta43.ddns.net/seta/webcam/index.html
El resultado no lo he hecho muy vistoso a propósito, para hacer mas legible el código, el que quiera lo puede mejorar retocando el código html.

Para ejecutar el programa en python he creado un programa en bash llamado app_python.sh que se ejecuta cuando se inicia el ordenador.
app_python.sh
#!/bin/bash
cd /home/seta/www/webcam
xterm -e "python camtem4.py"
He de reconocer que en mi placa OrangePI no consigo que se inicie automáticamente, aunque en el ordenador PC se inicie perfectamente, y mira que lo he revisado, pero nada, lo debo iniciar yo, por lo cual si se va la luz en el servidor, debo lanzarlo yo remotamente.

PROGRAMA


Saludos.
Juan Galaz


Bibliografía:
https://pyserial.readthedocs.io/en/latest/
sento.html
predi.html
raspb.html
arterec.html
tm16tem.html

viernes, 31 de mayo de 2019

Linux Mandar correo desde la línea de comandos. mutt

Volver

Linux

Mandar correo desde la línea de comandos.

mutt


En un anterior artículo había mandado un correo desde la línea de comandos utilizando curl.
Ante la imposibílidad de mandar adjuntos mediante curl ( yo no lo he podido conseguir ) , he buscado otras soluciones, y he encontrado mutt que está bastante extendido.
Lo primero es instalar el paquete mutt.
    apt install mutt
Creamos los ficheros de configuración.
    mkdir -p ~/.mutt/cache/headers
    mkdir ~/.mutt/cache/bodies
     touch ~/.mutt/certificates
Creamos el archivo de configuración.
    touch ~/.mutt/muttrc
Editamos el fichero de configuración según nuestro servidor de correos.
En mi caso utilizo leafpad como editor.
     leafpad ~/.mutt/muttrc


En mi caso (GMAIL) la configuración del servidor es la siguiente
set ssl_starttls=yes
set ssl_force_tls=yes
 
set imap_user = 'CORREO_ORIGEN@gmail.com'
set imap_pass = 'CONTASEÑA'
 
set from='
CORREO_ORIGEN@gmail.com'
set realname='seta43'
 
set folder = imaps://imap.gmail.com/
set spoolfile = imaps://imap.gmail.com/INBOX
set postponed="imaps://imap.gmail.com/[Gmail]/Drafts"
 
set header_cache = "~/.mutt/cache/headers"
set message_cachedir = "~/.mutt/cache/bodies"
set certificate_file = "~/.mutt/certificates"
 
set smtp_url = 'smtps://
CORREO_ORIGEN@gmail.com:CONTASEÑA@smtp.gmail.com:465/'
 
set move = no
set imap_keepalive = 900




El correo mandado será desde un archivo de texto, que en este caso se llama tarea23_59.txt .
Además se mandan los 3 ficheros adjuntos  gra1.png , gra2.png y datos.txt.

El fichero modelo del correo tiene el siguiente formato:
tarea23_59.txt
ESTADISTICAS DEL DIA
vie may 31 08:37:58 CEST 2019





Se crea script donde a partir de un modelo de correo, solo cambio la última línea donde inserto la fecha.
/home/seta/tareas/tarea1.sh
#!/bin/bash
datecreated=`date`

cd $HOME/tareas

sed -i '$d' tarea23_59.txt
echo
$datecreated >> tarea23_59.txt

mutt -s "temperaturas"  CORREO_DESTINO.com < tarea23_59.txt -a $HOME/www/webcam/gra1.png  -a $HOME/www/webcam/gra2.png  -a $HOME/www/webcam/datos.txt


Ya tenemos el script creado, pero nos falta que el script se ejecute a las 23:59.
Para esta tarea utilizaremos cron.  El comando cron es un administrador regular de procesos en segundo plano que viene de serie en linux.
Para añadir el comando que se debe ejecutar en segundo plano, utilizaremos el comando crontab -e  .
Y editaremos de la siguiente forma:

59 23 * * * /home/seta/tareas/tarea23_59.sh >/dev/null 2>&1

De esta forma el script se ejecutará a las 23:59 .


Saludos
Juan Galaz

Bibliografía:
https://www.garron.me/es/gnu-linux/correo-linea-commands-gmail-mutt.html
https://ubunlog.com/mutt-cliente-correo-terminal/

viernes, 10 de mayo de 2019

Mandar correo desde la línea de comandos y averiguar la IP publica

Volver

Linux

Mandar correo desde la línea de comandos.

Averiguar la IP publica de nuestro router desde la línea de comandos.


En anteriores artículos había realizado un servidor web.
Al no disponer IP fija de mi operadora, al algún caso cuando se reiniciaba el router, se cambiaba la IP pública.
Esto me hacía imposible entrar en mi servidor desde el exterior al no saber la IP en ese momento.
La única forma era mandarme un correo cada cierto tiempo de la IP publica que tengo.
En este artículo explico como averiguar mi IP pública, y cada 12 horas mandar a mi correo personal un correo donde indico la IP publica en ese momento.
El programa que se utiliza para mandar el correo y averiguar la IP pública es curl.
El programa curl es una auténtica navaja suiza, puede trabajar con la mayoría de los protocolos de internet.

Para averiguar nuestra IP pública utilizamos el comando:  
    curl ifconfig.me 
Nos devolvera una dirección IP, que corresponde la IP externa de nuestro router.

Para mandar un correo desde la línea de comandos (el servidor de correos es GMAIL) se utiliza el programa curl con los comandos:
curl --url 'smtps://smtp.gmail.com:465' --ssl-reqd   --mail-from 'correoOrigen@gmail.com' --mail-rcpt 'correoDestino@gmail.com'   --upload-file correo.txt --user 'correoOrigen@gmail.com:CONTRASEÑA' --insecure
Como podéis ver, para mandar un correo necesitamos una cuenta de correos de origen, y una cuenta de correos donde vamos a mandar el correo.
El correo mandado será desde un archivo de texto, que en este caso se llama correo.txt .

El fichero modelo del correo tiene el siguiente formato:
correo.txt
From: "SERVIDOR_PI" <correoOrigen@gmail.com>
To: "Otro Nombre" <
correoDestino@gmail.com>
Subject: AsuntoIP

Hola IP actual
vie may 10 00:00:01 CEST 2019
87.221.154.144


Todo lo anterior se junta en un script donde a partir de un modelo de correo, solo cambio las 2 últimas líneas donde inserto la fecha y la IP pública en ese momento.
/home/seta/tareas/tarea1.sh
#!/bin/bash
datecreated=`date`

cd /home/seta/tareas
echo "Mandando correo de la IP actual"
sed -i '$d' correo.txt
sed -i '$d' correo.txt

echo $datecreated >> correo.txt
curl ifconfig.me >> correo.txt

curl --url 'smtps://smtp.gmail.com:465' --ssl-reqd   --mail-from 'correoOrigen@gmail.com' --mail-rcpt 'correoDestino@gmail.com'   --upload-file correo.txt --user 'correoOrigen@gmail.com:CONTRASEÑA' --insecure


Ya tenemos el script creado, pero nos falta que el script se ejecute cada 12 horas.
Para esta tarea utilizaremos cron.  El comando cron es un administrador regular de procesos en segundo plano que viene de serie en linux.
Para añadir el comando que se debe ejecutar en segundo plano, utilizaremos el comando crontab -e  .
Y editaremos de la siguiente forma:

0 */12 * * * /home/seta/tareas/tarea1.sh >/dev/null 2>&1

De esta forma el script se ejecutará cada 12 horas.


Espero que os sirva de algo este artículo.


Saludos
Juan Galaz


lunes, 29 de abril de 2019

Sensores 18B20 LDR BMP180 DHT22, Arduino - Gambas - Python

Página principal


Sensores

18B20 LDR BMP180 DHT22

Arduino - Gambas - Python


Debía realizar un circuito electrónico para añadir a una página web donde indicara la temperatura ambiente.
La idea era solo colocar un sensor de temperatura 18B20, pero se me ocurrió añadir mas sensores.
En este circuito coloco varios sensores:
-18B20 sensor de temperatura.
-LDR sensor de luz.
-BMP180 sensor de presión y temperatura.
-DHT220 sensor de temperatura y humedad. (he utilizado el equivalente AM2302)


Todos los datos de estos sensores se transmiten al PC mediante el terminal serie.

Circuito montado.


Circuito.

Para la representación de los datos he utilizado dos programas.
El primero está realizado en Gambas (VB para linux).
El segundo realizado en Python.
En ambos programas busca la placa de sensores dentro de todos los posibles puertos serie.
Si encuentra el módulo de sensores los representa en pantalla.
Toda la programación se ha realizado en el entorno Linux con la distribución Debian 9.
La información de sensores se manda cada 5 segundos.
Su transformación para que funcionase en Windows en el caso de Phyton es fácil, solo cambiar la lista de dispositivos serie.

Programa Gambas (VB para linux).


Programa Phyton.

El montaje es perfecto para probar sensores.
Si no tenéis alguno de los sensores, deberéis anular el código correspondiente al sensor en el programa del arduino.

PROGRAMAS

VIDEO





Saludos.
Juan Galaz


Bibliografía:
predi.html
raspb.html
arterec.html
tm16tem.html




martes, 23 de abril de 2019

Servidor WEB con Cámara en Orange PI

Volver

Servidor WEB con Cámara
Orange PI


En el anterior artículo había realizado y probado un servidor WEB con la placa Orange PI y el servidor  NGINX.
En este artículo añado un componente mas a Orange PI, una cámara.
A través de la página web se podrá ver la imagen de la calle, esta imagen se actualizará cada 2 minutos.
http://seta43.duckdns.org/seta/webcam/index.html


Imagen vista desde un navegador.

Para este proyecto hemos utilizado una webcam  Logitech, Inc., aunque sirve cualquiera que funcione en Linux.

Cámara colocada en la ventana.

Como base de la página web tenemos el fichero index.html

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <meta http-equiv="content-type" content="text/html; charset=UTF-8">
    <meta http-equiv="refresh" content="115">
    <title>miweb</title>
  </head>
  <body alink="#EE0000" bgcolor="#ffff99" link="#0000EE" text="#000000"
    vlink="#551A8B">
    <i><big><b>Mi_Cámara</b></big></i><br>
    <hr size="2" width="100%"><big><big style="font-weight: bold;"><img
          alt="" src="web.jpg" height="480" width="640"><br>
        <br>
mar abr 23 20:26:01 CEST 2019
      </big></big>
  </body>
</html>



Lo primero que debemos hacer es utilizar un programa que capture una imagen de la webcam para colocarla en la página web.
_____VERSIÓN___ANTIGUA CAMBIADA_________
El programa utilizado es vgrabbj , este programa se maneja vía comandos, que es lo que nos interesa.

vgrabbj -U -R -i vga  -z 50  -f /home/seta/www/webcam/web.jpg


Con esta orden capturamos una imagen en /home/seta/www/webcam/web.jpg , es donde alojaremos la página web de la webcam.
En mi caso coloco mi webcam boca-abajo para mejor sujección, por lo cual debo utilizar las opciones -U -R para dejar la imagen bien.
El tamaño será de 640x480, con la orden -i vga capturo  ese tamaño.
En algunas webcam se necesita ciertas imágenes para que se estabilice la luz, yo espero 50 imágenes, opción -z 50.
El script queda de la siguiente manera.


#!/bin/bash
datecreated=`date`

vgrabbj -U -R -i vga  -z 50  -f /home/seta/www/webcam/web.jpg
sed -i '14d' /home/seta/www/webcam/index.html
sed -i "14i${datecreated}" /home/seta/www/webcam/index.html


Después de funcionar perfectamente la webcam durante 1 semana, se me ocurrió reiniciar la placa Orange PI.
Resultaba que la webcam no se llegaba a ver. Probando y probando me dí cuenta que el programa vgrabbj no funcionaba a veces cuando se lanzaba por primera vez.
Para solucionar el problema he cambiado el programa que captura imagenes, y ahora es fswebcam.
Ahora funciona todo bien cuando re reinicia el servidor.

#!/bin/bash
datecreated=`date`

#echo "$datecreated" >> /home/seta/web.txt
#vgrabbj -U -R -i vga  -z 50  -f /home/seta/www/webcam/web.jpg
#uvccapture -x640 -y480 -m -o"/home/seta/www/webcam/web.jpg"
fswebcam -r "640x480" -S 40 --flip h,v  --no-banner  --jpeg 70  /home/seta/www/webcam/web.jpg
sed -i '14d' /home/seta/www/webcam/index.html
sed -i "14i${datecreated}" /home/seta/www/webcam/index.html


Con el comando sed borro la línea 14, e inserto la hora y la fecha en la página web.

Para que la página web se actualize automáticamente coloco en la cabecera de la página web:

 <meta http-equiv="refresh" content="115">

Esto hace que se actualice cada 115 segundos.

Ya tenemos el script creado, pero nos falta que el script se ejecute cada 2 minutos.
Para esta tarea utilizaremos cron.  El comando cron es un administrador regular de procesos en segundo plano que viene de serie en linux.
Para añadir el comando que se debe ejecutar en segundo plano, utilizaremos el comando crontab -e  .
Y editaremos de la siguiente forma:

*/2  * * * * /home/seta/www/webcam/tareaWeb > /dev/null 2>&1

De esta forma el script se ejecutara cada 2 minutos.

Como veis es una forma bastante sencilla de crear una webcam en tu página web.


Saludos
Juan Galaz

Bibliografía:

servi.html
wpa.html
wpb.html
orange.html
https://orangepiweb.es/
http://www.orangepi.org/orangepibbsen/forum.php?gid=38



jueves, 11 de abril de 2019

Servidor WEB con Orange PI y NGINX

Volver

Servidor WEB

con

Orange PI y NGINX


En el anterior artículo había realizado y probado un servidor DELL R200.
El modelo DELL R200  tiene el procesador Xeon X3360 de 4 núcleos. El servidor está configurado con dos discos 250G en modo RAID, controlados por una tarjeta.
El resultado era bueno, pero el consumo 77W era alto debido a su potencia. Solo el coste de electricidad por año llegaba a 90€.
Para mantener un servicio comercial de varias páginas web es ideal, pero para un uso particular resulta un tanto costoso.
Hace años que había realizado un estudio de Orange PI PC ,es un clónico de la Raspberry Pi, pero algo mas barato y mas potente (en su día).
En este artículo realizo un servidor WEB con esta placa. Todos los pasos se pueden realizar en una Raspberry Pi, pero esto no lo he probado.
He de confesar que todos los pasos los realicé antes en un ordenador normal (PC) con Debian 9, y luego los he reproducido en la Orange PI PC con Debian 8, funcionando a la perfección.

Lo primero es ir a la página http://www.orangepi.org/downloadresources/ y bajar la versión de Debian que corresponda a vuestra placa, en mi caso (Orange Pi Pc)Debian XFCE Desktop .
Esta imagen está comprimida, y tenemos dos opciones para instalarla en una SD en linux.
La fácil es utilizar el programa gnome-disks desde root.
La segunda opción es descomprimir la imagen.gz que no creará un archivo con extensión .img.
Ahora instalamos la imagen.img a la SD con la orden:
    dd if=OrangePI_Jessie_Xdfce.img of=/dev/sdx bs=1M oflag=direct
donde /dev/sdx es el lugar donde se encuentra la SD. Para saber donde se encuentra la SD se teclea  fdisk -l y nos mostrará los diferentes discos y su localización.
Todo esto lo debemos hacer siendo root, tener paciencia, tarda tiempo en escribir la SD dependiendo de la clase que sea (4) (10).
En esta página del foro se puede encontrar algo en español:
http://www.orangepi.org/orangepibbsen/forum.php?mod=viewthread&tid=33
En ingles:
http://www.orangepi.org/orangepibbsen/forum.php?mod=viewthread&tid=342
Una vez instalada la imagen en la SD nos creará dos particiones:
BOOT donde se instalan las imágenes uImage del kernel y los script.bin (configuraciones)
Linux donde se encuentra el propio sistema operativo.
Antes debíamos de seleccionar el script.bin apropiado a nuestra placa, ahora ya viene instalado el script apropiado y no hay que hacer nada.

Todo preparado para el primer arranque, hdmi conectado a la Tv, SD con el sistema operativo instalado, teclado y ratón conectado al USB ,y red conectada. Conectamos la alimentación y esperamos como salen los primeros caracteres de arranque de linux.
Nos encontramos ante la petición de usuario y contraseña. Existen dos usuarios ya creados.
orangepi    contraseña: orangepi
root        contraseña: orangepi
Entramos con el usuario orangepi y nos encontramos con un escritorio Xfce.
Lo primero es cambiar la configuración del teclado, entramos en Settings->Keyboard , cambiamos la localización del teclado.

Si queremos cambiar la configuración del teclado en los terminales gráficos, tecleamos como root, la orden:
dpkg-reconfigure locales
Aquí me he encontrado que no funciona el cambio de locales, yo lo he solucionado como indica la página:
    https://enavas.blogspot.com/2015/01/configurar-locales-y-eliminar-el-aviso.html
Yo he editado el fichero  /etc/default/locale y lo he puesto de la siguiente forma:

LANG=es_ES.UTF-8
LANGUAGE=es_ES.ISO-8859-15@euro
LC_ALL=es_ES.UTF-8
LC_CTYPE=es_ES.UTF-8
LC_MESSAGES=es_ES.UTF-8
LC_TIME=es_ES.UTF-8
LC_PAPER=es_ES.UTF-8
LC_MEASUREMENT=es_ES.UTF-8
LC_MONETARY=es_ES.UTF-8
LC_NUMERIC=es_ES.UTF-8

De todas formas puedes manejar el teclado si sabes como está el teclado americano.

Lo primero y mas conveniente es cambiar las contraseñas de root y orangepi con la orden passwd usuario.
El usuario seta es desde donde voy a trabajar, este usuario entrara automáticamente en forma gráfica, se podrá manejar a distancia con ssh, VNC y ftp. Vamos que una vez configurado todo, no hace falta tener ni teclado, ratón y monitor en la placa Orange PI.
Creamos el  usuario con la orden adduser seta , y  colocamos la contraseña con passwd seta.
Para que inicie automáticamente un usuario, debemos configurar el gestor de arranque  lightdm .
Entramos en consola como root  y editamos el fichero de configuración con la orden:
pluma /etc/lightdm/lightdm.conf
y editamos las líneas siguientes:
autologin-user=seta
autologin-user-timeout=20
Donde seta es el usuario que se inicia automáticamente, y 20 son los segundos que tarda en iniciarse automáticamente.

Debemos configurar la red para que sea la IP estática, en nuestro caso le vamos a dar la IP 192.168.1.70 .


Veremos que cuando entramos en la consola como root o orangepi , nos salda la opción de poder utilizar toda la SD para el sistema. Cuando se instala la imagen en la SD se crea una partición de solo 2 o 3 Gb, si tenemos una SD de 16Gb desaprovecharíamos 13Gb, con la orden sudo fs_resize ,se redimensiona la partición para utilizar toda la SD.

Como pienso que instalar un servidor de páginas dinámicas en esta placa es un tanto pretencioso, no digo que no funcione, no he añadido los paquetes PHP, ni MySQL. El servidor solo servirá páginas estáticas para ser mas rápido.

Con el instalador de aplicaciones Synaptic, o con la orden apt install paquete,  instalamos los paquetes:
ssh    - acceso remoto a un servidor por medio de un canal seguro.
vsftpd    -Servidor ftp
x11vnc    -Servidor VNC
nginx    -Servidor WEB, es algo mas ligero que apache.
Además a mi me gusta instalar: dillo, xfe.

Otra cosa que me gusta hacer es instalar un servidor de escritorios remotos. Con el instalador de aplicaciones Synaptic instalamos x11vnc. Ahora  desde consola indicamos la contraseña del servidor de escritorio remoto, x11vnc  -storepasswd .
Para lanzar el escritorio remoto desde consola , x11vnc -forever -usepw -display :0 -ultrafilexfer


Ahora vamos a configurar el servidor ftp.
Editamos el fichero /etc/vsftpd.conf y colocamos esto:

listen=YES
listen_ipv6=NO
anonymous_enable=NO
local_enable=YES
write_enable=YES
dirmessage_enable=YES
use_localtime=YES
xferlog_enable=YES
connect_from_port_20=YES
chroot_local_user=YES
chroot_list_enable=YES
chroot_list_file=/etc/vsftpd.chroot_list
allow_writeable_chroot=YES
secure_chroot_dir=/var/run/vsftpd/empty
xferlog_enable=YES
vsftpd_log_file=/var/log/vsftpd.log    
xferlog_std_format=YES
xferlog_file=/var/log/xfer.log
dual_log_enable=YES
pam_service_name=vsftpd
ssl_enable=NO

Con esto enjaulamos a todos lo usuarios en su propio directorio.
Editamos el fichero /etc/vsftpd.chroot_list y colocamos esto: seta
Indicamos que el único usuario que no estará enjaulado será seta.

Para que las configuraciones se actualicen deberemos reiniciar la placa o actualizarlas una por una, mejor reiniciamos la placa.
Ahora mismo ya no nos hace falta ni ratón, teclado y monitor.
Podremos manejar la placa Orange PI de forma remota, lo podéis comprobar desde otro PC.

La forma de entrar desde otro ordenador a la placa Orange PI mediante ssh es:
ssh seta@192.168.1.70
También existe la posibilidad de ejecutar un programa gráfico con ssh,  ejemplo:
ssh -X -p 22 seta@192.168.1.70 pluma
Es una forma bastante más rápida que utilizar  VNC.

Para transferir ficheros utilizamos ftp, cualquier programa como gftp o Filezilla sirve.
Recordar que solo hemos autorizado la usuario seta a moverse por todos los directorios de la placa Orange PI.

También podemos entrar mediante VNC a manejar el escritorio del usuario seta.

Ya nos toca empezar ha configurar todos los parámetros del servidor WEB, que es el objetivo de este artículo.
Desde cualquier ordenador de nuestra red interna, teclearemos en nuestro navegador la dirección 192.168.1.70 .
Si todo fue bien nos aparecerá la página por defecto del servidor NGINX, el fichero es : /var/www/html/index.nginx-debian.html .
Este fichero será el de por defecto, si no encuentra el fichero index.html.
Normalmente esto serviría si solo tenemos un usuario, pero como yo suelo crear varías páginas que gestionan diferentes usuarios, debo hacer diferentes cambios.
Lo primero es crear un directorio www en el directorio de cada usuario, donde se alojará la página web de cada usuario.
mkdir   /home/seta/www
chown  -R seta:seta    /home/seta/www
chmod  u+rwx      /home/seta/www
chmod  ugo+rx      /home/seta/www
Hemos creado el directorio ww y dado todos los permisos para el buen funcionamiento.

Le damos as seta los permisos para editar todos los fichero web
chown -R seta:seta   /var/www/html
chmod  ugo+rx    /var/www/html

Como root creamos otro directorio:
mkdir  /var/www/html/seta
chown -R seta:seta   /var/www/html/seta
chmod  ugo+rx    /var/www/html/seta

Ahora hacemos un montaje, no enlace, donde los los ficheros que se encuentran en /home/seta/www , el servidor pensará que están en /var/www/html/seta.
echo "/home/seta/www     /var/www/html/seta   none    bind    0    0" >> /etc/fstab
Desde el navegador tecleamos la dirección 192.168.1.70/seta , y nos aparecerá la página almacenada en el directorio /home/seta/www.
Esto es muy útil, podemos crear usuarios enjaulándolos en su directorio www y que puedan tener su página. Ejemplo: http://seta43.duckdns.org/usuario

En mi caso he creado un script de comandos bash donde se crean usuarios con su pagina web desde 4 estilos diferentes en menos de 7 segundos. Los usuarios creados mediante este método están enjaulados en su propio directorio. Además tienen su directorio www, donde alojan su página que pueden actualizar mediante ftp.
Recordar que cuando subáis ficheros a vuestra página, estar seguro que ponéis los permisos adecuados para que se puedan leer,  a mi me paso, hasta que me di cuenta.

Si queréis ver mi página funcionando está en:
http://seta43.duckdns.org

Existe una utilidad en Apache tools para testear el servidor.
Con la orden: ab -c 5 -t 60 http://192.168.1.70/  chequeamos la velocidad del servidor WEB.
Petición desde HP A6_5400 hacia ORANGE PI
Petición desde HP A6_5400 hacia DELL R200
Server Software:        nginx/1.6.2
Server Hostname:        192.168.1.70
Server Port:            80

Document Path:          /
Document Length:        813 bytes

Concurrency Level:      5
Time taken for tests:   21.551 seconds
Complete requests:      50000
Failed requests:        0
Total transferred:      52250000 bytes
HTML transferred:       40650000 bytes
Requests per second:    2320.07 [#/sec] (mean)
Time per request:       2.155 [ms] (mean)
Time per request:       0.431 [ms] (mean, across all concurrent requests)
Transfer rate:          2367.65 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    0   0.1      0       4
Processing:     0    2   0.7      2      25
Waiting:        0    2   0.7      2      25
Total:          1    2   0.6      2      26
Server Software:        Apache/2.4.25
Server Hostname:        192.168.1.60
Server Port:            80

Document Path:          /
Document Length:        1112 bytes

Concurrency Level:      5
Time taken for tests:   4.606 seconds
Complete requests:      50000
Failed requests:        0
Total transferred:      69200000 bytes
HTML transferred:       55600000 bytes
Requests per second:    10855.19 [#/sec] (mean)
Time per request:       0.461 [ms] (mean)
Time per request:       0.092 [ms] (mean, across all concurrent requests)
Transfer rate:          14671.47 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    0   0.0      0       4
Processing:     0    0   0.1      0       4
Waiting:        0    0   0.1      0       4
Total:          0    0   0.1      0       4

El consumo del DELL R200 es de 77W con un coste anual de 90€
El consumo de la placa Orange PI es de 1,7W con un coste anual de 2,5€.

Como podéis observar el coste anual es mínimo, es una solución muy valida para tener unas pocas páginas sin demasiado tráfico.
Me ha sorprendido lo bien que responde a las peticiones desde internet, funciona bastante bien.

Como es tan pequeña la placa Orange PI la tengo metida debajo de la mesa, no mete ruido, consume poco, y se calienta poco (yo tengo la caja abierta para que no se acumule el calor).
Recordar que para que se pueda ver vuestro servidor desde internet, se tiene que configurar el router para que redireccione los puertos a la placa Orange PI, de la misma forma pasa con el ftp.

Si ahora intentas acceder a la página web desde internet, fuera de nuestra red, veremos que ya funciona nuestro servidor WEB.
Para poder verse a uno mismo como si estuviésemos en el exterior, debemos emplear un truco.
Existe una página web que permite hacer esto: http://anonymouse.org/anonwww.html
Aunque inserta un pequeño anuncio funciona perfectamente.
Otra forma utilizar nuestro móvil con conexión a internet, pero claro gastaremos datos.

Para los que no tengan dominio y quieran experimentar, yo utilizo un subdominio tipo NO-IP.
En mi caso es  http://seta43.duckdns.org/
En la página http://www.duckdns.org/ podéis conseguir el vuestro, funciona bastante bien, además te explican como instalarlo en vuestro servidor para que se actualice la dirección IP dinámica que ha dado el operador.



Saludos
Juan Galaz

Bibliografía:

servi.html
wpa.html
wpb.html
orange.html
https://orangepiweb.es/
http://www.orangepi.org/orangepibbsen/forum.php?gid=38