Sistemas operativos en PIC

[Cryn]

la verdad que estoy muy interesado en aprender mucho más acerca del RTOS, ya vi la ayuda que presenta en el manual de CCS, y pues quede algo desepcionado, porque simplemente dan unos pequeños datos de lo que hace cada funcion del RTOS, supongo que esas son todas las funciones pues no fijuran más en el manual. Pero la verdad que estoy muy interesando en seguir aprendiendo más acerca de este RTOS para CCS, no existe algún otro manual de ello, aunque sea en ingles?? para poder continuar con el mundo del RTOS.

muchas gracias un saludo.

[reiniertl]

Hasta donde yo se no hay mucho más, lo que es una lástima, sobre las funciones es cierto que son pocas pero sirven bien

[gera]

Muy bueno todo este tema, ya voy a hacer algun proyectito que lo implemente. Pero tengo una duda... no hay algun RTOS o alguna funcionalidad que pueda traer procesos desde una memoria externa, en lugar de tener q declarar funciones que seran los procesos? (como lo hacen nuestras computadoras)
Saludos!

[superprp]

encontré algunos libros bastante buenos sobre RTOS en microcontroladores PIC, aquí están los enlaces:


http://www.amazon.co.uk/Embedded-C-Programming-Microchip-Pic/dp/1401837484

http://www.amazon.co.uk/Programming-16-Bit-PIC-Microcontrollers-Technology/dp/0750682922/ref=pd_sim_b_1

http://www.amazon.co.uk/Designing-Embedded-Systems-PIC-Microcontrollers/dp/0750667559/ref=pd_sim_b_3

a quien no le importe que sea en ingles son perfectos, es lo mejor que he encontrado.

[Cryn]

mmmm

nose si será lo que busco, pues no dice exactamente CCS, en caso de que sean con CC pues un pequeño detalle, que personalmente no puedo comprarlos, pues no poseo TC

creo que no hay ningún material 'libre' como este que ha dejado reiner

ni modo, cosas de la vida, jaja, pero de todos modos seguiré buscando. un saludo

[reiniertl]

Muy bueno todo este tema, ya voy a hacer algun proyectito que lo implemente. Pero tengo una duda... no hay algun RTOS o alguna funcionalidad que pueda traer procesos desde una memoria externa, en lugar de tener q declarar funciones que seran los procesos? (como lo hacen nuestras computadoras)
Saludos!

Indio no entender, que quieres traer de memoria externa?

[LABmouse]

Muy bueno todo este tema, ya voy a hacer algun proyectito que lo implemente. Pero tengo una duda... no hay algun RTOS o alguna funcionalidad que pueda traer procesos desde una memoria externa, en lugar de tener q declarar funciones que seran los procesos? (como lo hacen nuestras computadoras)
Saludos!

Pues gera, simplemente colocas la memoria externa, y haces una función en el PIC que traiga datos y envié datos a la memoria externa..  Los PICs son buenos para aplicaciones pequeñas, es imposible que lo compares con un PC. Si quieres algo mas poderoso, entonces hay que mirar los ARM u otros de 32 Bits, con capacidad de correr LINUX o Windows C.

[scientist]

muy buen hilo, no lo habia visto, y la verdad a sido una grata sorpresa para mi haberlo encontrado, un pedazo de hilo, felicidades reniertl muy didactico

[josnelihurt]

Felicitaciones por el grandioso trabajo reniertl, auque no soy nuevo en el foro, no habia tenido una participacion activa y he decidido empezar por esta, me tomado como 3 dias de a trozos leer todo el contenido, por esto de las festividades navideñas pero la verdad tenia una mala idea infundada de los OS y ahora veo el alcance que pueden llegar a tener, espero que este hilo se reactive, quedo muy agradecido y altamente interzado en el tema

[edwin657]

Bueno, parece que este hilo hace rato no se alimenta, asi que decidi publicar una parte del libro  "The Art of Designing Embedded Systems" 2ed de "Jack Ganssle", donde habla hacerca de los RTOS, Jack Ganssle es uno de los gurus de los sitemas embebidos, la traduccion esta un poco burda pero se entiende....

Estos son mis reglas de oro para la decisión si obner o no un RTOS

Cualquier sistema grande, donde "grandes" se define como la pornografía (es decir, "Sé esto cuando lo veo"), se pone bien un RTOS o, en su caso, un sistema operativo convencional como Linux. Grandes sistemas siempre se hacen más grandes, grandes sistemas son inherentemente complejos, y los grandes sistemas manejan muchas diferentes actividades, por lo que se benefician de tener un entorno multitarea.

La mayoría de los sistemas pequeños, donde "pequeños" significa que estamos contando centavos, no le pongas un sistema operativo de ningún tipo.

