RTOS para PIC GNU

[Darukur]

Si antes realizaba eso pero no permite modularidad en el proyecto, ya que el .C almacena una porcion de codigo (componente) y el .H es la publicacion hacia afuera de dicho codigo (funciones, variables, definiciones y macros).
Trabajar con un solo .C complica a los compiladores en su tarea de la ubicacion optima del programa-datos en los bancos de memoria ROM del micro.
Intenten hacer un solo .C en compiladores de Hitech o Microchip y veran que no superan la capacidad de un solo banco (el 18F252 tiene 2 bancos de 8Kwords y con un solo .C llegas max a 50% de codigo que son 8Kwords)

Saludos

[kamehouse]

 ! Que padre esta todo esto de verdad ¡ ,esta muy interesante esto del RTOS hace tiempo ya habia tenido contacto con el SALVO
pero no entendi nada asi que lo abandone pero en la practica te encuentras con muchos programas que no son tan simples de manejar de la manera "normal" , y ahora que se ve el gran potencial del "RTOS" gracias por compartir sus conocimientos con los que menos sabemos sobre ese tema ,ya estuve haciendo algunos ejemplos del ccs , y esto a todo dar,hice uno muy sencillo que enviaba datos por el serial ,escribia en la lcd,encendia dos leds en un puerto mientras sacaba un contador por el puerto b. usando un pic 16f877a a 20 mhz. gracias y sigan asi.

[Darukur]

Zaphyrus acordate de pasarme la directiva de compilador para el C30 de manera de parchear el problema que tengo en la "optimizacion no deseada"
Salute y felicitaciones por tu adquisicion "interneteril".
Ahora no apagues mas la maquina, es mas hacete la pagina!

Marcelo

[Zaphyrus]

Darukur, no me acuerdo bien que era lo que precisabas sobre el C30 pero acá está la info para investigarla (la información es para el Atmel AVR pero de todas forma es el mismo compilador GCC):

La directiva __atribute__() con los atributos "signal" y "naked". Creo que necesitas usar el atributo "naked" para evitar que el compilador escriba código para la entrada o salida en la función o interrupción:

Signal:

The '__attribute__ ( ( signal ) )' directive on the function prototype informs the compiler that the function is an ISR and results in two important changes in the compiler output.

   1. The 'signal' attribute ensures that every processor register that gets modified during the ISR is restored to its original value when the ISR exits. This is required as the compiler cannot make any assumptions as to when the interrupt will execute, and therefore cannot optimize which processor registers require saving and which don't.
   2. The 'signal' attribute also forces a 'return from interrupt' instruction (RETI) to be used in place of the 'return' instruction (RET) that would otherwise be used. The AVR microcontroller disables interrupts upon entering an ISR and the RETI instruction is required to re-enable them on exiting.

Naked:

The 'naked' attribute prevents the compiler generating any function entry or exit code. Now compiling the code results in much simpler output

Enlaces:

Signal

Naked

Saludos.

[Darukur]

Gracias tincho lo analizo

Marcelo

[jeremylf]

Q gran tema! 

Espero hablar de lo mismo puesto q ayer me tope con un ejemplo del RTOS que es este:

Código: [Seleccionar]

/////////////////////////////////////////////////////////////////////////
////                     ex_rtos_demo_5_yield.C                                                                           
////  This file demonstrates how to use the real time operating     
////  rtos_yield function.                                     
///////////////////////////////////////////////////////////////////
#include <18F452.h>
#use delay(clock=4000000)
#use rs232(baud=9600,xmit=PIN_C6,rcv=PIN_C7)
#use rtos(timer=0,minor_cycle=100ms)

#task(rate=1000ms,max=100ms,queue=2)
void The_first_rtos_task ( );

#task(rate=500ms,max=100ms,queue=2)
void The_second_rtos_task ( );

void The_first_rtos_task ( ) {
   int count=0;
   // rtos_yield allows the user to break out of a task at a given point
   // and return to the same ponit when the task comes back into context
   while(TRUE){
      count++;
      rtos_msg_send(The_second_rtos_task,count);
      rtos_yield ( );
   }
}

void The_second_rtos_task ( ) {
   if(rtos_msg_poll( ))
   {
      printf("count is : %i\n\r",rtos_msg_read ( ));
   }
}

void main ( ) {
   rtos_run();
}
Y bueno me intereso mucho el tipo de contador q hacia, siendo ya un segundero. El asunto es que intentando comprenderlo viendo cada ejemplo q trae el CCS y pues llege a hacer esto:

Código: [Seleccionar]

#include <18F452.h>
#use delay(clock=4000000)
#use rs232(baud=9600,xmit=PIN_C6,rcv=PIN_C7)
#use rtos(timer=0,minor_cycle=100ms)

