sábado, 20 de enero de 2018

Configuración de modo cine en Arduino


Cada vez que propongo un trabajo en clase siempre hay algunos alumnos que van más allá, que les gusta la temática propuesta y superan lo que se les pide, y lo que aquí les presento es uno de esos casos.

Quebehi y Eduardo han realizado un montaje en Arduino realmente bueno, muy original y creativo y con un ligero toque de humor incluido.

Han realizado una instalación domótica sobre la plataforma Arduino en la que han desarrollado un prototipo de modo cine: control remoto de la pantalla, diversidad de canales, avisador acústico y óptico de infiltrados, cierre automático de persianas,...

A continuación te ofrecemos un adelanto de su trabajo:


Detalle del interior de la maqueta



Placa Arduino con toda la electrónica conectada



Simulación electrónica del modo cine



Esquema del montaje electrónico



Además, incluyen una memoria técnica en la que explican de forma pormenorizada todo el proceso de montaje, el código, los esquemas electrónicos, relación de componentes utilizados,...
Una nueva joya que hoy añadimos a nuestra biblioteca dedicada a esta temática, esperamos que te guste.


Enhorabuena tanto al uno como al otro, sin duda un trabajo bien hecho!

Enlace al tutorial completo de Arduino:
https://fpkanarias.blogspot.com.es/2016/11/videotutorial-arduino-aprendiendo.html

viernes, 19 de enero de 2018

Hoy añadimos otra joya al tutorial de Arduino


Hoy hemos añadido otra joya a la biblioteca de Arduino.

Esteban, Adara y Elías, estudiantes del 2do curso del CFGS de Sistemas de Telecomunicaciones e Informáticos, han realizado una maqueta utilizando esta plataforma de automatización con un nivel de refinamiento exquisito.

Una vivienda con un elevado grado de automatización: iluminación, televisión, sistema de alarma,...
Y todo, acompañado de una memoria técnica en la que se explica con todo detalle cómo llevarlo a cabo: materiales, presupuesto, esquemas de montaje electrónico, código, vídeos demostrativos,...

Si te apetece conocer un poco más acerca del apasionante mundo de la domótica, aquí tienes una propuesta realmente buena, disfrútala.


Si te has quedado con ganas, y todavía quieres conocer más, aquí tienes un enlace al tutorial básico de Arduino que hemos elaborado, con multitud de ejemplos de montaje que parten desde lo más sencillo, a montajes con un cierto nivel de complejidad del calibre que hoy presentan Adara, Esteban y Elías.

Enlace al tutorial completo de Arduino:
https://fpkanarias.blogspot.com.es/2016/11/videotutorial-arduino-aprendiendo.html

jueves, 18 de enero de 2018

Instalar profiCAD 9.3 en Elementary OS para hacer diagramas KNX



profiCAD es un software de Diseño Asistido por Ordenador que usamos para representar circuitos eléctricos. En mi caso, lo usaré para el tema de KNX del módulo profesional de Sistemas Integrados y Hogar Digital del 2do curso de CFGS de Sistemas de Telecomunicaciones e Informáticos.

Instalar profiCAD en Elementary OS y en cualquier otra versión de Linux basada en Ubuntu es tan sencillo como descargar de la página oficial el instalador y seguir paso a paso sus indicaciones. Eso sí, debes de tener Wine en tu sistema.

A continuación te muestro algunos pantallazos para que veas los simple que es:




Accedemos a la página de profiCAD y a su sección descargas:


Pulsamos sobre el fichero .exe que hemos descargado



Elegimos la ruta de instalación


Ponemos nombre a la carpeta de instalación



Instalar



Nos avisa de que se instalar .net framework 4.0



Parece que todo ha ido bien



Y ya tenemos profiCAD instalado en eOS



Icono de profiCAD en mi sistema eOS



Sección de componentes KNX 



Última versión instalada: 9.3.4



Esquema KNX

miércoles, 10 de enero de 2018

¿Está mi Elementary OS afectado por Spectre o por Meltdown? Un script para comprobarlo



Spectre y Meltdown son dos virus que afectan a procesadores Intel y ARM, estos segundos muy habituales en móviles, tablets. Como la vulnerabilidad está en el procesador, los sistemas Linux y MacOS también pueden ser afectados.

A continuación te dejo una forma sencilla para saber si tu sistema Linux está afectado. En mi caso, lo he probado en Elementary OS Loki 0.4 y por suerte estoy a salvo.


Instalamos git
sudo apt install git



