RSS

Creando un gabinete casero

Cuando compré mi primera Raspberry me dí cuenta de inmediato de que necesitaría varias cosas para iniciar a trabajar con ella. Entre estas cosas una que aprendí que es un complemento obligado cuando tienes peques en casa (con mi iPad) es un gabinete o funda protectora. Pedí el gabinete pero no tenía planeado esperar los dos meses que tardaba en llegar por lo que me pusé manos a la obra en casa.

Viendo algunos gabinetes como este:

pi2243

Me puse a buscar alternativas de materiales.

  • Preguntando en una vidriería por acrílico me han dicho que solo tenían “plástico”, personalmente no le ví la diferencia y para lo que era me ha resultado perfecto. El molde ha sido mi mebresía de un club de precios.
  • En una casa del tornillo pedí unos tornillos con tuercas y ahí mismo encontré algo que le llaman “pernos” aunque no sé si sea el nombre correcto.

En la siguiente foto muestro de izquierda a derecha:

  1. La tarjeta Raspberry Pi
  2. Las tuercas
  3. Los tornillos
  4. Los pernos
  5. Las placas de plástico
  6. Unas “rondanas” hechas con el carton de una caja de cereal, estas se me han venido a la mente de las que traen las computadoras para evitar cortos circuitos.

IMG_20160212_104957_mini

A continuación me he hecho una plantilla del PCB para guiarme al momento de hacer las perforaciones, aunque debo confesar que en este punto he recordado un comentario “casi cualquier problemas que tengas alguien ya lo ha resuelto”, así que investigando en google he navegado por las siguientes ligas:

Raspberry Pi rev2 template with mounting holes

Raspberry Pi Mounting Hole Positions and Template

http://www.raspberrypi-spy.co.uk/wp-content/uploads/2012/11/Raspberry-Pi-Mounting-Hole-Template.pdf

Ya recortada la plantilla la he validado contra la placa física y posteriormente la he pegado a las placas de plástico para hacer las perforaciones necesarias y me he puesto a hacer los agujeros, acto seguido le quite el plastico que trae para evitar rayones. Al final quedo algo así:

IMG_20160212_105201_mini

Y ya con todo listo solo he tenido que ensamblar el gabinete, visto de perfil ha quedado así:

IMG_20160212_110542_mini

Un par de fotos más de como se ve terminado:

GabineteRPi_2_mini

GabineteRPi_1_mini

Como conclusión les he de decir que fuera del aspecto de los tornillos me ha dejado satisfecho la artesanía y es que la tarjeta por si sola da una sensación de fragilidad impresionante y tenía miedo de echarla a perder doblando algun pin o rompiendole algún componente. Con el gabinete ha cambiado drásticamente la confianza al manejar la tarjeta.

 
Deja un comentario

Publicado por en febrero 12, 2016 en RaspberryPi

 

Conociendo la Raspberry Pi

La Rasperry inicio como un proyecto para generar computadoras de bajo costo y de esta manera hacer que el cómputo estuviera más cerca de un mayor número de gente. Como objetivo alterno estaba tener una plataforma para entusiastas.

El PCB (Printed Circuit Board, o tarjeta de circuito impreso) tiene el tamaño de una tarjeta de crédito. En la siguiente imagen se muestra una Raspberry Pi 2:

IMG_20160205_125054_ComparativaTC

Los elementos básicos que debemos de conocer e identificar son los siguientes:

  1. Puerto de alimentación
  2. Salida HDMI
  3. Conector de video compuesto/audio
  4. Puertos USB
  5. Puerto ethernet
  6. Lector de tarjeta Micro SD (al reverso en la fotografía)
  7. Leds indicadores
  8. GPIO

IMG_20160205_113513_ConNumeros

Con los puertos anteriores podemos conectar lo básico para tener una computadora funcional. Sin embargo una de las características más atractivas de la Raspberry es que puede ser utilizada en proyectos de electrónica con lo que llaman “computación física”, básicamente se refiere a controlar elementos externos como sensores (de humedad, movimiento, procimidad, etc.), leds, motores, etc. desde la Raspberry. Para llevar a cabo este tipo de proyectos cuenta con los pines conocidos como GPIO (General Purpose Input/Output, puertos generales de entrada/salida). Se muestran en la siguiente imagen los pines GPIO de la Raspberry Pi 2:

