Category Archive Microcontroladores

Rafael Sobrevilla PorRafael Sobrevilla

Sistemas Operativo en Tiempo Real, para un Sistema Embebido (ARDUINO)

Introducción

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

https://aprendiendoarduino.wordpress.com/tag/rtos/

 

Video

Código

/**************************************************************************************************
* 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.
}

pinMode(led1, OUTPUT);
pinMode(led2, OUTPUT);
pinMode(led3, OUTPUT);
pinMode(led4, OUTPUT);
pinMode(led5, OUTPUT);
pinMode(led6, OUTPUT);
pinMode(led7, OUTPUT);
pinMode(led8, OUTPUT);
pinMode(led9, OUTPUT);
pinMode(floor0, OUTPUT);
pinMode(floor1, OUTPUT);
pinMode(floor2, OUTPUT);

// 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 );

xTaskCreate (
TaskPotenciometer
, (const portCHAR *) “Sensor”
, 128 // Stack size
, NULL
, 3 // Priority
, 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.
}

/******************************************************************************/
/* 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);
}
}

/************************************************************************/
/* Patron 1 */
/************************************************************************/
void patron1 (void)
{
//floor 2
enable(led1, floor2);
enable(led2, floor2);
enable(led3, floor2);
enable(led4, floor2);
enable(led5, floor2);
enable(led6, floor2);
enable(led7, floor2);
enable(led8, floor2);
enable(led9, floor2);
delay(potenciometer_status );

disable(led1, floor2);
disable(led2, floor2);
disable(led3, floor2);
disable(led4, floor2);
disable(led5, floor2);
disable(led6, floor2);
disable(led7, floor2);
disable(led8, floor2);
disable(led9, floor2);

//floor 1
enable(led1, floor1);
enable(led2, floor1);
enable(led3, floor1);
enable(led4, floor1);
enable(led5, floor1);
enable(led6, floor1);
enable(led7, floor1);
enable(led8, floor1);
enable(led9, floor1);
delay(potenciometer_status );

disable(led1, floor1);
disable(led2, floor1);
disable(led3, floor1);
disable(led4, floor1);
disable(led5, floor1);
disable(led6, floor1);
disable(led7, floor1);
disable(led8, floor1);
disable(led9, floor1);

//floor 0
enable(led1, floor0);
enable(led2, floor0);
enable(led3, floor0);
enable(led4, floor0);
enable(led5, floor0);
enable(led6, floor0);
enable(led7, floor0);
enable(led8, floor0);
enable(led9, floor0);
delay(potenciometer_status );

disable(led1, floor0);
disable(led2, floor0);
disable(led3, floor0);
disable(led4, floor0);
disable(led5, floor0);
disable(led6, floor0);
disable(led7, floor0);
disable(led8, floor0);
disable(led9, floor0);

//floor 1
enable(led1, floor1);
enable(led2, floor1);
enable(led3, floor1);
enable(led4, floor1);
enable(led5, floor1);
enable(led6, floor1);
enable(led7, floor1);
enable(led8, floor1);
enable(led9, floor1);
delay(potenciometer_status );

disable(led1, floor1);
disable(led2, floor1);
disable(led3, floor1);
disable(led4, floor1);
disable(led5, floor1);
disable(led6, floor1);
disable(led7, floor1);
disable(led8, floor1);
disable(led9, floor1);
}

/*********************************************************************************/
/* Patron 2 */
/*********************************************************************************/
void patron2(void)
{
//wall 2
enable(led1, floor2);
enable(led2, floor2);
enable(led3, floor2);
enable(led1, floor1);
enable(led2, floor1);
enable(led3, floor1);
enable(led1, floor0);
enable(led2, floor0);
enable(led3, floor0);
delay(potenciometer_status );

disable(led1, floor2);
disable(led2, floor2);
disable(led3, floor2);
disable(led1, floor1);
disable(led2, floor1);
disable(led3, floor1);
disable(led1, floor0);
disable(led2, floor0);
disable(led3, floor0);

//floor 1
enable(led4, floor2);
enable(led5, floor2);
enable(led6, floor2);
enable(led4, floor1);
enable(led5, floor1);
enable(led6, floor1);
enable(led4, floor0);
enable(led5, floor0);
enable(led6, floor0);
delay(potenciometer_status );

disable(led4, floor2);
disable(led5, floor2);
disable(led6, floor2);
disable(led4, floor1);
disable(led5, floor1);
disable(led6, floor1);
disable(led4, floor0);
disable(led5, floor0);
disable(led6, floor0);

//floor 0
enable(led7, floor2);
enable(led8, floor2);
enable(led9, floor2);
enable(led7, floor1);
enable(led8, floor1);
enable(led9, floor1);
enable(led7, floor0);
enable(led8, floor0);
enable(led9, floor0);
delay(potenciometer_status );

disable(led7, floor2);
disable(led8, floor2);
disable(led9, floor2);
disable(led7, floor1);
disable(led8, floor1);
disable(led9, floor1);
disable(led7, floor0);
disable(led8, floor0);
disable(led9, floor0);

//floor 1
enable(led4, floor2);
enable(led5, floor2);
enable(led6, floor2);
enable(led4, floor1);
enable(led5, floor1);
enable(led6, floor1);
enable(led4, floor0);
enable(led5, floor0);
enable(led6, floor0);
delay(potenciometer_status );

disable(led4, floor2);
disable(led5, floor2);
disable(led6, floor2);
disable(led4, floor1);
disable(led5, floor1);
disable(led6, floor1);
disable(led4, floor0);
disable(led5, floor0);
disable(led6, floor0);
}