Descargamos el script spectre-meltdown-checker desde github
git clone https://github.com/speed47/spectre-meltdown-checker.git




Lanzamos el script que revisa si estamos infectados
sudo sh spectre-meltdown-checker.sh 

Por suerte NO estoy afectado pero sí que es cierto que ahora mismo mi sistema es vulnerable.


Fuentes:

viernes, 5 de enero de 2018

Recuperando la confianza en bq: continúa las actualizaciones de mi tablet tras 2 años



Desde mi punto de vista, uno de los aspectos clave a la hora de comprar un móvil o una tablet es la política de actualizaciones de la marca.

La inmensa mayoría de fabricantes abandona el mantenimiento de sus dispositivos después de vendidos. Así, por más que Google saque actualizaciones de Android, estos no se preocupan en preparar drivers que les den soporte.

Hoy bq me ha sorprendido. Mi tablet, que tiene ya mas de 2 años desde que la compré, se ha descargado una actualización.

En fin, recuperó la confianza en la marca española.



domingo, 24 de diciembre de 2017

Auriculares Logitech Headset USB H340 en Elementary OS Loki: conectar y listo



Hace unos años que compré estos auriculares USB con micrófono, y por aquel entonces costó lo suyo que lo detectara Kubuntu Linux.

Hoy, los he necesitado para un trabajo de innovación con la ULL y me ha soprendido gratamente la evolución permanente del sistema operativo del pingüino con el reconocimiento de hardware. Ha sido conectar y listo.

Detección y pruebas del micrófono integrado



Detección y pruebas de los auriculares



Por si te diera algún problema, te dejo un enlace a lo que tuve que hacer hace unos años para que los reconociera:



viernes, 22 de diciembre de 2017

Domótica/Inmótica con Arduino en Sistemas integrados y hogar digital: Maquetas 2017/18


Éste es el tercer año que usamos Arduino en el módulo profesional de Sistemas Integrados y Hogar Digital del 2do curso del CFGS de Sistemas de Telecomunicaciones e Informáticos.

Un año más, sigo aprendiendo de los estudiantes, a los que les propongo la automatización de una instalación doméstica haciendo uso de la plataforma Arduino y, en grupos, tienen libertad absoluta para elegir su diseño y sus funcionalidades.



Grupo 1: Adara, Elías y Esteban
Este grupo ha hecho un grandísimo esfuerzo no sólo en la componente electrónica de la instalación, sino también en la infraestructura física.

La maqueta en sí misma tiene un acabado muy muy logrado, con un enorme parentesco con el mundo real. Se han preocupado de incluir mobiliario, de camuflar el cableado en el interior de los muros, de mimetizar los elementos electrónicos como sensores y actuadores entre el mobiliario del domicilio,...

A nivel de automatización, ya tienen implementada las siguientes funcionalidades:

  • Iluminación por zonas
  • Control de toda la instalación por telemando Infrarrojos
  • Alarma de intrusión por detección de movimiento y activación retardada
  • Desconexión del sistema de alarma desde el telemando
  • Sistema de elevación de pantalla de TV para home-cinema

Los componentes electrónicos que han empleado en la instalación son:
  • Sensor IR, para control de la instalación desde el telemando
  • Sensor de movimiento y zumbador, para la alarma de intrusión
  • Leds y pulsadores para la iluminación por zonas
  • Servomotor para el sistema de elevación de pantalla de TV para su home-cinema


Detalles constructivos de la maqueta



Gran nivel de acabado en los elementos constructivos de su maqueta



Vista del cuarto que contiene la electrónica de automatización



Vista lateral de toda su maqueta




Grupo 2: Adrián, Airam y Cristo
Este grupo ha realizado una instalación domótica/inmótica con un elevadísimo nivel de automatización.

A nivel constructivo, han empleado madera para la maqueta, lo cual dificulta tremendamente las tareas de montaje, pero ofrece una instalación robusta, rígida y duradera.

Las funcionalidades que han incorporado en su instalación son:

  • Apertura de puerta de garaje
  • Riego automático del jardín mediante electroválvulas
  • Control de la instalación desde el teléfono móvil.
  • Optimización en la orientación de placas fotovoltáicas para la captación de energía solar
  • Control automático de temperatura para la incubación de huevos de crías de lagarto, con sistema de cuenta atrás en caso de superar el umbral de temperatura máxima admitida y alarma, refrigeración mediante ventilación y calefacción mediante resistencias. Visualización en pantalla del estado de la incubadora en todo momento.
  • Monitorización de la instalación con rotación automática de cámara captadora de imágenes.



