el rincón del ccs c -1ª parte

El Rincn del CCS C -1 Parte

PicMana by RedRavenInicio . Mapa . Presentacin . Electrnica Bsica . Experimentos . Proyectos . CCS C . C30 . Invitados . Eagle . Conceptos Datasheets . IC's . USB . Trucos e Ideas . Cajn de Sastre . Recursos . Enlaces . RedPic . Noticias . Histrico . VisitasBuscar

Bsqueda personalizada


El lenguaje C es el que uso por defecto para el 90% de mis programas. Aqu os muestro algunos ejemplos de cmo hacer cosas con este idioma. Todos ejemplos que se muestran en esta seccin se han realizado usando el PCW PICC de CCS (Veriones 3.242 a 4.096 segn depende) Ms CCS C : 1 2 3 4ndice General:

Curso c para PICSCurso-taller c para PIC16f887 Diplomado de programacin de picswww.commtechcomput

Template para el uso de la Interrupcin RTCC mediante el TIMER0 La primera y quizs la mas utilizada de las interrupciones, por ejemplo es la bsica para los Relojes en Tiempo (casi) Real. Template para el uso de la Interrupcin RDA de la USART Utilsima para recibir datos desde el PC mientras nuestro micro se dedica a otra cosa mariposa. Una aplicacin prctica de RTCC : Cronopic 1.0 Contando segundos y minutos con nuestro PIC y mostrndolos sobre 4 displays de 7 segmentos multiplexados. BIN2BCD para enviar nuestros bytes a los Displays de 7 segmentos. Flex LCD una completa librera para manejar un mdulo LCD con la posibilidad de configurar los pines a usar. Modificando el ancho de un pulso, generado con RTCC, mediante ordenes RS-232. O un PWM por Software. Una librera para rastrear un Teclado matricial 4x4

http://picmania.garcia-cuervo.net/picc.php[09/01/2012 01:40:30 p.m.]


Lista para usar (y configurable). Procesador de comandos va RS232 (con Buffer de recepcin) Para dar rdenes con mas enjundia a nuestro PIC Controlando un SERVO con el PIC desde nuestro PC O todo lo que siempre quiso saber sobre los Servomotores y nunca se atrevi a preguntar Strings Demo o como se pueden manejar las cadenas en nuestro PIC No te voy a explicar que sn los punteros o los arrays pero puedes verlos funcionar. RROS v 2.0 La EEPROM interna puesta a nuestro servicio Escribiendo o recuperando datos de la EEPROM interna desde nuestro PC va RS232. Funciones de Date y Time para PIC Coleccin de funciones para manejar Aos, meses, semanas, das, horas, minutos y segundos. Leer y Escribir en la EEPROM interna del PIC variables int 16 bits (2 bytes) Para cuando nuestra variable es mayor que el byte Lib_Int_EEPROM Funciones especiales para Leer y Escribir la EEPROM interna del PIC Para cuando queremos utilizar otras variables distintas al Int8. Rutina de conversin de Nmeros Arbigos a Nmeros romanos Para que nuestro PIC hable en Latn Clsico. Manejando un Array de bits I y Manejando un Array de bits II (simulado en CCS C que no lo implementa) Para que nuestro PIC no desperdicie memoria. Teclado Matricial 4x4 con Driver Analgico Una tcnica para ahorrar pines del pic. Controlando 8 Servos con una sola interrupcin. Una tcnica para conseguir estabilidad y potencia. Teora y Praxis de la Comunicaciones TTL Hablando con el PIC hasta por los codos.

Serie Tcnicas en C: Tcnicas en C : ndice Un punto de entrada a esta nueva serie de artculos. Tcnicas en C : Midiendo un pulso. 1 Parte Midiendo en tiempo que un pulso permanece en alto mediante INTEXT.



Tcnicas en C : Midiendo un pulso. 2 Parte Midiendo en tiempo que un pulso permanece en alto mediante INTCCP en modo Capture. Tcnicas en C : Midiendo un pulso. 3 Parte Midiendo en tiempo que un pulso permanece en alto mediante INTRB. Tcnicas en C : Midiendo un pulso. 4 Parte Midiendo el pulso completo. Periodo y Frecuencia. Tcnicas en C : Generando un pulso. 1 Parte Generando una onda cuadrada simtrica de 2 Khz mediante INTRTCC. Tcnicas en C : Generando un pulso. 2 Parte Generando una onda cuadrada simtrica de 2 Khz mediante INTCCP en modo Compare. Tcnicas en C : Librera de Funciones "tiles" Un artculo muy til sobre funciones tiles y su implementacin en CCS C.