#task(rate=1000ms,max=100ms,queue=2)
void The_first_rtos_task ( );

void The_first_rtos_task ( )
{
   long segundos=0,minutos=0,horas=0;
   // rtos_yield allows the user to break out of a task at a given point
   // and return to the same ponit when the task comes back into context
   while(TRUE)
   {
   if(segundos>=59)
      {segundos=0;
      if(minutos>=59)
         {minutos=0;horas++;}
      else
         {minutos++;}
      }
   else
      {segundos++;}
   rtos_yield();
   printf("%lu:%lu:%lu\n\r",horas,minutos,segundos);
      }
}

void main ( )
{
   rtos_run();
}

Esto mantiene las horas, minutos, segundos. Aqui lo escencial es el rtos_yield() q produce los retardos pero nose a base de que.

Quisiera saber si es estamos hablando de lo mismo en lo que es el RTOS porque recien ayer me e involucrado con esto. Y dejando la PC prendida toda la noche comprove q se retraso unos 4 segundos (quiza haya sido culpa del reloj con q probe, no estoy seguro), ahora estoy probando con el de la PC y esta todo bien por ahora.

Que fabuloso tema, justo andaba buscando algo parecid a esto. Espero aprender mucho del RTOS yaq se ve muy interesante.


salu2

[reiniertl]

Vamos por partes, como Jack

Lo primero, la idea de usar un RTOS es que te ahorres el tener que comprender cómo es que está hecho, más bien debes preocuparte por aprender bien cómo utilizarlo. Para ello visita mi hilo "Sistemas Operativo en PIC". Allí encontrarás unas cuantas respuestas a tus dudas.

Lo segundo, un RTOS, no es la mejor variante para implementar un reloj preciso, para ello es mejor que combines tu programa, que te ha quedado bien, con algún reloj serio, como los relojes calenadrios DSxxx que, ya por estos lares han explicado muy bien.

Mezclando ambas cosas tendrás dos cosas buenas: La precisión que aporte el RTC y el uso eficiente de tu PIC al emplear el RTOS.

Un saludo Reinier

[jeremylf]

Si e escuchado hablar de los DSxxx, es mas, ya e pedido algunos q ya deben estar por llegar. Lo q sucede esq quisiera hacer este "reloj" sin usar los DSxxx; e probado con delay_ms y fue un desastre, y creo q el RTOS se acerca a ello solo que hay que echarle mas ganas pues es un avance lo q llevo echo.

Nose si el programa q hice estara bien puesto que se a retrasado 1 segundo (sin seguridad) yaq modifique mucho el codigo. Haber si alguien le echa una ojeada.  Vamos q recien me entero ayer en la noche sobre la existencia del RTOS 


salu2

[Darukur]

La exactitud de los retardos o relojes que implementes con un microcontrolador dependen mucho de las rutinas de interrupción que atienden dicho servicio.
Aunque uses un delay de RTOS o inclusive un Real time clock (movido por tu timer), si tu rutina de interrupcion de timer no se atiende en tiempo y forma, se produciran errores acumulativos.
Yo lo que hago, aunque ajuste segun las relaciones del timer, es realizar pequeñas correcciones por intervalos de tiempo.
Por ej: Si se que el reloj adelanta 10uS cada 1 segundo, lo que hago es agregar dicha correcion por cada segundo.
Esto sirve solo si el error es solo dependiente de la misma interrupcion de reloj, si tu micro no tiene suficiente tiempo para atender las diferentes interrupciones el error no se podra corregir por su naturaleza asincrona.

En microcontroladores como los DSPIC y PIC los relojes son mucho mas faciles de configurar y mas precisos ya que manejan mas opciones en sus PRE y POST SCALERS. Directamente configuras cada cuantos clocks queres que interrumpa.

Saludos

Código: [Seleccionar]

void TIMER_INIT (void)
{CLKDIV=0B0000100001000011 ;//FCY=Fosc/2=Fin/2*(M/(N1*N2))=.5*((10^6*64)/(5*4))=16MIPS,PLLPOST=01=out/4,PLLPRE=11=in/5
 PLLFBD=62;//M=64-2=PLLDIV*64
 OpenTimer1(T1_ON&T1_IDLE_STOP&T1_GATE_OFF&T1_PS_1_1&T1_SYNC_EXT_OFF&T1_SOURCE_INT,16000);//
 ConfigIntTimer1(T1_INT_PRIOR_3&T1_INT_ON); //Int habilitada Prioridad 3
}

void _ISR _T1Interrupt (void) // Interrupción de Timer cada 1 mseg
{IFS0bits.T1IF=0;LMOS_TIMER();}