Cuando hay vidas en juego si el sistema no es cargado ligeramente hacemos un análisis muy cuidadoso para ver si el multitarea podría crear problemas en el determinismo (ver más abajo). Si el determinismo no se puede garantizar, y si no hay ningún mecanismo de seguridad redundante, evitar un RTOS. Tenga en cuenta, sin embargo, que el traslado de tareas a los llamados de interrupción no resuelve el problema de determinismo. Un mecanismo diferente, como secuencias de disparo por tiempo, es probablemente más adecuado.

Si un organismo regulador debe certificar el producto, entonces, utilizar un RTOS sólo si una versión certificable está disponible. Por ejemplo, varios proveedores venden sistemas operativos comerciales certificable a DO-178B Nivel A, pero estos productos no están disponibles para todos los procesadores.

Si hay múltiples actividades independientes en marcha, tales como la necesidad de actualizar la pantalla al mismo tiempo que la obtención de datos y escaneo de un teclado, prefiero usar un RTOS.

Si un simple loop puede manejar todas las necesidades de la aplicación, y que se prevé la no necesidad futura de agregar mas funcionalidad más allá de lo que el bucle se puede manejar, no tome la RTOS

[IIIC]

Si bien al fin de cuentas se dio un curso de RTOS, el desarrollo de un sistema operativo sobre pic no se abordo, ahora mismo estoy interesado por un firmware que permita la ejecucion de una maquina virtual de java que a su vez permita la ejecucion de bytecode que controla las acciones y procesos del pic.

Ustedes han oido hablar acerca de estos proyectos, del unico que tengo referencia es de LEJOS NXT... que trabaja precisamente de esa forma, y esta orientada para los carisimos juguetes de LEGO MINDSTORMS.

Cabe mencionar que este proyecto esta enfocada a los siguientes micros

32-bit AT91SAM7S256 (ARM7TDMI) main microprocessor @ 48 MHz (256 KB flash memory, 64 KB RAM)
8-bit ATmega48 microcontroller @ 4 MHz (4 KB flash memory, 512 Bytes RAM)

Aunque tambien entiendo que la programacion de un microprocesador y un microcontrolador difieren.
 
Alguien podria dar un poco de luz a mi ignorancia?

Saludos.

[jeremylf]

Muy buen curso reiniertl, gracias.

Creo que en otro lado has mencionado que te estas pasando al FreeRTOS cierto? Habra un curso como este para este RTOS?    La pega, como bien se sabe, es que es en c18 (en el caso de los PIC18). Aunque ya estoy metiendome a este lenguaje.

Gracias otra vez!!

[reiniertl]

Estuve dando un curso en micropic, el cual por motivos de tiempo no he podido completar. Sin embargo, espero que en el primer trimestre del próximo año pueda retomarlo muy en serio y con muchas mejoras. Pretendo para esa fecha tener lo siguiente:

Todas las clases escritas y listas (se asegura el curso) gracias a que utilizaré los materiales que he escrito para dar este curso en la universidad donde doy clases como profesor. En enero comienzo a dar nuevamente el curso de sistemas operativos, así que tendremos una versión revisada y corregida de esos materiales.

Los resultados de mi tesis de maestría, para el desarrollo de sistemas de tiempo real on FreeRTOS. Esta será una parte avanzada del curso y es probable que no todos estén motivados a seguirla, pero aquellos que lo hagan tendrán una herramienta muy poderosa en sus manos para diseñar sistemas de tiempo real, verificables. Esto quiere decir que si aplicas mi técnica y el compilador no hace cosas raras, tu aplicación no debe fallar por problemas de implementaciones de tu software o por incumplimiento de plazos en sistemas de tiempo real.

El curso se mantendrá totalmente gratuito y abierto a toda la comunidad dentro y fuera de TODOPIC

Saludos
Reinier

[rivale]

Hola reiniert, no habia visto este post, gracias a tu ultimo mensaje vi que existia.

Muchas gracias por compartir informacion, y seguire de cerca lo que pongas relacionado a tu curso.

Saludos

[jeremylf]

Hola mundo con RTOS
Después de teorizar un poco sobre los Sistemas Operativos, vamos a introducirnos en la programación de aplicaciones empleando un RTOS.

En nuestro caso, para comenzar, utilizaremos el RTOS que viene con el compilador de CCS. Las razones de mi elección las expongo a continuación:

• Sencillez en la implementación de aplicaciones
• El RTOS está integrado en el propio compilador de CCS
• Abundante experiencia en el foro con este compilador
• Gran cantidad de dispositivos soportados por el compilador de CCS