Nota 1: Los Micros usados son el 16F628, el 16F876A y el 18F4550 pero puede ser fcilmente adaptado a otros modelos de PIC. Ocasionalmente se usan tambin los 18F1320 y 18F2550. Todos los tiempos estn calculados para cristales de 4 Mhz y 20 Mhz, salvo en los 18F4550 y 18F2550 en funciones de USB que "corren" a 48 Mhz mediante el PLL interno.

Template para el uso de la Interrupcin RTCC mediante el TIMER0 La interrupcin RTCC se produce cada vez que el contador TIMER0 pasa de FFh a 00h. El TIMER0 hace un cmputo completo de 00h a FFh cada 512 S, sin embargo este tiempo puede ser cambiado mediante un preescaler o sea un divisor, ajustable. Los tiempos generados para cada configuracin son (Ver Nota 1): :2 :4 :8 :16 :32 :64 :128 :256 -> -> -> -> -> -> -> -> 512 1.0 2.0 4.0 8.1 16.3 33.3 66.6 S al mnimo preescaler posible. mS mS mS mS mS mS mS al mximo preescaler posible.



El Template que propongo usa un Preescaler de 128 para producir una interrupcin RTCC cada 33.3 mS y as cada 30 veces que se produce cambio de estado la variable Flag, o sea 33.3 x 30 = 999 mS. Exactamente este Template es el utilizado en el experimento WinkIntc en el que hacemos parpadear un Led cada 0.25 segundos (aproximadamente).

Template para el uso de la Interrupcin RTCC mediante el TIMER0 #include // Selecciona el PIC #fuses XT,NOWDT,NOPROTECT,PUT,BROWNOUT // Opciones de configuracin #use delay(clock=4000000) // Velocidad del Cristal : 4 Mhz byte const NInts=30; para 1 Segundo // VARIABLES GLOBALES char C_Ints=0; ocurridas char Flag=0; interrupciones // Contador de Interrupciones // Flag que cambia cada NInts // Numero de interrupciones

#int_RTCC desbordamiento RTCC_isr() { if(C_Ints > NInts){ ints para 1 Seg. if(Flag==0){ Flag=1; } else{ Flag=0; } C_Ints=0; Ints } ++C_Ints; interrupciones }

// Interrupcin por // del TIMER0 RTCC // Si las ints ocurridas >

// Reinicializo Contador de

// Incremento el nmero de // Ocurridas