IMG_20160205_113513_GPIO

A mi parecer esto es lo básico que debemos conocer sobre las partes de la Raspberry Pi, sin embargo existen otras adicionales que en proyectos avanzados será importante conocer, por ejemplo, ayer me he enterado que existe al menos una manera adicional para alimentar la tarjeta esto es aparte del puerto mostrado.

Antes de iniciar a trabajar con la Raspberry Pi en lo personal he buscado proteger la tarjeta ya que la tarjeta viene desnuda, sin ningún gabinete que lo proteja. En el siguiente post mostraré como lo he protegido con un pequeño gabinete que he hecho de forma casera.

 
Deja un comentario

Publicado por en febrero 9, 2016 en RaspberryPi

 

Librería de logging para shell

Para diversos proyectos he tenido la necesidad de crear una librería de logging para bash.

Para quienes no están muy familiarizados con el tema les platicaré un poco. Una librería de logging nos permite gestionar de una manera sencilla y muy controlada los mensajes de una aplicación.

En español, pensemos en un programa escrito en C que utiliza punteros, no somos muy buenos en ello y estamos teniendo un error de segmentación el cual a veces termina en un lugar a veces termina en otro, en fin uno de esos que hay que andar cazando y nos hacen arrancarnos los cabellos. Comúnmente estaríamos poniendo mensajes en el programa para ir cercando el problema y una vez que lo hemos encontrado retiraríamos estos mensajes para liberar el programa a producción. El problema y lo frustrante sucedería cuando aparezca un nuevo error y nos veamos obligados a poner/quitar los mensajes.

¿Que sucedería si siempre estuvieran ahí los mensajes? Imaginemos que ponemos los mensajes y que estos siempre están ahí pero que el programa (o la librería de logging) es lo suficientemente inteligente para saber que mensajes debe de mostrar dependiendo de si lo están corriendo en producción o en desarrollo. Sería muy práctico.

El concepto es muy sencillo:

  1. Se definen varios niveles de mensajes. Los mensajes críticos están en un extremo de la escala, son mensajes que se deben de mostrar siempre sin importar en que ambiente se encuentre, los mensajes de debug están en el otro extremo y solo deben de ser visibles cuando se esté trabajando en un ambiente de desarrollo o bien uno productivo pero se esté realizando la detección de un caso de error.
  2. Se definen varias funciones para mandar los mensajes según el nivel. Comúnmente siempre lo hacemos con un printf en el caso de C, con la librería de logging tendríamos por ejemplo log_critical, log_debug. Es necesaria una función por cada nivel.
  3. En el programa se debe de inicializar la librería de logging. Esto es como mínimo especificar el nivel de los mensajes que se desean mostrar aunque algunas librerías muy sofisticadas pueden realizar otras tareas.
  4. En el programa se debera de utilizar las funciones de la librería para enviar los mensajes que se desee cuidando de usar el nivel apropiado para el mensaje.

Para muestra les dejo la librería de logging que tengo actualmente para bash. Se encuentra muy básica pero espero poco a poco irla creciendo según las necesidades.

 

#!/bin/bash

#Constantes para imprimir el nivel de log en los mensajes
LOG_DEBUG_MSG_LEVEL=DEBUG
LOG_INFO_MSG_LEVEL=INFO
LOG_WARN_MSG_LEVEL=WARN
LOG_FATAL_MSG_LEVEL=FATAL

#Constantes para los niveles de logging
LOG_LEVEL_DEBUG=1
LOG_LEVEL_INFO=2
LOG_LEVEL_WARN=3
LOG_LEVEL_FATAL=4

#Inicializaciones
LOG_LEVEL=$LOG_LEVEL_INFO

log_log(){
local PARM_NIVEL=”$1″
local PARM_MSG=”$2″

printf “[%-5s] %s\n” “$PARM_NIVEL” “$PARM_MSG”

}

log_debug(){
local PARM_MSG=”$1″

if [ $LOG_LEVEL_DEBUG -ge $LOG_LEVEL ] ; then
log_log “$LOG_DEBUG_MSG_LEVEL” “$PARM_MSG”
fi
}