[reiniertl]

Bien, si quieres hacerlo sólo con RTOS, digamos que para aprender está muy bien, pero te advierto que la idea del RTOS no es la mejor opción para eso porque hay muchas cosas que atentan contra la precisión.

La más simple es que el RTOS de CCS es cooperativo, así que si por ejemplo tienes una tarea que cuenta, digamos decenas de segundos, debe ser atendida cada 10ms, bien. Pero que pasa si una tarea que escribe una trama por el puerto serie demora 11 ms en hacer su trabajo, nada que tendrás un error metido por esa tarea.

Por eso una buena opción es tener un RTC independiente del programa, un RTC hw, al que consultas la hora cada vez que lo necesitas, si tu programa se cuelga y el WD reinicia al uC, no hay problemas porque la hora está en un dispositivo externo, si no puedes consultarlo debidamente, tampoco hay problemas. Esa es la mejor opción para tener precisión.

Si quieres aprender a utilizar RTOS, es muy bueno hacer un reloj. De hecho es una de las mejores aplicaciones que puedes utilizar para llevarlo a cabo. Pero como consejo, te digo que no es una buena opción para hacer una aplicación que deba ser precisa y segura, debes ser muy cuidadoso con eso porque las cosas pueden no salirte bien.

Un saludo Reinier

[jeremylf]

Si entiendo, ya van 4 horas q e dejado prendido la pc conectada por rs232 y se a retrasado 2 segundos.   
Creo q no me queda de otra mas q usar los DSxxx. 

Porcierto nadie sabra como modificar ese codigo q puse para q sea exacto ??? Esq eso de quitarle cada segundo 10us o algo asi nose cmo hacerlo. Haber si alguien le da una ojeadita 


salu2

[Darukur]

Tu codigo no lo vi pero puedo brindarte un ejemplo de correcion del timer mio en un proyecto.
Esta es la macro de atencion de interrupciones del timer

Código: [Seleccionar]

#define R_TIMER_0_REFRESH()\//Esta Macro se llama desde una sola area de código.
{if (TMR0IE&&TMR0IF)\
{TMR0=R_TMR0_C_1;\
if (++R_TIMER_VAR.LAP_MS_CNT>=R_TIMER_V_LAP_CORRECT_MAX)\
{TMR0=R_TMR0_C_2;R_TIMER_VAR.LAP_MS_CNT=0;}\// correccion de tiempo
if (R_TIMER_VAR.LAP_10_MS++==R_TIMER_V_LAP_10MS_MAX)\// Evento cada 10 mS
{OSTimer();R_TIMER_VAR.LAP_10_MS=0;\// Llamo al Tick de sistema
}\
TMR0IF=0;\
}\
}

Despues trabajas sobre las variables de ajuste:

Código: [Seleccionar]

//Constantes
#define R_TMR0_C_1 0xDA //D8:atrasa  D9:atrasa DA:adelanta
#define R_TMR0_C_2 0xD9 //DA:adelanta D9:
//
#define R_TIMER_V_LAP_10MS_MAX 4
#define R_TIMER_V_LAP_CORRECT_MAX 3 //2:atrasa 3:atrasa 4:adelanta 8:adelanta

Como veras cuando haces los calculos de tu reloj siempre tenes un pequeño error acumulativo dependiente de tus opciones de cristal prescaler postcaler, valores de recarga de timer, etc.
Cuando empezas a trabajar con los valores ves por ej que si corres el valor de recarga del timer llega un punto que un valor arriba adelanta y un valor abajo retrasa.
Te quedas con la opcion que menos error produce y trabajas sobre las correcciones mas finas agregando o restando un fino dependiendo el caso.

Te comento que no sera lo mejor pero por ejemplo tengo un reloj en el auto hecho con un PIC 16F818 y lleva casi 2 años y no se ha corrido mas de lo que se me corre mi reloj de muñeca, ya llega un punto que juega el error del cristal.

Saludos

PD: Si queres precision podes optar por un RTC o incluso usar un timer del PIC dedicado con un XTAL de 32Khz externo.

[jeremylf]

Ey muchas gracias, aunq la verdad no lo entiendo muy bien. Aun asi lo tendre muy encuenta, enserio, se agradece. 


salu2

[fedex]

Muy buen trabajo Darukur, me gustaría si puedes subir algún ejemplo para ver si lo puedo entender mejor...

Saludos

[Darukur]

Hola, el thread mas actual de este tema (que esta bastante descontinuado) esta en sistemasembebidos.
Lo que si creo que en el mismo archivo comprimido hay un ejemplo sino lo vemos y publicamos.

Un saludo