Andrés Sabás es cofundador de Electronic Cats, así mismo cuenta con el proyecto The Inventor House en Aguascalientes, que es un Hackerspace en donde se pueden crear proyectos muy diversos.
Juntos abordamos varias aristas del problema de seguridad en IoT.
Platicamos con el Ing. Antonio Toriz, @elingbruxo, sobre su experiencia de cultura maker, lo que se espera en el futuro en una plática muy interesante y amena.
LIGAS:
Maker Faire Jalisco http://bit.ly/2K6BWbL
Faldas con luz http://bit.ly/2JYlJGZ
diablitos digitales http://bit.ly/2JV9WJb
Son las 11 de la mañana y los alrededores del Franz Mayer ya están muy despiertos, hay una banda tocando rock en la explanada exterior y un flujo discreto de gente entra al museo, ya adentro se empieza a acumular una fila para la taquilla que avanza rápido.
Escucha el podcast:
En ivoox:
En spotify:
En youtube:
Es temprano y ya podemos ver muchos asistentes de todas las edades, desde niños de edad preescolar acompañados de sus padres, jóvenes preparatorianos que llegan en grupos de amigos, hasta personas de la tercera edad que se integran en las actividades y para ver las exposiciones.
En la planta baja, lo primero que encontramos de lado derecho es la entrada al auditorio en el que desde las 11:30 iniciará la jornada de charlas; desde este momento hay una larga fila para la charla de Arduino en el espacio de David Cuartielles.
De lado izquierdo nos encontramos un stand de Hacedores en donde puedes conseguir los kits para los talleres y algunos souvenirs.
Avanzando por esta planta, sobre el marco del patio de la antigua alhóndiga que ahora es locación del museo, encontramos inaugurando el recorrido de exposiciones al Colectivo Creabióticos, un grupo de artistas que trabaja para la concietización sobre la importancia de la captación del agua de lluvia, ya que la CDMX recibe anualmente en lluvia 3 veces el agua que requiere para su población, sin embargo es traída de otros estados por el sistema Cutzamala; Creabióticos, con el espíritu maker, ha diseñado un sistema de captación y purificación de agua, y lo ha integrado con su formación artística para crear un performance de conciencia.
Los siguientes expositores muestran cómo han creado dos maquinitas tradicionales a partir de una Raspberry Pi y un arduino, aquí se juntan muchos adolescentes (y otros no tan jóvenes) para jugar sin necesidad de traer el cambio de las tortillas con créditos ilimitados.
Más adelante están proyectos como el de Cansat Cemanahuatl de la fabricación de satélites “enlatados”, hechos para ser lanzados a un kilómetro de altura para monitorear información de la atmósfera por medio de un Arduino con sensores, y como lo dice el nombre, usando una lata como carcasa.
En este mismo espacio encontramos varios proyectos como el de Trash Metal y GMartell que te animan a componer música usando medios no convencionales como Arduino o construir tu propio bajo o/y guitarra.
Cerca de ahí, la exposición de Xedelectronics atraía a muchísimas personas, principalmente niñas y niños, en la que había dos robots hexápodos que podían manejarse por medio de un arduino que recibía instrucciones para moverse desde un celular.
En el primer piso del museo se encontraban los talleres maker en los que podías aprender desde circuitos sencillos para prender un led, hasta soldar con cautín y fundamentos de programación de Arduino. Algo llamativo es que en algunos talleres recibías instrucción de niños y niñas, quienes además de explicarte qué clase de proyectos han hecho, te enseñaban y animaban a iniciarte en la programación y electrónica.
En este piso había talleres para hacer robots de cartón, carritos de lata, cohetes de papel, insectos vibradores, fluido no newtoniano, entre otros.
También había espacios en los que podías convertir un dibujo en un tallado sobre acrílico o madera o imprimirlo en 3D por módicos precios, o llevarte el contacto de lugares donde puedes hacer esto para animarte a llevar más allá tus ánimos creativos.
Todo el tiempo se percibió un ambiente de energía, las charlas del auditorio tuvieron muchísima participación y sin duda la mayoría de los asistentes se llevaron esta curiosidad por vivir la experiencia maker, al igual que muchos niños y niñas descubrieron herramientas que, esperamos sean determinantes en su vida.
En la víspera del Arduino Day 2019 a celebrarse en la Ciudad de México, entrevistamos a Antonio Quirarte, organizador y hacedor.
El jueves 14 de marzo del 2019, atrás de la Catedral metropolitana, acudimos a la cita que amablemente nos brindó Antonio Quirarte, co-fundador de hacedores y organizador del Arduino Day 2019. En un lugar que se aleja de los turistas, de los vendedores de marcos, de las imágenes religiosas, hay un oasis para makers: El makerspace de hacedores.
Desde ese lugar, se prepara el Arduino Day 2019, ahí entre cautines, impresoras 3D, cortadoras láser, máquinas de coser, sierras de banco, un grupo de makers se mueve a toda velocidad para dejar listas las actividades del gran día. Para mi compañera Karla García y para mí, es un lugar que se aparece inesperado y se antoja digno de convertirse en una costumbre.
-Es como una membresía de un gimnasio- apunta Arturo Gamez, quien, amablemente nos da un tour completo por el lugar.
El ambiente, aunque atareado, también es festivo, Hacedores cumple 5 años y el makerspace 4. Además el Arduino Day será el próximo sábado y por ello las excusas para celebrar sobran.
Antonio Quirarte nos recibe y amablemente nos platica su perspectiva del evento, del movimiento maker y, por supuesto, de hacedores.
Tradicionalmente los microcontroladores, se programan usando un algoritmo secuencial, en la cual los recursos de hardware, no se comparten entre funciones, es decir el uso de un periférico, como son: la Unidad Aritmetica Lógica, contadores, Convertidores Analogico Digital, etc; no son liberados hasta que termina la función actual de ejecutarse. Esto implica tener varias funciones anidadas, que esperan a que la función en ejecución termina de usar los recursos del microcontrolador.
El nivel de integración actual, ha permitido que los microcontroladores posean, mayor capacidad de memoria, mayor velocidad de transferencia de datos para su procesamiento y un acceso mas rápido a la lectura y escritura de memoria.
Todas las características anteriormente citadas, permiten el poder implementar un RTOS (Sistema Operativo en Tiempo Real) en un microcontrolador de 8 bits. Un RTOS, es un gestor de tiempo de ejecución, que administra diferentes tareas que son parecidas a una función secuencial, pero permiten ser, puestas en espera, imitarles el acceso a la memoria y/o al hardware, guardar el entorno actual de contadores, periféricos, contador del programa, etc. Saltar a otra tarea, compartir los recursos y regresar a la tarea que se quedo en espera. Todo esto gracias a la creación de varios Stacks (pilas de registros guardados) en este caso generalmente en memoría RAM. Finalmente la tarea que estaba esperando o que se quedo a mitad de ejecución, puede continuar su ejecución justo en el punto donde fue interrumpida.
Después de comprender este sencillo ejemplo, imaginémonos que esta “puesta en espera” se realiza con diferentes tareas, compartiendo recursos y saltando simultáneamente entre ellas. La combinación de un gestor de tiempos entre tareas secuenciales que comparten recursos, es el objetivo de los RTOS.
Arduino UNO con un RTOS
Una arquitectura Arduino UNO (Atmega328, 8 Bits uC a 16 mega hertz) gracias a freeRTOS, nos permite implementar un pequeño Sistema en Tiempo Real.
Quiero compartirles, este código que utiliza un RTOS en un arduino UNO, es para un cubo de leds de 3×3. En futuras aportaciones explicare a detalle como funciona este RTOS y como configurar las diferentes tareas creadas. Por el momento a grandes razgos:
Una tarea ejecuta las secuencias de patrones de encendido de los leds
Una tarea revisa el potenciómetro (genera un voltaje variable) que aumenta la velocidad de las secuencias
Una tarea revisa el estado de un botón que cambia la secuencia de encendido de los leds, por si ya te aburriste y quieres que los leds prendan con un patrón diferente.
Este programa también se puede escribir de manera tradicional, con lógica secuencial, pero al usar un RTOS, para actualizar las variables globales, que controlan el sentido y velocidad de los patrones de encendido de los leds, se hace evidente, que al usar un RTOS, el programa final es más sencillo y utiliza más eficientemente los recursos del microcontrolador.
Adjunto también, un enlace a un video, para que vean el funcionamiento de este cubito de 3×3.
Rafael Sobrevilla
Referencias
Programación de Sistemas Embebidos en C, Gustavo Galeano, Primera Edición, 2009, Alfaomega
/**************************************************************************************************
* File name: cube3x3.ino
* Date Start: 17-may-17
* Author: Rafael Sobrevilla
* email: rasobrevilla@yahoo.com
* Descrip:
* – Control a 27 leds cube
* – Use digital outputs of arduino UNO
* + D2 – D10 Control of base leds
* + D11 – D13 The three floors
* + A0 – A1 Two Buttons
* + D0 and D1 To keep the serial port available
*
* led1 led2 led3
*
* led4 led5 led6
*
* led7 led8 led9
*
* floor0
* floor1
* floor2
*
**************************************************************************************************/
/**************************************************************************/
/* Include headers */
/**************************************************************************/
#include <Arduino_FreeRTOS.h>
/*************************************************************************/
/* Define two task for Sensors and Clock */
/*************************************************************************/
void TaskPatron( void *pvParameters );
//void TaskPotenciometer ( void *pvParameter );
void TaskButton ( void *pvParameter );
/********************************************************************/
/* Global variables */
/********************************************************************/
int led1 = 2;
int led2 = 3;
int led3 = 4;
int led4 = 5;
int led5 = 6;
int led6 = 7;
int led7 = 8;
int led8 = 9;
int led9 = 10;
int floor0 = 11;
int floor1 = 12;
int floor2 = 13;
int sen_pin0 = A0;
int sen_pin1 = A2;
const int ON = 1;
const int OFF = 0;
int delay_ms_value_1 = 250;
int delay_ms_value_2 = 500;
int button_status = 0;
int potenciometer_status = 0;
/***************************************************************************/
/* Setup function is executed when you press reset or power the board */
/***************************************************************************/
void setup() {
Serial.begin(9600);
while (!Serial) {
; // wait for serial port to connect. Needed for native USB, on LEONARDO, MICRO, YUN, and other 32u4 based boards.
}
// Now set up two tasks to run independently.
xTaskCreate (
TaskPatron
, (const portCHAR *) «Sensor»
, 128 // Stack size
, NULL
, 3 // Priority
, NULL );
xTaskCreate (
TaskButton
, (const portCHAR *)»Motors» // A name just for humans
, 128 // This stack size can be checked & adjusted by reading the Stack Highwater
, NULL
, 3 // Priority, with 3 (configMAX_PRIORITIES – 1) being the highest, and 0 being the lowest.
, NULL );
// Now the task scheduler, which takes over control of scheduling individual tasks, is automatically started.
}
/***********************************************************************/
/* Function for turn on a Position led */
/***********************************************************************/
int enable(int position_led, int floor_on)
{
digitalWrite(position_led, ON);
digitalWrite(floor_on, ON );
}
/***********************************************************************/
/* Fnction for turn off a Position Led */
/***********************************************************************/
int disable(int position_led, int floor_on)
{
digitalWrite(position_led, OFF);
digitalWrite(floor_on, OFF );
}
/*****************************************************************************/
/* LOOP FUNCTION */
/*****************************************************************************/
void loop()
{
// Empty. Things are done in Tasks.
}
void TaskPatron(void *pvParameters) // This is a task.
{
(void) pvParameters;
for (;;)
{
Serial.println(«PATRONES»);
do{
patron1();
}while(button_status > 200);
do{
patron2();
}while(button_status > 200);
do{
patron3();
}while(button_status > 200);
do{
patron4();
}while(button_status > 200);
}
}
void TaskPotenciometer (void *pvParameters) // This is a task.
{
(void) pvParameters;
for(;;)
{
potenciometer_status = analogRead (sen_pin0);
Serial.println(potenciometer_status);
//delay(delay_ms_value_2);
}
}
void TaskButton (void *pvParameters) // This is a task.
{
(void) pvParameters;
for(;;)
{
button_status = analogRead (sen_pin1);
Serial.println(button_status);
//delay(delay_ms_value_2);
}
}
Quiero compartirles los problemas que tuve con un módulo DS1302 que pedí a China. Pues lo conecté y, aunque todo se veía bien, con un programita sencillo que imprimía la hora al monitor serial, tenía lecturas erróneas. Por ejemplo:
23:34:04 <- buena lectura
23:34:05 <- buena lectura
01:01:10 <- mala lectura
01:10:11 <- mala lectura
23:34:08 <- buena lectura
Pues pasé horas, ¡horas! revisando las bibliotecas que usé. Descargué varias, las revisé parte por parte, descarté las que no me gustaban. También cambié puertos, cables, y todo era en vano. Bien, pues les comparto una receta de cocina para que no sufran lo mismo que sufrí yo y se den de golpes contra la pared cuando prueben lo siguiente:
Toma el módulo y revisa que tu integrado esté orientado como viene en la placa impresa. ¡Uno de mis módulos tenía el porta integrados volteado! Asegúrate de que sea como la placa lo dice.
Con unas pinzas de punta, saca y endereza correctamente los pines del DS1302. Vuélvelo a conectar y asegúrate de que la panza del integrado toque el porta integrados. (Esto era lo que me causaba ruido).
Coloca la pila CR-2032 en el porta pilas y asegúrate de que no tiene «juego», es decir, que está floja. Si lo está, retírala y con unas pinzas baja un poco el seguro para que haga mayor fuerza y sostenga la pila.
Cambia tus cables, yo estaba usando los cables para pines arduino, unos hembra-macho. Lo que hice fue encajar el módulo directamente en la protoboard y usar cable telefónico o el del cable ethernet.
Usa una biblioteca robusta de interconexión y pon atención a los tiempos de lectura. La mejor biblioteca que encontré es la de Timur Maksimov 2014. Aquí la liga a la página.
Aquí adjunto una foto de stock en donde pueden ver que el integrado está meramente sobrepuesto en el porta integrado. Así vienen por lo general estos módulos, asegúrate de que corriges ese punto.
Aquí una foto de los cables que retiré. Repito, RETIRÉ.
Aquí una foto de los cables que usé:
Espero que estos tips les ayuden y en menos de quince minutos estén arriba con su reloj.
Una de las grandes preguntas sobre Arduino que tenía desde hace tiempo, era la posibilidad de hacerle ingeniería inversa, específicamente, obtener el código de un Arduino programado. Les adelanto la sorpresa, la respuesta corta es que si, si es posible obtener código de un Arduino programado, sin embargo, no será lenguaje de alto nivel. Lo más cerca que tendremos será un paso intermedio entre lenguaje ensamblador e instrucciones en hexadecimal.
Lista de equipo
Arduino Uno (yo usé un Arduino Uno R3 con chip desmontable)
Tarjeta lectora/escritora de chips AVR. (Yo usé la conocida stk500 de Atmel)
Adaptador usb-serial
Cable usb con terminal tipo A
PC con la suite de Arduino instalada
Proceso de ingeniería inversa
Grabar el código original
Este paso ya lo has hecho una y otra vez, sólo carga el sketch al arduino. En mi caso voy a usar un sketch muy sencillo para efectos didácticos como el que podemos encontrar dentro de la carpeta de «Ejemplos», el famoso Blink. Lo modifiqué un poco para que el led 13 parpareada cada 7 segundos en lugar de 1, esto para poder identificar fácilmente el resultado.
void setup() {
// initialize the digital pin as an output.
pinMode(13, OUTPUT);
}
// the loop routine runs over and over again forever:
void loop() {
digitalWrite(13, HIGH); // turn the LED on (HIGH is the voltage level)
delay(7000);// wait for a second
digitalWrite(13, LOW); // turn the LED off by making the voltage LOW
delay(7000);// wait for a second
}
Extraer el chip atmega328p
Este modelo nos permite extraer el chip atmega328p, para poderlo colocar en el lector stk500.
Extraer el binario en hexadecimal
Para extraer el binaro en formato hexadecimal de Intel, usa el siguiente comando:
/dev/ttyUSB0 es el puerto que usa el convertidor usb-serial, en tu caso puede cambiar, revísalo con el comando dmesg inmediatamente después de conectar el usb-serial.
El resultado será un archivo con el nombre reverse.hex, si lo abres, encontrarás algo como lo siguiente:
El resultado de ese comando, nos entregará un pseudocódigo parecido al ensamblador, claro que habrá que hacer bastante trabajo estético para poderlo leer, pero el siguiente extracto muestra llamadas las funciones que prenden y pagan el pin 13.
0x000000e8 ldi r22, 0x01 ; 1
0x000000ea ldi r24, 0x0D ; 13
0x000000ec call 0x37a ; 0x0000037a Llama a la función que cambia el pin a alto
0x000000f0 ldi r22, 0x58 ; 88
0x000000f2 ldi r23, 0x1B ; 27
0x000000f4 ldi r24, 0x00 ; 0
0x000000f6 ldi r25, 0x00 ; 0
0x000000f8 call 0x1ee ; 0x000001ee Llama la función de delay
0x000000fc ldi r22, 0x00 ; 0
0x000000fe ldi r24, 0x0D ; 13
0x00000100 call 0x37a ; 0x0000037a LLama la función que cambia el pin a bajo
0x00000104 ldi r22, 0x58 ; 88
0x00000106 ldi r23, 0x1B ; 27
0x00000108 ldi r24, 0x00 ; 0
0x0000010a ldi r25, 0x00 ; 0
Claro que hay que hacer mucho trabajo para entender el funcionamiento correcto del equipo, sin embargo, es completamente viable realizarlo.
