Author Archive Rafael Sobrevilla

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

 

Rafael Sobrevilla PorRafael Sobrevilla

Robot, Actualmente, ¿Qué es un Robot y qué no es?

Robot es un término que apareció por primera vez en la novela R.U.R. (Robots Universales Rossum) del dramaturgo checo Karel Čapek, que se estrenó en 1920.1 La palabra se escribía como “robotnik”[1].

 

La palabra Robot, hace referencia a sirviente o trabajador. La autoría del término Robótica, fue desarrollado en varias novelas de Isaac Asimov donde se plantea el estudio, el diseño y la generación de inteligencia artificial, necesarios para estos tipos de dispositivos y el problema de su interacción con los seres humanos.

Este término ha tenido una evolución, en los años 60’s en la industria, se planteó a las universidades el desarrollo de manipuladores que permitieran realizar tareas complicadas y/o peligrosas para los seres humanos. Por lo que la creación de manipuladores  caracterizó a la década de los sesentas. Utilizando principios de mecánica, permitían levantar cargas más pesadas, mantenerse a una distancia segura en caso de manipulación de químicos u objetos calientes. Esto nos lleva una de las tres partes principales de un robot.

– Estructura Mecánica [3]

En la década de los 70’s, la industria solicitó a las universidades/fabricantes, que el desarrollo se orientara a la implementación de motores eléctricos e interruptores para poder controlar las estructuras de los robots industriales. El potencial de la producción en cadena, planteado por Henry Ford, al emplear manipuladores mecánicos eléctricos controlados por interruptores y por operadores dentro de las fábricas, fue alto y sigue vigente hasta en la actualidad. Los motores eléctricos, requieren mucho menos mantenimiento que los motores a combustibles fósiles, son más silencios, eficientes, fáciles de reparar y al ser controlados con interruptores versátiles, nos introduce a la segunda parte fundamental de un robot: Su sistema eléctrico de control.

– Sistema Eléctrico de Control

En los años 80’s del siglo pasado, en los manipuladores industriales, tomó importancia el uso de sensores. Con la incorporación de las mini-computadoras programables,  en las cuales se podían generar rutinas con los movimientos repetitivos que caracterizan a la producción en serie. Los problemas de desgaste en las juntas de este tipo de maquinaria, no permitían automatizar por medio de un programa de secuencias repetitivas a los manipuladores, pues las posiciones a las que tenían que llegar los elementos del manipulador, cambiaban con el tiempo, por el efecto de fricción y desgate mencionado. Por lo que los avances en el ramo de la robótica, se centran en la automatización, basada con la retroalimentación de los sensores de posición, velocidad, distancia y presencia. Estos aportes permitieron que los Manipuladores Industriales pudieran tener programaciones que con retroalimentación del mundo exterior, que asegura si las tareas se realizaban dentro de los rangos esperados, o bien, avisar que requerían un ajuste los movimientos, incluso ser ajustados automáticamente por los programas contenidos en su microcomputadora.

Actualmente la definición de robot actual es:

Dispositivo con un sistema de computo, que contiene un programa para controlar los movimientos de los actuadores mecánicos y eléctricos, utilizando la información recopilada de su medio ambiente, por medio de sus sensores, para tomar decisiones.

Partes de un robot

a) Actuadores mecánicos

b) Sistema eléctrico y Sistema electrónico

b) Con un sistema de computo, con un programa

c) Sensores, para tener una retroalimentación de su medio ambiente

Referencias

[1] https://es.wikipedia.org/wiki/Robot

[2] http://www.jotdown.es/2013/02/detroit-asi-se-hundio-el-titanic-del-capitalismo-estadounidense/

[3] http://davidentrablog.blogspot.mx/2012/12/transformaciones-del-sxix-y-su.html