void main(void) { setup_counters(RTCC_INTERNAL,RTCC_DIV_128);// TIMER0: Clock Interno, Presescaler 128 setup_timer_1(T1_DISABLED); // para una RTCC cada 33.3 milisegundos setup_timer_2(T2_DISABLED,0,1); // -> 1 Segundo = 30 RTCC setup_comparator(NC_NC_NC_NC);



setup_vref(FALSE); enable_interrupts(INT_RTCC); Interrupcin RTCC enable_interrupts(global); Interrupciones

// Habilito // Habilito

do{ // Bucle infinito if(Flag==K){} else { ... // AQUI HAGO LO QUE DESEE CADA 1 SEGUNDO k=Flag; anterior de Flag } }While(TRUE); } Descargar Template RTCC Haciendo Click sobre la imagen inferior puede verse un momento de la simulacin realizada con el programa anterior haciendo parpadear un Led conectado a PORTB.0. (La simulacin est realizada con el PIC Simulator IDE 5.22 de Oshon Soft) // Guardo estado

// si ha cambiado Flag

Template para el uso de la Interrupcin RDA de la USART La interrupcin RDA se produce cada vez que en la USART hay disponible un carcter para ser ledo. El buffer de recepcin de la USART del PIC 16F628 dispone de solo 2 bytes por lo que es importantsimo el descargarlo tal como se van recibiendo los caracteres, de esta forma evitamos el que se vean tristemente perdidos en el limbo serie.



Este Template demuestra cmo recibir cada carcter que llega hacindole eco desde el programa principal. Si necesitamos recoger muchos caracteres y nuestra rutina principal es larga y farragosa es interesante recibir mediante RDA los caracteres e irlos almacenando en un BUFFER ms amplio para ser posteriormente tratados.

Template para el uso de la Interrupcin RDA de la USART #include // Selecciona el PIC #fuses XT,NOWDT,NOPROTECT,NOLVP,PUT,BROWNOUT // Opciones de configuracin #use delay(clock=4000000) // Velocidad del Cristal : 4 Mhz #use standard_io(b) #use rs232(baud=9600, xmit=PIN_B2, rcv=PIN_B1) // Definicin del RS232 char Keypress=' '; #int_rda void serial_isr() { Keypress=0x00; if(kbhit()){ Keypress=getc(); if(Keypress!=0x00){ putchar(keypress); keypress=0x00; } } }

void main() { enable_interrupts(global); enable_interrupts(int_rda); printf("\r\n\Listen on RS232 (Int)\r\n"); do {

} while (TRUE); } Descargar Template RDA

Una aplicacin prctica de RTCC : Cronopic 1.0 Este artculo nos presenta un mtodo razonable para implementar un cronmetro en nuestro PIC. Hacemos uso en l del Template para el uso de la Interrupcin RTCC mediante el TIMER0 descrito ms arriba as como del Hardware descrito en Hardware de Experimentos : 4 x 7 Segmentos.



Para este ejemplo vamos a cambiar de micro y nos mudamos del 16F628 al 16F876A, aunque nuestro programa funcionara exactamente igual en uno que en otro con solo cambiar el include correspondiente. No estara de ms que le dieses un vistazo al artculo Los Cristales y El Tiempo donde discutimos los clculos que despus vamos a utilizar en nuestro Cronopic 1.0. He intentado comentar suficientemente el cdigo fuente, sin embargo debo explicar al menos que tcnica he seguido para desarrollarlo. El asunto es como sigue: Cronopic 1.0 habilita la interrupcin RTCC usando un Cristal de 4 Mhz y con un Preescaler de 1:256 por lo que se produce un desbordamiento cada 66.6 ms. Con 15 interrupciones de stas tenemos 15 * 66.6 = 999 ms, o aproximadamente un segundo. As que lo que vamos a implementar es un contador de segundos que solo se incrementa cada 15 RTCC's consecutivas. Para esto utilizamos la variable nRTCC que cuando es igual a la constante RTCCxS permite incrementar la variable segundo, que es nuestro contador de segundos transcurridos. Si segundo pasa de 59 incrementamos minuto, y si ste sobrepasa el valor de 59 volvemos a comenzar reinicindolo a 0. Esto dentro de la rutina de tratamiento de la interrupcin RTCC. En el bucle principal, y eterno, dentro de Main() habilitamos una variable ksegundo que si no es igual a segundo nos indica que el segundo actual ha cambiado. Al ocurrir esto disparamos la actualizacin de los valores a sacar por nuestros 7 segmentos. Para ello llamamos a time2bcd() que es la rutina que va a formatear segundo y minuto para que puedan ver visualizados. Inmediatamente hacemos ksegundo igual a segundo para que no volvamos a hacer esto mismo hasta que no cambie el segundo actual, que volveremos a detectar comparndolo con ksegundo. El formateo realizado en time2bcd() consiste en convertir segundo y minuto de sus actuales valores binarios a BCD que es el que acepta el driver de los displays. Esta conversin carga con sus nuevos valores las variables D1 y D2 que son los dgitos Low y Hight en que se convierte segundo y D3 y D4 que son los de minuto. Dentro del bucle principal de main() se llama constantemente a la rutina display_reloj() que es la encargada de poner los valores de D1, D2, D3 y D4 en el driver de los displays. Y eso esto, o casi todo ya que este Cronopic tiene un error de 1 milisegundo por cada segundo contado por lo que no debes tener una fe absoluta en l si tu vida depende de ello. No he querido complicarlo en esta primera versin pero no es difcil compensar este desfase usando el mtodo que he bautizado como pic-bisisesto y que lo realizaremos para versiones posteriores de Cronopic.

Cronopic 1.0 #include // Selecciona el PIC #fuses XT,NOWDT,NOPROTECT,PUT,BROWNOUT // Opciones de configuracin #use delay(clock=4000000) // Velocidad del Cristal : 4 Mhz #use standard_io(B) // PORTB en estandar IO digital #use fixed_io(b_outputs=PIN_B0,PIN_B1,PIN_B2,PIN_B3,PIN_B4,PIN_B5,PIN_B6,PIN_B7) char const RTCCxS=15; // Nmero de RTCC's para 1 segundo con 4 Mhz / 1:256.



// VARIABLES GLOBALES int int int int int int int int int nRTCC=0x00; segundo=0x0; minuto=0x0; D1=0x00; D2=0x00; D3=0x00; D4=0x00; l_digit, h_digit; i; // // // // Contador de interrupciones RTCC completas Segundos del Reloj Minutos del Reloj Contenido de los Displays

// Resultado de la conversin bin2bcd // index general // Funcin que testea los displays // Funcin que muestra el contenido del reloj // Funcin que convierte minutos y segundos a 4 // Funcin que convierte de Binario a BCD // Interrupcin por desbordamiento // del TIMER0 RTCC

void testdisplays(void); void display_reloj(void); void time2bcd(void); x BCD void bin2bcd(int valor); #int_RTCC RTCC_isr() { if(++nRTCC==RTCCxS){ nRTCC=0x00; if(++segundo>59){ segundo=0; if(++minuto>59){ minuto=0; } } } } void main(void) { int ksegundo=0x00;

setup_counters(RTCC_INTERNAL,RTCC_DIV_256); // TIMER0: Clock Interno y Preescaler setup_timer_1(T1_DISABLED); setup_timer_2(T2_DISABLED,0,1); setup_comparator(NC_NC_NC_NC); setup_vref(FALSE); enable_interrupts(INT_RTCC);// Habilito Interrupcin RTCC enable_interrupts(global); // Habilito Interrupciones

do{ // Bucle infinito if(segundo!=ksegundo){ time2bcd(); ksegundo=segundo; } display_reloj(); }While(TRUE); // si cambia el segundo actualizo las // variables con lo que hay que mostrar

// Muestra constantemente



} void display_reloj(void){ // Funcin que muestra el contenido del reloj output_b(D1); output_high(PIN_B4); delay_us(30); output_b(D2); output_high(PIN_B5); delay_us(30); output_b(D3); output_high(PIN_B6); delay_us(30); output_b(D4); output_high(PIN_B7); delay_us(30); } void time2bcd(void){ bin2bcd(segundo); D1 = l_digit; D2 = h_digit; bin2bcd(minuto); D3 = l_digit; D4 = h_digit; } void bin2bcd(int valor){ // Funcin que convierte de Binario a BCD h_digit=0; if (valor>=10){ do{ valor-=10; h_digit++; } while (valor>=10); } l_digit=valor; } // Funcin convierte minutos y segundos a 4 x BCD // Paso de binario a BCD el segundo y actualizo // contenido a mostrar // Paso de binario a BCD el minuto y actualizo // contenido a mostrar // Muestro 1er carcter de segundo

// Muestro 2do carcter de segundo

// Muestro 1er carcter de minuto

// Muestro 2do carcter de minuto

Bin2BCD Cuando queremos utilizar uno de esos drivers para Displays de 7 segmentos que solo aceptan datos en BCD se impone una rutina que nos convierta nuestro byte en tan estrambtico Binary Code Decimal. Ah os dejo una funcin para realizar la necesaria conversin:



Bin2BCD (1): int l_digit, h_digit; // resultado de la conversion bin2bcd

void bin2bcd(int valor){ BCD h_digit=0; if (valor>=10){ do{ valor-=10; h_digit++; }while (valor>=10); } l_digit=valor; }

// Funcion que convierte de Binario a

Una librera para manejar un LCD con los Pines que deseemos: flex_lcd.c Aqui os brindo una librera para manejar un LCD con 4 bits de datos, pudiendo establecer los pines que deseemos para ellos y para los de control E, R/W y RS. Slo hay que modificar los #defines de los mismos. Para usarla solo debis incluir el correpondiente #include "flex_lcd.c" en vuestro programa.

flex_lcd.c // flex_lcd.c // Change these pins to fit your own board. #define #define #define #define LCD_DB4 LCD_DB5 LCD_DB6 LCD_DB7 PIN_B4 PIN_B5 PIN_B6 PIN_B7

#define LCD_RS PIN_C0 #define LCD_RW PIN_C1 #define LCD_E PIN_C2 // If you only want a 6-pin interface to your LCD, then // connect the R/W pin on the LCD to ground, and comment // out the following line. #define USE_LCD_RW 1 //========================================



#define lcd_type 2 // 0=5x7, 1=5x10, 2=2 lines #define lcd_line_two 0x40 // LCD RAM address for the 2nd line

int8 const LCD_INIT_STRING[4] = { 0x20 | (lcd_type

el rincón del ccs c -1ª parte

Documents