Los componentes electrónicos empleados son:

  • Motor de giro continuo, relés, fuente de alimentación de PC, finales de carrera para el sistema de apertura de la puerta de garaje
  • Electroválvulas y relés en el sistema de riego automático
  • Uso de appInventor y módulo de recepción/transmisión bluetooth para el control de la instalación desde el teléfono móvil
  • Foto-resistencia y servomotor en la optimización de la orientación de placas fotovoltáicas.
  • Leds, ventilador de CC, visualizador 7 segmentos, zumbador y pantalla LCD en la incubadora de huevos de crías de lagarto.
  • Servomotor para la monitorización de la instalación con cámara captadora de imágenes.

Además de lo anterior, en esta instalación se ha hecho un gran esfuerzo por la colocación óptima de los sistemas de suministro de corriente y conectores, facilitando así la puesta en servicio, el mantenimiento y la localización de averías de la instalación.




Vista en primer plano del sistema de monitorización 
de la instalación mediante cámara captadora de imágenes



Vista en primer plano de la puerta de garaje de la instalación.



Vista en primer plano de la zona destinada a jardín 
con riego automático por electroválvulas



Vista en primer plano de la fuente de alimentación de PC
utilizada para el suministro de energía a los componentes de la instalación



Vista de detalle de la fuente de alimentación de la instalación

miércoles, 13 de diciembre de 2017

Elementary OS: 1 año de uso y la Wifi NO falla



Hace ya algo más de un año que comencé a usar Elementary OS. En aquel momento pensé:

  • "En unas semanas me aburriré de eOS"
  • "No creo que vaya muy bien"
  • "Ubuntu es mucho mejor"
  • ...
Creí que sería un tema fugaz, que rápidamente descubriría que es un sistema débil, poco maduro, frágil,... Pues no. Va realmente muy muy bien. En el mismo ordenador he probado otros sistemas: Ubuntu, Kubuntu, Lubuntu,... todos, absolutamente todos, me han dado muchos problemas con la tarjeta de red inalámbrica de mi portátil, y Elementary, ni uno. Nunca falla la conexión, va siempre bien. No he tenido que hacer mil y un scripts para conseguir que la Wifi no se corte.

Y en general, el sistema va de maravilla: rápido, fluido, liviano,... y con una interfaz gráfica realmente muy muy atractiva.

lunes, 11 de diciembre de 2017

Frases célebres: Ser pobre y estudiar

Cuando se nace pobre,
estudiar es el mayor acto 
de rebeldía contra el sistema

El saber rompe las cadenas
de la esclavitud


Elementary OS: Script para mostrar escritorio con atajo de teclado

Una de las cosas que me chirrían de Elementary OS es que no tenga la opción de utilizar un atajo de teclado para mostrar el escritorio. Es cierto que en el dock que incluye por defecto hay un acceso directo al escritorio, pero no he visto una forma sencilla de activarlo desde teclado. Me he acostumbrado a que la tecla <Súper>+D me muestra el escritorio, y si vuelvo a pulsarla, me devuelve las ventanas a su aspecto original.

Lo he resuelto con un script en bash que utiliza las siguientes herramientas de XWindows:
  • wmctrl
  • xwininfo
  • xdotool


Lo primero será por tanto instalar estas herramientas en tu sistema Elementary OS:
  • sudo apt install wmctrl
  • sudo apt install xwininfo
  • sudo apt install xdotool


¿Qué hace cada una de ellas?


wmctrl -d: relación de escritorios virtuales

wmctrl -d nos muestra una línea por cada uno de los escritorios virtuales que tenemos. En mi caso tengo 4 escritorios virtuales. Fíjate que marca con un asterisco (*) el que está activo. En la imagen anterior se ve que el escritorio 0 es el que está activo ahora


wmctrl -l: ventanas activas en mi sistema
wmctrl -l nos muestra una línea por cada ventana activa en el sistema.
Veamos campo por campo el sentido de cada línea:

  1. El primer campo es el ID de la ventana
  2. El segundo campo es en qué escritorio virtual se encuentra la ventana. Fíjate que -1 es un escritorio no existente.
  3. El tercer campo es el nombre del PC
  4. El cuarto campo es el nombre de la ventana.

xwininfo: ¿Está la ventana x minimizada?
Esta herramienta me permite obtener información de detalle de una determinada ventana. Por ejemplo, ¿está minimizada?
Básicamente funciona así: xwininfo -id <idventana>
Donde, idventana es el ID que nos devuelve wmctrl.