Introducción al RTOS de CCS
La versión del compilador que tengo instalada en estos momentos es la 3.249, así que si en versiones posteriores han aparecido nuevas características, les ruego que lo informen para tomar las debidas providencias en el momento oportuno, y comenzar a utilizar esas nuevas características.

El RTOS de CCS es un Sistema Operativo de Tiempo Real que implementa la técnica de multiprocesamiento cooperativo (non preemptive), por lo que es responsabilidad del programador asegurarse de que el control del procesador retorna al planificador de tareas en algún momento. Así que cuando programemos nuestra aplicación, tenemos que asegurarnos de que no llamamos a una función que se queda esperando por algún evento largo como es el caso de gets(), o dentro de un lazo infinito o demasiado extenso.

Planificador de tareas
Uno de los elementos fundamentales de cualquier SO es el planificador de tareas, éste señor es el administrador de nuestros recursos. Su misión fundamental es determinar dentro de las tareas que están listas para ejecutarse, a cuál de ellas le entrega el procesador. La política de planificación empleada por CCS no la conozco, pero eso no importa porque el RTOS funciona y para lo que queremos hacer, nos sirve bien.

Directivas del preprocesador
Existen dos directivas del preprocesador para el uso del RTOS, ellas son:

• #USE RTOS: Se utiliza para indicarle al compilador que se va a utilizar el RTOS
• #TASK: Se utiliza para indicarle al compilador se la función definida a continuación es una tarea a ejecutar por el RTOS

Vamos a ver más detenidamente cada una de las directivas, así como sus parámetros de configuración:
#USE RTOS
Opciones del RTOS:
timer: especifica que temporizador, de los disponibles, es el que se utilizará para la ejecución de las tareas. Este temporizador solamente debe ser utilizado por el RTOS y típicamente se escoge Timer0
minor_cycle: especifica la cantidad de tiempo mínima que una tarea tendrá para ejecutarse, y los tiempos de ejecución de cada tarea deben ser múltiplos de esta cantidad. Si por ejemplo decimos que el tiempo mínimo de ejecución para todas las tareas es de 1ms, debemos conocer que cada tarea se ejecutará, en menos tiempo que este. Lo realmente importante de este dato es que ayuda a establecer la frecuencia con que se ejecutan las tareas, luego veremos un ejemplo de esto. Este parámetro, si no se especifica, es calculado por el compliador en el momento de la compilación.
statistics: le indica al compilador que lleve las estadísticas de las tareas, esto sirve para  conocer que tiempo consume cada tarea en ejecutarse, sin embargo como veremos más adelante, la estadística realmente importante es la que nos indica si nuestra tarea se ha sobrepasado en su tiempo mínimo de ejecución.

#TASK
Opciones para las tareas:
rate: especifica con que frecuencia se ejecuta la tarea, este parámetro debe ser igual a minor_cycle de #use_rtos o un múltiplo de este valor.
max: especifica que cantidad de tiempo debe consumir esta tarea en su ejecución, si se sobrepasa este tiempo y están activadas las estadísticas, entonces esta tarea es marcada con el valor overrun. Este parámetro es útil para informar al programador que una tarea se ha pasado de su tiempo de ejecución, y si el RTOS fuera de tiempo compartido seguramente especificaría el tiempo en que el planificador le retira el procesador para dárselo a otra tarea.
queue: especifica el tamaño de la cola de mensajes de la tarea. Si la tarea no recibe mensajes, entonces debe dejarse en blanco para no consumir memoria RAM innecesariamente.

Hasta aquí hemos visto una pequeña explicación de las directivas para utilizar el RTOS. Sin embargo, la utilidad de esto es mejor verla con un ejemplo.

Funciones del RTOS
EL RTOS de CCS ofrece un conjunto de funciones que veremos cada una en su momento y con sus debidos ejemplos. Sin embargo hoy utilizaremos solamente la función rtos_run(), que le indica al planificador que comience a ejecutar las tareas.

El ejemplo
Se quiere implementar una aplicación en un PIC16F877, donde se utilice el RTOS para transmitir por el puerto serie de este uC, tres cadenas de caracteres. Cada cadena será transmitida desde dentro de una tarea del RTOS y tendrán el formato “Ejecutada tarea #”. Las especificaciones de tiempo del sistema y de cada tarea son las siguientes:

• Temporizador para el RTOS: Timer0
• Tiempo mínimo en que debe ejecutarse una tarea: 10ms
• Frecuencia de ejecución de la Tarea 1: 1seg, tiempo para ejecutar: 10ms
• Frecuencia de ejecución de la Tarea 2: 2seg, tiempo para ejecutar: 5ms
• Frecuencia de ejecución de la Tarea 3: 3seg, tiempo para ejecutar: 250us