log_info(){
local PARM_MSG=”$1″

if [ $LOG_LEVEL_INFO -ge $LOG_LEVEL ] ; then
log_log “$LOG_INFO_MSG_LEVEL” “$PARM_MSG”
fi
}

log_warn(){
local PARM_MSG=”$1″

if [ $LOG_LEVEL_WARN -ge $LOG_LEVEL ] ; then
log_log “$LOG_WARN_MSG_LEVEL” “$PARM_MSG”
fi
}

log_fatal(){
local PARM_MSG=”$1″

if [ $LOG_LEVEL_FATAL -ge $LOG_LEVEL ] ; then
log_log “$LOG_FATAL_MSG_LEVEL” “$PARM_MSG”
fi
}

 

El núcleo de la librería es la función log_log, lo único que hace es imprimir formateado el mensaje. Alrededor de ella se cosntruyen 5 funciones que actúan como wrappers(envolventes) que lo que hacen es validar si el mensaje se debe de escribir o se desecha, comparando el nivel de esa función contra la variable $LOG_LEVEL, en caso de imprimirse se llama a la función log_log enviándole el nivel de log que se está procesando para que lo imprima apropiadamente.

Una manera de utilizarla sería la siguiente:


#Importar la libreria de log
source $COMMON_SCRIPTS_DIR/logger.sh

LOG_LEVEL=$LOG_LEVEL_DEBUG
log_info “Hola soy info”
log_debug “Hola soy debug”
log_debug “Hola soy debug!!!”

Primero se “importa” la librería (la línea source), posteriormente se configura el nivel deseado (la asignación a la variable LOG_LEVEL), y finalmente se utiliza (invocación a las funciones log_info y log_debug).

