Programación

  • Aprendiendo a programar con Python 3

    Taller orientado a personas que no tengan experiencia previa en programación y deseen aprender utilizando un lenguaje potente y fácil de aprender como lo es Python 3.

    ¿Cuándo?: Miércoles 11 de Mayo de 3 pm a 5 pm

    ¿Dónde?: Vivelab Bogotá Av el dorado carrera 45 No 26 – 33

    Entrada libre, para participar inscríbete en:
    https://www.eventbrite.es/e/entradas-aprendiendo-a-programar-con-python-3-24751321870

     

    ChpOkp2W0AA Rp

  • Instalando Django 2.0 en Ubuntu Linux 16.04 LTS

    python

     

    El pasado 2 de Diciembre fue liberada la version 2.0 de Django, Framework para desarrollo web escrito en Python.

    Es por esto que en OpenSAI nos dimos a la tarea de hacer un pequeño resumen de como instalarlo de manera facil en nuestro Ubuntu Linux 16.04.

    Antes de instalar Django verificamos cumplir los requerimientos mínimos del sistema.

    Para la version 2.0 es nesario contar con Python 3.5 instalado.

    Luego Procedemos a instalar pip3

    1 - Como súper usuario ejecutamos:

     

    :~$ apt install python3-pip

     

    2 - Una vez instalado pip procedemos a actualizarlo a la ultima versión disponible

     

    $source djangoprojects/bin/activate

    :~$ pip3 install -U pip

     

    3 - Una vez actualizado pip procedemos a instalar como súper usuario el virtualenv para ejecutar las aplicaciones Django de forma independiente al python del sistema.

     

    :~$ pip3 install virtualenv

     

    4 - Una vez instalado correctamente el virtualenv procedemos a crear el directorio donde se alojara la instancia virtual de python.

     

    :~$virtualenv ENV

     

    5 - A continuación procedemos a activar el ambiente virtual de python con el siguiente comando

     

    :~$source djangoprojects/bin/activate

     

    6 - Sabremos que el entorno virtual esta activado cuando veamos que antes del nombre de nuestra terminal aparece el nombre de nuestro ambiente virtual entre paréntesis, ejem: (djangoprojects) [email protected]:~$

    7 - Para salir del entorno virtual simplemente ejecutamos el comando:

     

    :~$ deactivate

     

    8 - Finalmente procedemos a instalar Django en nuestro entorno virtual.

     

    :~$ pip3 install Django

     

    9 - Una vez instalado Django procedemos a comprobar que en efecto la instalación fue exitosa, ejecutando el siguiente script desde el interprete de python.

    :~$python3

     

    >>> import django

    >>> print(django.get_version())

     

    Finalemente al ejecutarlo deberemos de obtener el numero de la versión de Django que acabamos de instalar.

     

    TerminalDjgo

     

     

  • Pomodoro en Bash en menos de 100 líneas (newbies)

    Cuando se tienen muchas cosas que hacer, a veces no se sabe por donde empezar, se arma un interbloqueo y hasta aparece la procrastinación. Una técnica de trabajo que apoya esa situación es la del Pomodoro. Se fraccionan las tareas en ciclos de al menos 25 minutos (divide y vencerás), donde se ejecuta sólo una tarea, con toda la concentración del mundo (está demostrado que el multitasking en los seres humanos es puro cuento...bueno las mujeres pueden hacerlo, pero no es la norma 😜😇). Al finalizar el día si se hace responsablemente la labor, el nudo comenzará a simplificarse, desde luego conviene llevar un registro, lo que en sistemas de software sería un log.

    Hay una infinidad de aplicaciones para trabajar Pomodoro, sin embargo, por puro placer y como ejercicio práctico para el aprendizaje de Bash y conceptos básicos de programación, publicamos un Pomodoro en menos de 100 líneas de código en Bash. Quién aprenda a manejar realmente este sistema de scripting y una Terminal Linux, tendrá una ventaja competitiva en los sistema industriales de software actuales.

    ChontoRunning

    Todo arranca con un comando básico y sencillito:

    sleep 1

    El comando sleep es nativo de la consola de Linux que nos detiene la ejecución de un script, en este caso precisamente por un segundo. Si se puede hacer eso podemos organizar un loop (ciclo repetitivo) que nos cuente hasta un minuto:

    for (( SECSCount=1; SECSCount<=60; SECSCount++ ))
    do
      tput clear
      print_timer " $(($MINS-$MINSCount)) Minutes " "$((60-$SECSCount)) Seconds to rest... " "$(tput lines)" "$(tput cols)"
      sleep 1
    done

    Se tiene un ciclo para 60 segundos, en cada paso se limpia la pantalla, se imprimen los minutos, segundos, no hay que dejarse despistar por tput que es un comando que permite manejar los parámetros de comportamiento de la terminal:

    tput lines retorna el número de líneas disponiblesn en la terminal actual
    tput cols retorna el número de columnas disponibles en la terminal actual
    tput clear limpia la pantalla
    tput bold coloca los caracteres de la terminal en negrilla
    tput cut Y X posiciona el cursor de la pantalla en la coordenada X, Y (filas, columnas)
    tput setaf cambia color del fondo del texto
    tput rev invierte el coloreado de los caracteres (color en fondo y no en las letras)
    tput sgr0 reinicia los parámetros de la terminal (si no se usa al terminar la ejecución, la terminal queda con otros colores...)
    tput civis oculta el cursor de la terminal
    tput cnorm muestra de nuevo el cursor

    y print_timer es una función creada al inicio del script para imprimir el reloj (el letrero en pantalla con los minutos y segundos...después la miramos), esta función recibe como parámetros encerrados en comillas dobles, el contador de los minutos, el contador de los segundos, el tamaño en filas y en columnas de la terminal. El objetivo es que el reloj siempre se presente en el centro de la pantalla.

    Cómo estámos contando el tiempo en reversa (si tenemos 25 minutos para el pomodoro, vamos hacia atrás hasta llegar a cero...), a 60 le restamos los segundos del contador y a los minutos totales, le restamos los minutos del contador de minutos de nuestro script (...así se hace un ciclo repetitivo for en bash...¡vamos! quién sepa programar en Bash no estaría leyendo este contenido, por eso lo aclaramos).

    Bueno, pero un minuto tiene 60 segundos, luego el anterior ciclo debería estar en otro externo para contar minutos y segundos:

    for (( MINSCount=1; MINSCount<=$MINS; MINSCount++))
    do
      for (( SECSCount=1; SECSCount<=60; SECSCount++))
      do
       tput clear
       print_timer " $(($MINS-$MINSCount)) Minutes " "$((60-$SECSCount)) Seconds to rest... " "$(tput lines)" "$(tput cols)"
       sleep 1
      done
    done

    El ciclo externo cuenta los minutos, el interno los segundos. $MINS es una variable que guarda el primer parámetro recibido desde la consola de Linux por nuestro script. 

    Hay que aclarar que en la terminal del sistema, nuestro script se ejecuta asi:

    ./chontoBash.sh NumMinutesToWork "My Task to work in double quotes..."

    el ./ le indica al sistema Linux que ejecute el script chontoBash.sh del directorio actual, NumMinutesToWork...simplemente es un número de minutos a contar, "My Task to work in double quotes..." es la tarea que se registrará como ejecutada. Entonces se reciben dos parámetros, que dentro del script se validan asi: 

    if [[ $# != 2 ]]; then
     tput bold; echo Error in arguments...; tput sgr0;
      echo
      print_help
      exit 1
    fi

    if ! [[ $1 =~ ^[0-9]+$ ]]; then
      tput bold; echo...how many minutes do you like to work?; tput sgr0;
      echo
      print_help
      exit 1
    fi

    Tenemos dos comparaciones, el primer if valida que desde la terminal de linux nos entreguen (2) dos parámetros, el segundo if valida que el primer parámetro sea un número entero. Son validaciones básicas, obviamente se pueden mejorar. Si ocurre alguna de las dos exepciones el programa termina con exit 1 (programa o script aquí son sinónimos...ya ves tú, estás programando en Bash).

    Una función en Bash se crea así:

    print_help (){
      echo USAGE FROM TERMINAL:
      echo ./chontoBash.sh NumMinutesToWork \"My Task to work in double quotes...\"
      echo If not exist, chonto will create the log file log.chonto, csv file to make data analytics:
      echo "TimeStamp, TotalMinutes, Task worked..., status: completed (FULL) or incomplete task (BREAK)"
      echo "TimeStamp, TotalMinutes, Task worked..., status: completed (FULL) or incomplete task (BREAK)"
      echo "TimeStamp, TotalMinutes, Task worked..., status: completed (FULL) or incomplete task (BREAK)"
      echo .
      echo .
      echo .
    }

    La ventaja es que para imprimir en pantalla todas estas líneas con el comando echo, una vez creada la función, sólo tengo que llamarla: print_helpcuántas veces quiera (el nombre de la función tu te lo inventas), esto ahorra trabajo, y mejora la organización del script.

    Las otras funciones del script son:

    log_chonto_break (){

      end_time=$( date '+%s' )
      echo $(date +"%F %H:%M:%S"), $((($end_time - $1) / 60)) Mins, "$2", BREAK >> log.chonto
      mplayer glass.ogg > /dev/null 2>&1
      tput clear
      echo "Unfinished task logged :("
      tput cnorm
      exit 1
    }

    log_chonto (){
      end_time=$( date '+%s' )
      echo $(date +"%F %H:%M:%S"), $((($end_time - $1) / 60)) Mins, "$2", FULL >> log.chonto
      mplayer glass.ogg > /dev/null 2>&1
      tput clear
      echo "Task finished logged :)"
    }

    print_timer (){
      #center the timer text, centering the cursor in Y/2:X/2-((text length)/2)
      tput cup $(($3/2)) $((($4/2)-($(expr length "$1 $2")/2)))
      tput bold; tput setaf $((1 + RANDOM % 10)); tput rev; echo "$1$2"; tput sgr0;
    }

    print_timer se encarga de centrar el cursor calculando primero el tamaño del reloj (cuántas letras tiene nuestro reloj para que quede centrada, verticalmente y horizontalmente), el RANDOM con el módulo es para jugar los colores de impresión en pantalla, hace que cada segundo estos cambien.

    log_chonto detiene el reloj y registra en el archivo log.chonto la tarea terminada. La magia de los dos >> actúa como una redirección de los datos, permite que si el archivo log.chonto no existe se cree, y si existe agregue la linea de registro al final del mismo. Registrando en esa línea, la marca de tiempo, el tiempo ejecutado en minutos, el texto descriptivo de la tarea, la palabra FULL indica que la tarea se ejecutó en su totalidad...que no se oprimió CTRL + C.

    ¿Qué pasa con el CTRL+C? que hay que capturarlo y asociarle una función que se ejecutará cuando ocurra. Esa función es log_chonto_break, hace lo mismo que log_chonto, pero registra en log.chonto la palabra BREAK para indicar que NO se terminó la tarea, junto con el tiempo parcial ejecutado. El programa termina con el correspondiente aviso en terminal de carita triste: echo "Unfinished task logged :("...log_chonto por el contrario SI imprime carita feliz.

    La interrupción de CTRL+C se captura así:

    trap 'log_chonto_break "$start_time" "$2"' SIGINT

    ¡Ahhh bueno!...hay que tener mplayer instalado (búscalo en tu distribución de Linux preferida), para reproducir la campanita al terminar, para eso es el archivo de sonido glass.ogg

    trap (comando nativo de Bash) recibe como parámetro el nombre de la función a ejecutar (log_chonto_break), pero esta función a su vez recibe como parámetros el tiempo de inicio registrado y el nombre de la tarea que se le envío por consola a nuestro script...almacenado en la variable $2.

    Para anotar: si un script recibe tres parámetros estarían internamente guardados en $1 $2 $3. A su vez cuando una función como las que mostramos, recibe parámetros, para ella quedarían guardados en $1, $2, $3...etc. y sólo existirían en su espacio de función, por eso los corchetes. Es como una caja negra, un script, dentro de un script.

    Al ejecutar un script, estas funciones no se ejecutarían automáticamente, sólo lo harían cuando se llamen explícitamente, entonces, las primeras líneas reales de ejecución de nuestro programa (obviando los if de validación), serían:

    MINS=$1
    start_time=$( date '+%s' )

    En $MINS queda guardado nuestro primer parámetro recibido desde la terminal Linux, los minutos a ejecutar (hay que usar el símbolo $ cuando se quiera llamar su contenido), y start_time arranca nuestro reloj. Si todo sale bien, la última línea de ejecución es:

    log_chonto "$start_time" "$2"

    Es un llamado a la función de guardado en log.chonto, que recibe como parámetros el tiempo de inicio y el nombre de la tarea. El archivo log.chonto es un archivo separado por comas, que puede usarse en otros sistemas (hasta en el mismo office...bueno, mejor LibreOffice) para generar analíticas.

    El script completo sería el siguiente:

    #!/bin/bash

    print_help (){
       echo USAGE FROM TERMINAL:
       echo ./chontoBash.sh NumMinutesToWork \"My Task to work in double quotes...\"
       echo If not exist, chonto will create the log file log.chonto, csv file to make data analytics:
       echo "TimeStamp, TotalMinutes, Task worked..., status: completed (FULL) or incomplete task (BREAK)"
       echo "TimeStamp, TotalMinutes, Task worked..., status: completed (FULL) or incomplete task (BREAK)" 
       echo "TimeStamp, TotalMinutes, Task worked..., status: completed (FULL) or incomplete task (BREAK)"
       echo .
       echo .
       echo .
    }

    log_chonto_break (){
         end_time=$( date '+%s' )
      echo $(date +"%F %H:%M:%S"), $((($end_time - $1) / 60)) Mins, "$2", BREAK >> log.chonto
      mplayer glass.ogg > /dev/null 2>&1
      tput clear
      echo "Unfinished task logged :("
      tput cnorm
      exit 1
    }

    log_chonto (){
      end_time=$( date '+%s' )
      echo $(date +"%F %H:%M:%S"), $((($end_time - $1) / 60)) Mins, "$2", FULL >> log.chonto
      mplayer glass.ogg > /dev/null 2>&1
      tput clear
      echo "Task finished logged :)"
      tput cnorm
    }

    print_timer (){
      #center the timer text, centering the cursor in Y/2:X/2-((text length)/2)
      tput cup $(($3/2)) $((($4/2)-($(expr length "$1 $2")/2)))
      tput bold; tput setaf $((1 + RANDOM % 10)); tput rev; echo "$1$2"; tput sgr0;
    }

    if [[ $# != 2 ]]; then
      tput bold; echo Error in arguments...; tput sgr0;
      echo
      print_help
      exit 1
    fi

    if ! [[ $1 =~ ^[0-9]+$ ]]; then
      tput bold; echo...how many minutes do you like to work?; tput sgr0;
      echo
      print_help
      exit 1
    fi

    MINS=$1
    start_time=$( date '+%s' )

    tput civis

    trap 'log_chonto_break "$start_time" "$2"' SIGINT

    for (( MINSCount=1; MINSCount<=$MINS; MINSCount++))
     do
     for (( SECSCount=1; SECSCount<=60; SECSCount++))
      do
       tput clear
       print_timer " $(($MINS-$MINSCount)) Minutes " "$((60-$SECSCount)) Seconds to rest... " "$(tput lines)" "$(tput cols)"
       sleep 1
      done
    done

    log_chonto "$start_time" "$2"

    Todo el script se encuentra en https://github.com/Open-SAI/ChonToPom obviamente es libre, más que libre esta bajo una licencia MIT.

    El nombre de Chonto...ya se imaginarán por qué es. Pomodoro en italiano es tomate, en estas tierras hay tomate...chonto, el software libre da la libertad de crear tecnología y cuando se hace, uno le pone el nombre que quiera, así también se exporta cultura.

  • Trabajando IoT con Intel Galileo

    OpenSAI MakerTop

    Durante los últimos tres días nuestro equipo HackVision ha estado trabajando IoT sobre tecnología Intel Galileo, que en esencia una implementación de Arduino con algunas mejoras y exenciones realizadas por Intel para el mercado naciente del Internet de las cosas.

    Estas actividades han estado enmarcadas dentro del trabajo de la iniciativa Vivamaker_co apoyada por el Vivelab Bogotá y el centro de excelencia y apropiación en internet de las cosas CEA-IoT.