xdotool: realizar acciones sobre una ventana
xdotool me permite realizar acciones sobre una ventana concreta:
  • maximizar
  • minimizar
  • restaurar
  • asignarle el foco, es decir, pornerla en primer plano y marcarla como activa


Básicamente, lo que hace mi script es:

  1. Contar el número de ventanas visibles del escritorio actual
  2. Si n_ventanas_visibles > 0 entonces, minimizar todas
  3. Si no, restaurar todas las ventanas del escritorio activo

Con un pequeño matiz, cuando minimizo todas, guardo en un fichero temporal cuál es la ventana activa en ese momento. Esto me permitirá que, si vuelvo a restaurar las ventanas, se vuelva a marcar como activa aquella en la que yo estaba trabajando.

A este script yo lo he llamada mDesktop.sh. Para asignarle un atajo de teclado, sencillamente configuro los atajos de teclado personalizados en Elementary OS:


A continuación te muestro el código completo del script:


#!/bin/bash
mute=1

Program=$@
program_workingDir=`dirname $(readlink -f $0)`
status_fname="$program_workingDir/.mdesktop_status"
program_systemWindows="$program_workingDir/.mdesktop_systemWindows"

n_visible=0
window_id=0
window_name=""
window_hidden=0
window_isignorable=0
window_vd=0 #vd means virtual desktop
vd_activeId=0

#-----------------------------------------------------------------------------------------------
function debug() {
if [[ $mute == 0 ]]
then
echo "DEBUG: $1"
fi
}
#-----------------------------------------------------------------------------------------------
function vd_getActiveId() {
local vd_id=-1
local vd_status="-"

while read vDesktop
do
vd_id=`echo "$vDesktop" | tr -s ' ' | cut -f 1 -d " "`
vd_status=`echo "$vDesktop" | tr -s ' ' | cut -f 2 -d " "`

if [ "$vd_status" == "*" ]
then
echo $vd_id
break
fi
done < <(wmctrl -d)
}
#-----------------------------------------------------------------------------------------------
function isSystemWindow() {
local window_isSystem=0
window_isSystem=$(grep "$window_name" $program_systemWindows | wc -l)
echo $window_isSystem
}
#-----------------------------------------------------------------------------------------------
# window_activeId
# Window id which actually is focused, it is, the one which is active
# This value will be saved in .desktop_status so it can be restored
#-----------------------------------------------------------------------------------------------
function windows_minimize_all() {
local window_activeId=-1
debug "windows_minimize_all..."

window_activeId=$(xdotool getactivewindow)
echo "$window_activeId" > $status_fname
while read Window
do
window_name=`echo "$Window" | tr -s ' ' | cut -f 4 -d " "`
window_id=`echo "$Window" | tr -s ' ' | cut -f 1 -d " "`
window_vd=`echo "$Window" | tr -s ' ' | cut -f 2 -d " "`

if [[ $(isSystemWindow $window_name) == 1 ]]
then
debug "NOT minimize $window_name: system window"
continue
fi
if [[ $window_vd != $vd_activeId ]]
then
debug "NOT minimize $window_name: in another desktop"
continue
fi

debug "MINIMIZE $window_name"
xdotool windowminimize $window_id
done < <(wmctrl -l)
}
#-----------------------------------------------------------------------------------------------

function windows_restore_all() {
while read Window
do
window_name=`echo "$Window" | tr -s ' ' | cut -f 4 -d " "`
window_id=`echo "$Window" | tr -s ' ' | cut -f 1 -d " "`
window_vd=`echo "$Window" | tr -s ' ' | cut -f 2 -d " "`

if [[ $(isSystemWindow $window_name) == 1 ]]
then
debug "NOT RESTORE $window_name: system window"
continue
fi
if [[ $window_vd != $vd_activeId ]]
then
debug "NOT RESTORE $window_name: in another desktop"
continue
fi

xdotool windowactivate $window_id
done < <(wmctrl -l)
# Set focus to the window was active before minimizing all
window_activeId=$(cat $status_fname)
debug "SETTING FOCUS TO: $window_activeId"

xdotool windowactivate $window_activeId
}
#-----------------------------------------------------------------------------------------------
debug "###############################################"
debug "###############################################"
debug "# MAIN  ##########################################"
debug "###############################################"
debug "###############################################"

vd_activeId=$(vd_getActiveId)
debug "current virtual desktop=$vd_activeId"

