Teoría y praxis de las comunicaciones serie TTL con los PIC's 16F/18F en CCS C

[pieromichelle]

En realidad es muy bueno y util todo el material que nos brinda RedPic, pero en el momento que posteaba este hilo (finales del 2008), nadie contesto, ni daba muestras de estar siguiendole y quizas eso lo desanimo pensando que la gente ya estaba desinteresada del hilo. La verdad es que soy uno mas que se une a la lista de fans de RedPic, por la calidad de sus hilos, la buena metodologia y sobretodo por el aporte desinteresado.
GRACIAS REDPIC.
Saludos
Piero

[japifer_22]

hola bueno estoy en las mismas que ustedes y por que nocontinuas REDPIC ?? tus explicaciones y ejemplos son demasiado buenos. te comento que yo como hace 1 año mas menos estoy trabajando en esto de los pic y lamentablemente e tenido que aprender todo esto solo, pero no me quejo al solo leer estos tipos de post que para uno son de gran ayuda y utilidad, aparte que me abren un millon de puertas a nuevas ideas.
bueno te comento que yo e tenido bastante tropiesos con esto de programar pero siempre estan ustedes a la hora de pedir ayuda, ya se que algunas cosas son demasiados basicas paro para otro es como abrir otro mindo. por que te digo esto, bueno estoy tratando ahora mismo con la comunicacion RS-485, pero por motivos de que en mi pais o siudad no lo encontrado el CI voy a tener que emigrar al RS-232, y este post me vino de lujo a la hora de aprender con respecto a esto. buno yo estoy tratando de comunicar 2 pic por este medio (RS-485 ó RS232)y que los 2 se comporten como master7slave. y por eso te pito patudamente que sigas este hilo que esta bastante bueno.
de antemano se despide japifer.
tu admirador secreto jajajajajaj jujajaja broma  pero osea = admiro tus conosimientos y manejo con los pic. bueno salu2s a todos

[jhozate]

  don Diego he aqui una fanaticada ..un club de fans..desde diferentes lugares del mundo

[willie_rosario_salsa]

Gracias por esta inmensa ayuda !!!

De veras admiro tu intereés y paciencia para ilustrarnos a los que sabemos menos.

Estoy en mi proyecto de grado, y en 3 días he podido hacer algunas cositas interesantes con USART y en CCS (sólo usaba MPLAB).

De verdad Gracias amigo 

Saludos desde Guayaquil
Con Salsa,
Julio

[ariznaf]

Pues sí, muy bueno y ayuda un montón, gracias RedPic, me has hecho ver que iba por buen camino.

Yo tento un problema similar: recibir órdenes sencillas desde una linea serie RS485 y procesarlas interpretando los parámetros (si es que el comando va dirigido a esa unidad).

Como los comandos tienen un determinado formato conocido, en mi caso entiendo que mejor que usar un buffer en el que almacenar los comandos y parámetros en la subrutina de interrupción, es que ésta vaya ya interpretando el comando y almacenando los varlores de los parámetros, una solución parecida pero en la que no almaceno los caracteres tal cuál, si no que leo los números en variables (ya que los parámetros son numéricos y se transmiten como números hexadecimales).
Eso me permite ahorrar memoria ¿no creen?

El método de procesar los comandos en la subrutina de interrupción (separando los parámetros) y levantar un flag cuando finaliza el comando, me permite también usar el modo de tiempo real, las subrutinas RTOS del pic.

La subrutina que ha de interpretar los comandos, la meto en un task, y ésta espera en el flag que indica la llegada de un comando, dejando así al procesador que pueda hacer otras cosas en otras tareas task.

Intenté previamente leero los comandos directamente en el task, esperando por el kbhit (rtos_await(kbhit)), pero resultó ser bastente complicado y confuso, ya que no podía partir la subrutina de intérprete de comandos en otras funciones, pues las instrucciones rtos_await únicamente pueden estar directamente metidas en la función declarada como task, y no se pueden poner en ninguna función.