El código lo pongo a continuación y posteriormente les doy una explicación:

Código: C++

1. #include "D:\Documentos\Projects\RTOS\RTOS.h"
2. #use rs232(baud=9600,parity=N,xmit=PIN_C6,rcv=PIN_C7,bits=9)
3. #use RTOS(timer=0, minor_cycle=10ms) //temporizador Timer0, tiempo mínimo de ejecución de cada tarea 10ms
4. int8 test;
5.  
6. //Definición de las prototipos de función de las tareas
7. #task (rate=1s, max=10ms)  //Ejecutar cada 1 segundo y consumir como máximo 10ms
8. void Tarea1();
9.  
10. #task (rate=2s, max=5ms)  //Ejecutar cada 2 segundos y consumir como máximo 5ms
11. void Tarea2();
12.  
13. #task (rate=3s, max=250us)  //Ejecutar cada 3 segundo y consumir como máximo 250us
14. void Tarea3();
15.  
16. void main()
17. {
18.    setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);
19.    rtos_run();  //A partir de aquí comenzará la ejecución de las tareas
20.  
21. }
22.  
23. //Implementación de las tareas
24. void Tarea1()
25. {
26.   printf("Ejecutada tarea 1\r");
27. }
28.  
29.  
30. void Tarea2()
31. {
32.   printf("Ejecutada tarea 2\r");
33. }
34.  
35. void Tarea3()
36. {
37.  printf("Ejecutada tarea 3\r");
38. }

Este código funciona y si lo simulan con el Proteus comprobarán que las cadenas salen por el puerto serie. Como pueden ver es un ejemplo sencillo pero que muestra el funcionamiento del RTOS. Al ejecutarlo pueden comprobar que primero se ejecuta la Tarea 1, pero después comprobarán que las tareas no se ejecutan en orden secuencial porque la Tarea 2 se ejecutará cada 2 segundos y la Tarea 3 cada 3 segundos.

La no ejecución secuencial de cada tarea se debe al parámetro rate de la directiva #task, que le dice al planificador con que frecuencia ejecutar cada tarea. Este programa puede ser fácilmente modificado para cualquier aplicación específica, un ejemplo que se me ocurre es la lectura de teclados y eliminación de rebotes.
Como tarea les dejo que elaboren un programa sin el uso del RTOS que haga lo mismo que este.

He echo el mismo ejemplo pero con el RTOS OSA (v110306), un PIC18F258 a 20Mhz y usando el timer2 como temporizador para el RTOS. Estoy con el CCS v.4.134 y simulado con el proteus 7.10.

Código: [Seleccionar]

#include <18F258.h>

#fuses HS, NOWDT, NOPROTECT, NOLVP, NODEBUG, NOBROWNOUT

#use delay (clock = 20 000 000)

#use rs232(baud = 9600, uart1)

#include <osa.h>

void Init (void);
void Tarea1 (void);
void Tarea2 (void);
void Tarea3 (void);


void main (void)
{
   Init();  // Init periphery

   OS_Init(); // Init OS

   OS_Task_Define(Tarea1); // Define tasks.
   OS_Task_Define(Tarea2);      
   OS_Task_Define(Tarea3);      

   OS_Task_Create(0, Tarea1); // Create tasks.
   OS_Task_Create(0, Tarea2);  
   OS_Task_Create(0, Tarea3);    
  
   OS_EI();                            // Enable interrupts

   OS_Run();       // Running scheduler
}

void Init (void)
{  
   // TImer2 used for system ticks
   // post = 4, period = 250*4*5* 0.2 us = 1 ms
   setup_timer_2(T2_DIV_BY_4, (250-1) ,  5);
  
   enable_interrupts(GLOBAL);
   enable_interrupts(INT_TIMER2);
}

// System timer (for system ticks)
#INT_TIMER2
void timer2_isr (void)
{
    OS_Timer();
}

void Tarea1(void)
{
   for (;;)
   {
      printf("Ejecutada tarea 1\r");    
      OS_Delay(1000);
   }
}

void Tarea2 (void)
{
   for (;;)
   {
      printf("Ejecutada tarea 2\r");  
      OS_Delay(2000);
   }
}

void Tarea3 (void)
{
   for (;;)
   {
      printf("Ejecutada tarea 3\r");    
      OS_Delay(3000);
   }
}

Y el OSAcfg.h:

Código: [Seleccionar]

#ifndef _OSACFG_H
#define _OSACFG_H

#define OS_TASKS               3
#define OS_DISABLE_PRIORITY
#define OS_ENABLE_TTIMERS

#endif

Gracias reiniertl.