En fin, algo adicional que se le pudiera hacer es:

  • Imprimir el nivel de los mensajes con colores (Rojo para crítico y azul para debug p. ej.,
  • Imprimir la hora del mensaje para tracear el tiempo en que ocurre cada cosa.
  • Hacer que los mensajes persistan enviandolos a un archivo.
  • Enviar mensajes al syslog.

Por el momento es todo, espero les sea de utilidad.

 
Deja un comentario

Publicado por en febrero 4, 2016 en Bash, RaspberryPi, unix

 

Iniciando sección sobre Raspberry Pi

Bueno, actualmente tengo demasiado tiempo de sobra en el trabajo, y necesito invertirlo en hacer algo productivo.

Recientemente un amigo me invito a un curso de Robótica y me platicó que estaban trabajando con plataformas Arduino y Raspberry Pi. El lugar donde se imparte el curso me queda un poco lejos de casa y con mis peques no me queda mucho tiempo para gastar en traslados por lo que inicié a leer un poco del tema para evaluar lo que podría contener de interesante. Mi conclusión ha sido que no valía la pena hacer el traslado pero si iniciar a probar la tecnología… me compré una Raspberry Pi.

El hardware me ha sorprendido pues lo he comprado por $39 USD, de lo que veo bastante remarcable en el:

  • Tiene salida HDMI
  • Tiene 1gb de memoria (para correr un linux es bastante decente)
  • Tiene puerto ethernet
  • Tiene salida de video compuesto y audio
  • Utiliza como fuente de alimentación un puerto micro usb (si, de los que usan los celulares)
  • Requiere de una potencia para operar mìnimo de 750mAh
  • Tiene un lector de micro-sd

Repito por $39 USD, solo requiero conectarle un teclado, mouse, cargador de celular (smartphone preferentemente) y una TV, conesto tengo una computadora.

El sistema operativo que le he cargado es Raspbian. Su desempeño en el arranque es bastante fluido y trabajando he podido realizar tareas bastante normales para mi empleo actual de administrador de sistemas Tuxedo.

Su desempeño en el uso diario para una persona normal es bastante decente, he podido navegar, programar y mis peques jugaron un tiempo Minecraft.

En fin que el juguete es bastante interesante, creo que se presta para fantasear demasiado. Por eso es hora de iniciar con estos posts:

  1. Conociendo la Raspberry Pi
  2. Creando un gabinete casero
  3. Instalando Raspbian
  4. Práctica #1: Y se hizo la luz: encendido de un led
  5. Práctica #2: Al infinito y más allá: monitoreo de cámara ip
 
Deja un comentario

Publicado por en febrero 4, 2016 en RaspberryPi

 

Manual de Unix, secciones

Viendo mi último post he recordado algo bastante útil del manual de Unix: está organizado en secciones.

La mayoría de las personas cuando empeamos a utilizar man lo usamos a diestra y siniestra sin saber de las secciones, es decir:

man comando

El origen de man es el manual impreso de Unix el cual como muchos libros está organizado en secciones, por lo que si las sabemos utilizar nos podemos ahorrar algunos problemas al momento de buscar en él. Por ejemplo al buscar ayuda sobre printf nos mostraría lo siguiente:

Selection_003

Pensando que queremos saber como usar la función printf en ANSI C, podemos ver que no nos indica lo que buscamos, sin embargo en la parte superior podemos ver que el número encerrado entre paréntesis junto al nombre del comando es un 1, se refiere a que es la sección 1 “Comandos generales”. Las secciones disponibles son las siguientes:

1.- Comandos generales

2.- Llamadas al sistema

3.- Funciones de librerías

4.- Archivos especiales

5.- Formatos de archivo y convenciones

6.- Juegos y salvapantallas

7.- Miscelànea

8.- Comandos de administración de sistemas y demonios

Si lo que buscamos en información en un contexto de programación comúnmente estaremos ocupando las secciones 2 y 3. En nuestro ejemplo anterior lo que deberíamos hacer es solicitar que nos muestre la información de la sección 3, esto lo hacemos indicando el número 3 antes de indicar el nombre del comando, de la siguiente manera:

man 3 printf

Y nos debe de producir la siguiente salida:

Selection_004

Como podemos observar el título a cambiado a Manual de programadores y la información especificada es acorde a lo que buscamos.

Practiquen y jueguen un poco con este parámetro. Espero les sea de utilidad.

 
Deja un comentario

Publicado por en febrero 4, 2016 en unix

 

Manual de Unix

Documentando un shell me pidieron que la “ayuda” se desplegará como con el comando man, no igual porque seguro era muy difícil, sin embargo al menos formatear un documento de texto con secciones similares a las que muestra el comando.

Como siempre corrí a AWK, sin embargo ya encarrerado me detuve a pensar porque no verificaba como hacerlo bien.

http://upload.wikimedia.org/wikipedia/commons/d/db/Unix_manual.png

Descubrí que man tiene la opción -a la cual hará que me muestre todo lo que encuentre del comando, al introducir

man -a man

Me informó de la sección 7(miscelánea), en ella me habla de como formatear un archivo para man, es muy sencillo al menos para lo básico. El resultado por el momento es el siguiente:

 
Deja un comentario

Publicado por en febrero 24, 2014 en Uncategorized

 

Curso de AWK 1a. parte – Introducción

Con esta entrada daré inicio a un mini cursillo dell lenguaje AWK. La pregunta inicial podría ser porque AWK.

La primera vez que escuché que AWK era un lenguaje de procesamiento de patrones mi mente voló demasiado, hoy en día entiendo mejor esta descripción y recordando mi confusión inicial es que escribo esta entrada.

Pero porque aprender AWK?

La primera razón que se me ocurre es el hecho de que es un lenguaje muy pequeño, lo cual permite dominarlo en un tiempo relativamente corto, con un poco de práctica creo que es factible en una semana (si ya se tienen bases de programación) estar haciendo scripts sencillos de manera fluída y con algo más de dedicación en un par de meses puede uno encontrarse por encima del promedio de desarrollo.

El otro motivo de peso que me empuja es que es un lenguaje realmente poderoso para hacer ciertas tareas de manera sencilla y aún así muchas personas no pueden explotarlo de manera correcta.

Mi idea es brindar estas entradas de la manera en que yo fuí aprendiendo el lenguaje, es decir, primero aprenderlo mal y poco a poco aprenderlo bien, por lo que pido una disculpa si alguien ve que cometo algunos errores, solo considere que en su momento así entendí las cosas y eventualmente mejoré varios aspectos de mi desarrollo.

Historia
AWK fue originalmente desarrollado por Aho, Weinberger y Kernigan, posteriormente al ver las capacidades del lenguaje se crearon las versiones NAWK y GAWK las cuales agregaron nuevas características al lenguaje. Al final sirvió como base para la creación de Perl. actualmente podemos encontrar versiones para las principales plataformas y el proyecto GNU mantiene una versión que puede correr en Windows.

Instalación
Si te encuentras en un ambiente Unix es muy probable que ya cuentes con AWK instalado, recomendaría solo validar si se encuentra instalado GAWK, para ello ejecuta en una terminal:


gawk --version

En caso de que no se muestre la versión de GAWK intenta instalarlo con el gestor de paquetes de tu distribución.

Si te encuentras en Windows puedes decargarte GAWK desde la página del proyecto GNU. Otra opción es instalar Cygwin lo cual veo un poco engorroso si solo se quiere utilizar GAWK. La tercera opción es descargar MobaXTerm una aplicación que encapsula Cygwin en un solo ejecutable y que permite traerlo en una memoria usb y utilizarlo donde sea, lo puedes encontrar aquí.

Primeros pasos
La idea de los scripts de AWK es simple, tomar una entrada, típicamente un archivo, y leer de ella los registros (por defecto se delimitan por retorno de línea), por cada registro leído se ejecutara un conjunto de acciones(el cuerpo del script). Tiene un par de secciones especiales que nos permiten ejecutar instrucciones antes de procesar cualquier cosa y/o al final de procesar todo, si se está identificado con la POO yo lo asimilo con un constructor y un destructor.

Estructura
Aunque no sea correcto lo que a continuación diré, si facilitará el entendimiento inicial del lenguaje.
Para introducirnos en el manejo de scripts de AWK es importante entender como debemos estructurar un script:

BEGIN{
#Inicializacion
}
{
#Procesamiento principal
}
END{
#Procesamiento al finalizar
}

Lo primero que vemos en el script es la palabra BEGIN seguida de un bloque (en AWK los bloques de código se delimitan por medio de llaves), esto sirve para indicar que el bloque es el que se debe de ejecutar inmediatamente que se inicie la ejecución del script, incluso antes de leer el primer registro a procesar.
Despues del bloque BEGIN vemos que viene otro bloque que no esta precedido por ninguna palabra esto indica (por el momento) que es el bloque a ejecutar para cada registro que se lea y procese.
Por último vemos la palabra END seguida de un bloque, lo cual indica que el codigo que se encuentra dentro es el que se ejecuta una vez que se han procesado todos los registros de entrada.

Un script básico puede ser:


BEGIN{
print "Inicio del ejemplo"
}
{
print $0
}
END{
print "Fin del ejemplo"
}

Guardemos el script en el archivo ejemplo01.awk y creemos el archivo entrada.txt con el siguiente contenido:

aaa
bbb
ccc

Ahora ejecutemos el script de la siguiente forma:

awk -f ejemplo01.awk entrada.txt

Un detalle a notar aquí es que estamos utilizando la variable $0, es una variable muy especial ya que contiene el registro completo tal como fue leído de la entrada. Si deseáramos acceder a los campos del registro podemos hacerlo con las variables $1, $2, …, $NF donde NF es una variable especial que contiene el número de campos existentes en el registro actual, esto se debe a que se tener una cantidad variable de campos entre cada registro (:o).

Con esto hemos aprendido prácticamente lo básico de AWK oO. Esto se debe a que cuenta con un conjunto de funciones muy básicas, para darte una idea te recomiendo que tengas a la mano el Cheat Sheet de Peteris Krumis disponible aquí, en el hace un excelente trabajo en recabar información de AWK, muestra las variables predefinidas, opciones de línea de comando y funciones disponibles en el lenguaje.

A continuación haremos solo un breve recorrido por las variables especiales de AWK y terminaremos con algunos ejemplos:

FS Especifica el caracter (en GAWK permite una expresión regular) delimitador de campos
OFS Especifica el caracter delimitador de campos al imprimir el registro completo
$0 El registro completo
$1, $2, … Los campos contenidos dentro del registro actual
NR Número de registro actual procesado por el script
FNR Número de registro actual del archivo en curso
FILENAME El nombre del archivo del cual se está leyendo actualmente la entrada

 
Deja un comentario

Publicado por en agosto 25, 2011 en Uncategorized