Así que creo que la solución será hacer la interpretación (parsing) de los comandos en la subrutina isr_ad y advertir mediante una variable flagcommand cuando un comando ha finalizado.
En la tarea de ejecución de los comandos, será suficiente con hacer entonces un rtos_await(flagcommand != 0).

[lcullen]

Título : 2.- Un  "echo" interrupto  mediante la interrupción por recepción serie

Objetivos

No tan simple como nuestro anterior ejemplo pero casi. Esta vez vamos a hacer que el eco se produzca de igual forma que anteriormente pero haciendo uso de la interrupción por recepción serie, INT_RDA, que se nos va a disparar cuando nuestro PIC reciba un carácter por dicho canal.

Implementación en C

Para implementarlo en C lo que vamos a hacer es simplemente mover la recepción y reenvio del carácter desde el bucle infinito en el main(), que es donde lo teníamos antes, a una rutina especial que solo se ejecutará cada vez que se reciba un carácter por la USART. Recordad que la función escrita a continuación de la directiva #int_rda será la que se ejecute cuando se dispare dicha interrupción. De ahí que le haya llamado rda_handler o manejador de la interrupción RDA.

Podemos describir lo que vamos a hacer de la forma: Haz lo que te de la gana en el main() porque cuando te avisen de que hay algo pendiente de recibir saldrás de allí y en la rutina de la interrupción lo lees y lo vuelves a enviar, devolviéndote adonde estabas en cuanto termines. 

Programa Fuente

Recuerda que la cabecera es la misma para todos los programas y la tienes descrita en el primer post de esta serie.

Código: C#

1. ///////////////////////////////////////////////////////////////////////////////////////////////////
2. // INTERRUPCIONES : RDA Recepción USART
3. ///////////////////////////////////////////////////////////////////////////////////////////////////
4. #int_rda
5. void rda_handler(void){
6.       putc(getc());              //  recibe el caracter y lo reenvía...
7. }
8. ///////////////////////////////////////////////////////////////////////////////////////////////////
9. // MAIN
10. ///////////////////////////////////////////////////////////////////////////////////////////////////
11. void main() {
12.  
13.    printf("TyP_Serie_TTL\r\n");   // Al inicio escribe para ver que emite correctamente
14.    printf("Method : Interrupt\r\n");
15.  
16.    enable_interrupts(int_rda);    // Habilitamos la interrupción por recepción serie
17.    enable_interrupts(global);     // Habilitamos las interrupciones
18.  
19.    do{                            // Bucle ...
20.  
21.       // Aqui no tenemos nada que hacer ...
22.       // pero podemos hacer lo que queramos.
23.  
24.  
25.    }while(TRUE);                  // ... hasta el infinito.
26. }

Como podéis ver los resultados son idénticos al ejemplo anterior, pero con la inmensa diferencia de que en el bucle infinito del main() podemos escribir cualquier otro código que haga cualquier otra cosa con la seguridad de que al recibir un carácter lo tendremos disponible..



Continuará. 

Hola mira he programado el ejercicio 1 y anda perfecto por lo que entiendo el hardware esta bien. Pero cuando quiero utilizar el ejercicio 2 que es con interrupciones no anda , es decir en el hiperterminal no me devuelve el echo como lo hacia el anterior. Sabes que podra ser? (mi pic es un 16F877A)
saludos y gracias

[lcullen]

Hola mira he programado el ejercicio 1 y anda perfecto por lo que entiendo el hardware esta bien. Pero cuando quiero utilizar el ejercicio 2 que es con interrupciones no anda , es decir en el hiperterminal no me devuelve el echo como lo hacia el anterior. Sabes que podra ser? (mi pic es un 16F877A)
saludos y gracias

[johenrod]

cordial saludo, tan amables me podrian decir que funcion tiene esta parate del codigo

void main() {
 
   delay_ms(2000);           // Espero a estabilizar antes de actuar
 
   // HARD ///////////
   output_low(PIN_E2);
   output_low(PIN_C0);
   output_low(PIN_D7);
   output_low(PIN_E1);
   output_low(PIN_E0);
   output_high(PIN_D1);
   output_high(PIN_D0);
   delay_ms(110);
   output_low(PIN_D0);
   ///////////////////