/*********************************************************************************/
/* Patron 3 */
/*********************************************************************************/
void patron3 (void)
{
//wall 2
enable(led1, floor2);
enable(led4, floor2);
enable(led7, floor2);
enable(led1, floor1);
enable(led4, floor1);
enable(led7, floor1);
enable(led1, floor0);
enable(led4, floor0);
enable(led7, floor0);
delay(potenciometer_status );

disable(led1, floor2);
disable(led4, floor2);
disable(led7, floor2);
disable(led1, floor1);
disable(led4, floor1);
disable(led7, floor1);
disable(led1, floor0);
disable(led4, floor0);
disable(led7, floor0);

//wall 1
enable(led2, floor2);
enable(led5, floor2);
enable(led8, floor2);
enable(led2, floor1);
enable(led5, floor1);
enable(led8, floor1);
enable(led2, floor0);
enable(led5, floor0);
enable(led8, floor0);
delay(potenciometer_status );

disable(led2, floor2);
disable(led5, floor2);
disable(led8, floor2);
disable(led2, floor1);
disable(led5, floor1);
disable(led8, floor1);
disable(led2, floor0);
disable(led5, floor0);
disable(led8, floor0);

//wall 0
enable(led3, floor2);
enable(led6, floor2);
enable(led9, floor2);
enable(led3, floor1);
enable(led6, floor1);
enable(led9, floor1);
enable(led3, floor0);
enable(led6, floor0);
enable(led9, floor0);
delay(potenciometer_status );

disable(led3, floor2);
disable(led6, floor2);
disable(led9, floor2);
disable(led3, floor1);
disable(led6, floor1);
disable(led9, floor1);
disable(led3, floor0);
disable(led6, floor0);
disable(led9, floor0);

//floor 1
enable(led2, floor2);
enable(led5, floor2);
enable(led8, floor2);
enable(led2, floor1);
enable(led5, floor1);
enable(led8, floor1);
enable(led2, floor0);
enable(led5, floor0);
enable(led8, floor0);
delay(potenciometer_status );

disable(led2, floor2);
disable(led5, floor2);
disable(led8, floor2);
disable(led2, floor1);
disable(led5, floor1);
disable(led8, floor1);
disable(led2, floor0);
disable(led5, floor0);
disable(led8, floor0);
}

/*********************************************************************************/
/* Patron 4 */
/*********************************************************************************/
void patron4 (void)
{
//wall 2
enable(led1, floor2);
enable(led5, floor1);
enable(led9, floor0);
delay(potenciometer_status );

disable(led1, floor2);
disable(led5, floor1);
disable(led9, floor0);

//wall 1
enable(led2, floor2);
enable(led5, floor1);
enable(led8, floor0);
delay(potenciometer_status );

disable(led2, floor2);
disable(led5, floor1);
disable(led8, floor0);

//wall 0
enable(led3, floor2);
enable(led5, floor1);
enable(led7, floor0);
delay(potenciometer_status );

disable(led3, floor2);
disable(led5, floor1);
disable(led7, floor0);

//floor 1
enable(led4, floor2);
enable(led5, floor1);
enable(led6, floor0);
delay(potenciometer_status );

disable(led4, floor2);
disable(led5, floor1);
disable(led6, floor0);
}

 

León Ramos PorLeón Ramos

Problemas con un módulo DS1302

Hola amigos:

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:

  1. 23:34:04 <- buena lectura
  2. 23:34:05 <- buena lectura
  3. 01:01:10 <- mala lectura
  4. 01:10:11 <- mala lectura
  5. 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:

  1. 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.
  2. 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).
  3. 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.
  4. 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.
  5. 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.

Hasta la próxima,

Porcreadores

Ingeniería inversa en Arduino Uno

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
}

mci-tdd-00756_arduino_uno_r3_2

Extraer el chip atmega328p

Este modelo nos permite extraer el chip atmega328p, para poderlo colocar en el lector stk500.

atmega328p-pustk500

Extraer el binario en hexadecimal

Para extraer el binaro en formato hexadecimal de Intel, usa el siguiente comando:

avrdude -F -v -pm328p -cstk500 -P/dev/ttyUSB0 -D -Uflash:r:reverse.hex:i

/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:

:200000000C945C000C946E000C946E000C946E000C946E000C946E000C946E000C946E0082
:200020000C946E000C946E000C946E000C946E000C946E000C946E000C946E000C946E0050
:200040000C9488000C946E000C946E000C946E000C946E000C946E000C946E000C946E0016
:200060000C946E000C946E000000000700020100000304060000000000000000010204083E
:200080001020408001020408102001020408102004040404040404040202020202020303C0

Descompilar el hexadecimal

Para poder entender el código hexadecimal, lo pasaremos por un descompilador que convertirá los códigos en instrucciones legibles.

avr-objdump --no-show-raw-insn -m avr --prefix-addresses -D reverse.hex > reverse.assembler

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.

¿Cómo evitar que lean código de mi chip?

Existe una sección de fusibles o bits de cerrado que impedirán el proceso anterior. Sólo tienes que seguir correctamente la receta. Adjunto este sitio con información al respecto.

Happy reverse engnineering!!