while read Window
do
debug "-----------------------------------------------------------------------"
debug "$Window"
window_id=`echo "$Window" | tr -s ' ' | cut -f 1 -d " "`
window_vd=`echo "$Window" | tr -s ' ' | cut -f 2 -d " "`
window_name=`echo "$Window" | tr -s ' ' | cut -f 4 -d " "`
window_hidden=`xwininfo -all -id $window_id | grep "Hidden" | wc -l`
window_isignorable=$(isSystemWindow $window_name)
debug "Window Id: $window_id"
debug "Window vd: $window_vd"
debug "Window Hidden: $window_hidden"
debug "Window Name: $window_name"
debug "Window is system: $window_isignorable"

# is current window an ignore Window?
if [[ $window_isignorable == 1 ]]
then
debug "Ignore actual Window"
continue
fi

# is current active virtual desktop?
if [[ $window_vd != $vd_activeId ]]
then
debug "Ignore actual Window: in another desktop"
continue
fi

# Is there any visible window?
if [[ $window_hidden == 0 ]]
then
debug "show_desktop"
let n_visible++
fi
done < <(wmctrl -l)


# We must exec every window and minimize or maximize, depending wether it was already minimized or not
debug "###n_visible = $n_visible"
# windows_restore_all
if [[ $n_visible == 0 ]]
then
debug "restore all windows"
windows_restore_all
else
debug "minimize all windows"
windows_minimize_all
fi


Fuentes:

miércoles, 29 de noviembre de 2017

FreeFileSync en Elementary OS Loki: sincronización de carpetas entre mi PC y mi pen drive



En mi día a día trabajo con multitud de PCs: el de casa y uno por cada aula en la que doy clase. No es trivial mantener sincronizados los datos en todos estos PCs, de modo que lo que haga en casa se actualice en el PC1, en el PC2,... y viceversa.

Una solución que hemos hecho todos alguna vez es tener un pen drive con todos los archivos de casa, pero claro, luego llegas al trabajo, haces un cambio en algún archivo, y en casa modificaste otro, pero es que en trabajo también lo modificaste,... total, que ya no sabes cuál es el bueno, si el de casa o el del pen drive,... ¡¡¡¡ahhhh!!!! Al final, siempre terminas perdiendo algún archivo clave.

La idea de FreeFileSync es que este software, de forma automática, compara dos carpetas y añade, quita y modifica de cada una lo que falta, lo que sobra o lo que sencillamente ha variado respectivamente, tomando siempre la versión más reciente.

Es una especie de Git, o de Subversion, pero para mantener sincronizadas dos carpetas.
En mi caso lo usaré para mantener sincronizado mi PC con mi pen drive.
Haré algo parecido a lo que hace Dropbox: tendré una carpeta que llamaré Trabajo, y esa carpeta la tendré en el PC de casa, en el pen drive, y en cada uno de los equipos que uso en el trabajo. 

Lo bueno de FreeFileSync es que, además de ser software libre, es multiplataforma. Así que en el instituto, que lo que hay es Windows, se sincronizará sin problemas con mi PC que es Linux. Así que instalaré FreeFileSync en todos los equipos y tendré que acostumbrarme al final de cada día a hacer una sincronización PC del trabajo -> USB -> PC de casa y viceversa.



Accedemos a la web de FreeFileSync en 



Bajo la sección Downloads, elegimos nuestro sistema operativo
En mi caso, Ubuntu 16.04 que es en la que se basa Elementary OS



Aspecto de la página principal de FreeFileSync



FFS sincronizando archivos

jueves, 23 de noviembre de 2017

La versión de Cisco Packet Tracer para Android es brutal



Hace ya un tiempo que instalé CPT en Android, pero por aquel entonces yo me imaginé que sería una versión descafeinada, incompleta, una especie de CPT--, en la que no estuvieran todas las funcionalidades que hay para la versión PC.


Guión de valoración de un lab de Cisco



Pues bien, la he estado usando, me he descargado unos cuantos labs de Cisco y los he podido resolver completamente en mi tablet Android.
Aún no he encontrado nada que no funcione y además es realmente cómoda la interfaz que han propuesto para trabajar sin ratón, sino directamente pulsando sobre la pantalla.

Conexión por hiperterminal a un switch


La gran ventaja que le veo es que te permite estudiar y practicar redes tomando un cortado, al aire libre o en la playa, y no sentado en casa, en una habitación oscura y detrás de un teclado de ordenador.

Visión física de un switch Cisco Catalyst 2960




Aplicaciones de red del escritorio de un PC