Imprimir Página - Ejemplitos en C para 16F648A

Microcontroladores PIC => Lenguaje C para microcontroladores PIC => Mensaje iniciado por: vszener en 13 de Agosto de 2005, 16:33:00

Título: Ejemplitos en C para 16F648A
Publicado por: vszener en 13 de Agosto de 2005, 16:33:00

Buenass!!! aqui podreis encontrar programas realizados en C con el compilador de la casa CCS (http://www.ccsinfo.com/) para los microcontroladores PIC (http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=74) de Microchip (http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=64).

En este caso, para los programas se ha utilizado el pic 16F648A (http://www.microchip.com/stellent/idcplgidcplg?IdcService=SS_GET_PAGE&nodeId=1335&dDocName=en010212), se ha usado dicho pic por su precio, por su memoria, sus perifericos.....y porque tenia unos cuantos por aqui tirados sin usar!jeje

INDICE:

1. Parpadeo de un led cada 0,5s (http://www.todopic.com.ar/foros/index.php?topic=4530.msg38848#msg38848)
2. Parpadeo de un led cada 0,5s 16F628A (http://www.todopic.com.ar/foros/index.php?topic=4530.msg38850#msg38850)
3. Parpadeo de tres led"s cada 0,5s (http://www.todopic.com.ar/foros/index.php?topic=4530.msg38852#msg38852)
4. Parpadeo de cuatro led"s cada 0,5s (http://www.todopic.com.ar/foros/index.php?topic=4530.msg38855#msg38855)
5. Coche Fantastico v.I (http://www.todopic.com.ar/foros/index.php?topic=4530.msg38857#msg38857)
6. Coche Fantastico v.II funcion rotar (http://www.todopic.com.ar/foros/index.php?topic=4530.msg38861#msg38861)
7. Coche Fantastico v.III bucle while (http://www.todopic.com.ar/foros/index.php?topic=4530.msg38865#msg38865)
8. Coche Fantastico vIV bucle for (http://www.todopic.com.ar/foros/index.php?topic=4530.msg38866#msg38866)
8. Juego de luces (http://www.todopic.com.ar/foros/index.php?topic=4530.msg38868#msg38868)
10. Luces. Como realizar una libreria (http://www.todopic.com.ar/foros/index.php?topic=4530.msg38870#msg38870)
11. Contador ascendente 0a9 (7seg) (http://www.todopic.com.ar/foros/index.php?topic=4530.msg38872#msg38872)
12. Contador descendente 9a0 (7seg) (http://www.todopic.com.ar/foros/index.php?topic=4530.msg38876#msg38876)
13. Contador reversible 0a9 con switch (7seg) (http://www.todopic.com.ar/foros/index.php?topic=4530.msg38878#msg38878)
14. Contador 00a99. (7seg) uso del TMR0 (http://www.todopic.com.ar/foros/index.php?topic=4530.msg38880#msg38880)
15. Contador 00a99 automatico (7seg) (http://www.todopic.com.ar/foros/index.php?topic=4530.msg38883#msg38883)
16. Contador 0a9 BCD&Boton (http://www.todopic.com.ar/foros/index.php?topic=4530.msg38885#msg38885)
17. Contador 0a9 BCD 2pulsadores(1.Inc 2.Decr) (http://www.todopic.com.ar/foros/index.php?topic=4530.msg38886#msg38886)
18. Super contador 0000a9999 (7seg) (http://www.todopic.com.ar/foros/index.php?topic=4530.msg38888#msg38888)
19. BETI parpadeo (7seg) (http://www.todopic.com.ar/foros/index.php?topic=4530.msg38890#msg38890)
20. AUPA DEPO (7seg) (http://www.todopic.com.ar/foros/index.php?topic=4530.msg38897#msg38897)
21. HOLA rotar hacia izquierda (7seg) (http://www.todopic.com.ar/foros/index.php?topic=4530.msg38899#msg38899)
22. Animacion limites (7seg) (http://www.todopic.com.ar/foros/index.php?topic=4530.msg38903#msg38903)
23. Dado digital (7seg) (http://www.todopic.com.ar/foros/index.php?topic=4530.msg38904#msg38904)
24. Hola mundo (LCD) (http://www.todopic.com.ar/foros/index.php?topic=4530.msg38907#msg38907)
25. Hola mundo ahorrando 1 pin (LCD) (http://www.todopic.com.ar/foros/index.php?topic=4530.msg38909#msg38909)
26. Abecedario (LCD) (http://www.todopic.com.ar/foros/index.php?topic=4530.msg38912#msg38912)
27. Mover palabra por pantalla LCD (http://www.todopic.com.ar/foros/index.php?topic=4530.msg38916#msg38916)
28. Limites LCD (http://www.todopic.com.ar/foros/index.php?topic=4530.msg38922#msg38922)
29. Escribir&Leer eeprom interna del pic (LCD) (http://www.todopic.com.ar/foros/index.php?topic=4530.msg38923#msg38923)
30. Contador 0a9 buzzer&boton (LCD) (http://www.todopic.com.ar/foros/index.php?topic=4530.msg38925#msg38925)
31. Escribir&Leer eeprom 24LC256 (LCD) (http://www.todopic.com.ar/foros/index.php?topic=4530.msg38929#msg38929)
32. Dado digital (LCD) (http://www.todopic.com.ar/foros/index.php?topic=4530.msg38931#msg38931)
33. Reloj-Calendario DS1302 (LCD) (http://www.todopic.com.ar/foros/index.php?topic=4530.msg38943#msg38943)
34. RS232: PIC->PC (http://www.todopic.com.ar/foros/index.php?topic=4530.msg38946#msg38946)
35. Reloj-Calendario RS232 (http://www.todopic.com.ar/foros/index.php?topic=4530.msg38948#msg38948)
36. RS232 & teclado 3x4 (http://www.todopic.com.ar/foros/index.php?topic=4530.msg38951#msg38951)
37. LCD & Teclado 3x4 (http://www.todopic.com.ar/foros/index.php?topic=4530.msg38954#msg38954)
38. Clave (LCD&Teclado 4x4) (http://www.todopic.com.ar/foros/index.php?topic=4530.msg38958#msg38958)
39. RS232: PC->PIC (http://www.todopic.com.ar/foros/index.php?topic=4530.msg38961#msg38961)
40. Manejo INT/RB0 interrupcion externa (http://www.todopic.com.ar/foros/index.php?topic=4530.msg38962#msg38962)
41. Manejo ccp1 mod.comparacion flanco asc/des genera int (http://www.todopic.com.ar/foros/index.php?topic=4530.msg38981#msg38981)
42. Animacion bateria lcd2x16 (http://www.todopic.com.ar/foros/index.php?topic=4530.msg38985#msg38985)
43. Animacion come-cocos RS232->lcd 2x16 (http://www.todopic.com.ar/foros/index.php?topic=4530.msg38987#msg38987)
~~44. Temperatura con ds1620 BETA (http://www.todopic.com.ar/foros/index.php?topic=4530.msg39003#msg39003)~~
45. Manejo del periferico CCP1 modo PWM (http://www.todopic.com.ar/foros/index.php?topic=4530.msg39007#msg39007)
46. CCP1 modo PWM al 50% y 75% utilizacion y creacion .h (http://www.todopic.com.ar/foros/index.php?topic=4530.msg39017#msg39017)
47. C & ASM (http://www.todopic.com.ar/foros/index.php?topic=4530.msg39023#msg39023)
48. Interrupcion de los pines <4:7> portb (http://www.todopic.com.ar/foros/index.php?topic=4530.msg39025#msg39025)
49. Abecedario(1 Matriz de led"s 5x7) (http://www.todopic.com.ar/foros/index.php?topic=4530.msg39041#msg39041)
50. Reloj digital(display"s 7seg) (http://www.todopic.com.ar/foros/index.php?topic=4530.msg39054#msg39054)
51. Interrupcion RS-232. Lectura/Escritura eeprom interna (http://www.todopic.com.ar/foros/index.php?topic=4530.msg39057#msg39057)
52. Interrupcion RS-232. Lectura/Escritura eeprom 24LC256 (http://www.todopic.com.ar/foros/index.php?topic=4530.msg39059#msg39059)
53. SAA1064 modo DINAMICO (http://www.todopic.com.ar/foros/index.php?topic=4530.msg39063#msg39063)
54. SAA1064 modo ESTATICO (http://www.todopic.com.ar/foros/index.php?topic=4530.msg39067#msg39067)
55. PCF8591 modo D/A (http://www.todopic.com.ar/foros/index.php?topic=4530.msg39082#msg39082)
56. PCF8591 modo A/D (http://www.todopic.com.ar/foros/index.php?topic=4530.msg39093#msg39093)
57. Manejo 16 display's 7seg con dos pines del micro (4 SAA1064 en bus i2c) (http://www.todopic.com.ar/foros/index.php?topic=4530.msg68378#msg68378)
58. Termometro digital con ds1620 (http://www.todopic.com.ar/foros/index.php?topic=4530.msg68549#msg68549)

HERRAMIENTAS:

MPlab IDE (http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=1406&dDocName=en019469&part=SW007002) -> Entorno de trabajo
CCS Plug-in MPlab (http://www.ccsinfo.com/downloads.php) -> Integrar nuestro compilador CCS al entrono MPlab
CCS Demo (http://www.ccsinfo.com/content.php?page=compdemo) -> Una version demo de nuestro compilador
Como integrar CCS en Proteus (http://www.todopic.com.ar/foros/index.php?topic=12184.0) -> CCS en PROTEUS
Como simular CCS en Proteus (http://www.todopic.com.ar/foros/index.php?topic=12185.new#new) -> Debug con codigo .c
CCS manual (http://www.ccsinfo.com/downloads.php) -> Manual CCS en ingles(ultima version)
Manual CCS (http://www.box.net/shared/khtawd0o4s) -> Manual de nuestro compilador en español
7Seg (http://www.todopic.com.ar/foros/index.php?topic=7042.0) -> Programa que genera el codigo de display"s 7segmentos(ac & cc)
LCD 5x7 (http://www.todopic.com.ar/foros/index.php?topic=7042.0) -> Programa que genera codigo para caracteres cgram LCD 5x7
ASCII & RCC (http://www.todopic.com.ar/foros/index.php?topic=7042.0) -> Programas para obtener codigo ASCII y RCC para colores resistor

REVISIONES:

1. El programa 51 es la revision del programa 29
2. El programa 52 es la revision del programa 31

Recordar que estos programas fueron pensados para usar las funciones del compilador CCS manejando los perifericos del pic, por lo tanto, estos programas son validos para cualquier pic, eso si, con las modificaciuones oportunas y sus respectivas especificaciones y limitaciones del propio pic!

PD: Aqui os dejo un enlace a mi disco duro virtual para la descarga completa de los programitas y demas cosas!!! VsZeNeR-Disco Duro Virtual (http://www.box.net/shared/4l7bedpqrz)

Suerte!!! :wink:

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 13 de Agosto de 2005, 16:38:00

El primer ejemplo como no!!! la iluminacion de un led!!!jeje alguien alguna vez a visto programa similar???jeje bueno fuera de bromas por alguno hay que empezar y este es el nivel inferior jeje. El programa consiste en el encendido y apagado d eun led cada 0.5s por el pin RB0 del pueto B:

////////////////////////////////////////////////////////////////////////////////////
//   VsZeNeR"05
// 6/Agosto/05
//
//Programa:   Parpadeo de un led cada 0.5s
//Version:   0.0
//
//Dispositivo: PIC 16F648A      Compilador:    CCS vs3.227
//Entorno IDE: MPLAB IDE v7.20   Simulador:    Proteus 6.7sp3
//
//Notas: Parpadeo de un led cada 0.5s por el pin RB0 del puerto B
//////////////////////////////////////////////////////////////////////////////////

#include <16f648a.h>         //pic a utilizar
#fuses XT,NOWDT,NOPROTECT,PUT      //ordenes para el programador
#use delay (clock=4000000)         //Fosc=4Mhz
#use fast_io(b)

///PROGRAMA
void main(void)
{
   set_tris_b(0xFE);   //portb como salida(RB0,las demas desactivadas)
   disable_interrupts(GLOBAL);   //todas las interrupciones desactivadas

   do{
      output_low(PIN_B0); //led off
      delay_ms(500);
      output_high(PIN_B0); //led on
      delay_ms(500);
   }while(TRUE);       //bucle infinito
}

Seguimos en contacto! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: LordLafebre en 14 de Agosto de 2005, 00:30:00

Hola:

Que bien.... con ejemplos es como a mi parecer se aprende mas rapido.... yo tambien estoy colgando ejemplos pero en el foro PBP y PROTON+, estaba queriendo aprender a programar en C, ya tengo el compilador y ahora solo queda seguir uno a uno los ejemplos que vayas colgando... y de ves en cuando o si no es muy seguido ire haciendote preguntas de "NOVATO", puedo este mismo programa utilizarlo para un pic 16F628...?

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 14 de Agosto de 2005, 05:35:00

Hola lordlafebre!!!por supuesto que puedes ir haciendo preguntas, asi entre todos podremos aprender juntos jeje(que bien suena), bueno con respecto hacia el pic 16F628 decirte que microchip sugiere que utilicemos la version 16F628A y claro que se puede utilizar este ejemplito para el pic que mencionaste, solamente tendremos que adecuarlo a sus necesidades, y esta vez adecuarlo es bastante facil, solamente tendremos que cambiar el include a nustro pic seleccionado(para asi poder utilizar las variables y funciones definidas para este dispositivo) y nada mas!!!!(nada mas por ser el ejmeplito muy facil jeje en otros dsipositivos tendriamos que ver si tienen los mismos perifericos etc), y aqui esta el programa modificado para el PIC 16F628A:

////////////////////////////////////////////////////////////////////////////////////
//      VsZeNeR"05
//    14/Agosto/05
//
//Programa:   Parpadeo de un led cada 0.5s
//Version:   0.0 revision del 16F628a
//
//Dispositivo: PIC 16F628A      Compilador: CCS vs3.227
//Entorno IDE: MPLAB IDE v7.20   Simulador: Proteus 6.7sp3
//
//Notas: Parpadeo de un led cada 0.5s por el pin RB0 del puerto B
//////////////////////////////////////////////////////////////////////////////////

#include <16f628a.h>         //pic a utilizar
#fuses XT,NOWDT,NOPROTECT,PUT      //ordenes para el programador
#use delay (clock=4000000)         //Fosc=4Mhz
#use fast_io(b)

///PROGRAMA
void main(void)
{
   set_tris_b(0xFE);   //portb como salida(RB0,las demas desactivadas)
   disable_interrupts(GLOBAL);   //todas las interrupciones desactivadas

   do{
      output_low(PIN_B0);   //led off
      delay_ms(500);
      output_high(PIN_B0);   //led on
      delay_ms(500);
   }while(TRUE);         //bucle infinito
}

Decir que aqui esta el enlace a la pagina que microchip a dedicado para el dispositivo 16F628a:
http://www.microchip.com/stellent/idcplgidcplg?IdcService=SS_GET_PAGE&nodeId=1335&dDocName=en010210
Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 14 de Agosto de 2005, 05:44:00

Desde esta direccion se podeis descargas el programa en c, el archivo hex y la simulacion en proteus

Suerte!!! :wink:

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 14 de Agosto de 2005, 05:49:00

Aqui otro ejemplito mas de led"s, esta vez como encender tres led"s por el port b de tres formas distintas...asi podreis elegir la que os guste mas jeje:

////////////////////////////////////////////////////////////////////////////////////
//      VsZeNeR"05
//      6/Agosto/05
//
//Programa: Parpadeo de tres leds cada 0.5s
//Version:   0.1
//
//Dispositivo: PIC 16F648A      Compilador: CCS vs3.227
//Entorno IDE: MPLAB IDE v7.20   Simulador: Proteus 6.7sp3
//
//Notas: Parpadeo de tres leds cada 0.5s de tres formas diferentes:
//   RB0 -> con la funcion output_high()/output_low()
//   RB1 -> definiendo el pin RB1
//   RB2 -> con la funcion output_bit()
//////////////////////////////////////////////////////////////////////////////////

#include <16f648a.h>   //pic a utilizar
#fuses XT,NOCPD,NOWDT,NOPUT,NOLVP,NOBROWNOUT //ordenes programador
#use delay (clock=4000000)   //Fosc=4Mhz
#use fast_io(b)
#bit RB1=0x106.1   //definicion pin potrb B1

///PROGRAMA
void main(void)
{
   set_tris_b(0xF8);   //puerto b como salida
   disable_interrupts(GLOBAL);   //todas interrupciones desactivadas

   RB1=0;   //valor inicial B1 para que los led"s se iluminen igual
   do{
      output_high(PIN_B0); //led"s on
      RB1=!RB1;
      output_bit(PIN_B2,1);
      delay_ms(500);

      output_low(PIN_B0); //led"s off
      RB1=!RB1;
      output_bit(PIN_B2,0);
      delay_ms(500);
      }while(TRUE);    //bucle infinito
}

Ya vamos manejando esto de los led"s jeje..... Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 14 de Agosto de 2005, 05:54:00

En esta dire podeis descargaros los archivos: c, hex, dsn(proteus) del programa anterior del encendido de tres led"s de tres formas diferentes

http://miarroba.com/foros/ver.php?foroid=348538&temaid=3484219

Pokito a poko la "juani" me volvio loko!!!jeje Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: LordLafebre en 14 de Agosto de 2005, 11:24:00

Hola:

Va quedando claro los ejemplos, solo dos preguntitas:

set_tris_b(0xF8); para configurar el puerto como entradas o salidas puedo utilizar valores binarios y decimales..? o solo lo puedo hacer en Hex...?

RB1=!RB1; aqui no me a quedado clara esta asignacion porque se utiliza en signo de admiracion...?

Lo siento si mis preguntas son un poco tontas pero de C no "C NADA" Llorica

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 14 de Agosto de 2005, 12:37:00

Ke pasa lordlafebre!!!jeje haber lo del set_tris_b....se puede utilizar el formato que quieras eso si, siempre que uses la directiva adecuada:
·Para HEXADECIMAL: 0xNUMERO_HEXADECIMAL -> 0x00
·Para DECIMAL: EL_NUMERO_DECIMAL -> 0
·Para BINARIO: 0bNUMERO_BINARIO -> 0b000000
Aunque aconsejo que uses la hexadecimal que es la mas usada, pero la forma binaria es util para solamente elegir ciertos pines!!!!.
Bien sobre lo del comando RB1=!RB1 decirte que realiza la negacion logica, es decir si RB1=0 entonces cuando llega a realizarse la instruccion RB1=!RB1 sera RB1=1, el simbolito ! cumple la funcion de complemento igual que la funcion comf f,d en el esamblador.
Bien revisando el codigo del parpadeo de los tres led"s de tres formas distintas, decir que se me olvido una cuarta formaa diistinta de encenderlos!!!!jeje aqui va el programa completo de como encender 4 led"s de 4 formas distintas:

////////////////////////////////////////////////////////////////////////////////////
//   VsZeNeR"05
// 14/Agosto/05
//
//   Programa:   Parpadeo de cuatro leds cada 0.5s
//   Version:   0.2
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.227
//   Entorno IDE: MPLAB IDE v7.20      Simulador:    Proteus 6.7sp3
//
//   Notas: Parpadeo de cuatro leds cada 0.5s de cuatro formas diferentes:
//            RB0 -> con la funcion output_high()/output_low()
//            RB1 -> definiendo el pin RB1
//            RB2 -> con la funcion output_bit()
//            RB3 -> con la funcion bit_set()/bit_clear()
//////////////////////////////////////////////////////////////////////////////////

#include <16f648a.h>            //pic a utilizar
#fuses XT,NOCPD,NOWDT,NOPUT,NOLVP,NOBROWNOUT      //ordenes para el programador
#use delay (clock=4000000)         //Fosc=4Mhz
#use fixed_io(b_outputs=PIN_B0,PIN_B1,PIN_B2,PIN_B3) //pin de salida portb
#bit RB1=0x106.1               //definicion pin potrb B1
#byte portb=06

///PROGRAMA
void main(void)
{
   set_tris_b(0x00);            //puerto b como salida
   disable_interrupts(GLOBAL);      //todas interrupciones desactivadas

   RB1=0;                     //valor inicial B1 para que los led"s se iluminen igual
   do{
      output_high(PIN_B0);      //led"s on
      RB1=!RB1;
      output_bit(PIN_B2,1);
      bit_set(portb,3);
      delay_ms(500);

      output_low(PIN_B0);         //led"s off
      RB1=!RB1;
      output_bit(PIN_B2,0);
      bit_clear(portb,3);
      delay_ms(500);
      }while(TRUE);            //bucle infinito
}

Jeje..ya no hay excusas de poder encender un led ennnn jeje Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 14 de Agosto de 2005, 12:42:00

Aqui esta el enlace para descargaros el archivo en c, hex y el dsn(para proteus) del programa anterior: parpadeo de cuatro led"s de cuatro formas diferentes

Suerte!!! :wink:

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 14 de Agosto de 2005, 12:52:00

Una mas de led"s jeje!!!¿quien no vio la serie de tv del coche fantastico??¿quien no soño algun dia con tener uno?¿quien no hablo alguna que otra vez al volante del coche haber si le respondia Kit?? jeje (yo le hababa en su momento al coche de mi papi un opel corsa de los antiguos jeje peor nunca me respondio Enfurruñado

), pues el siguiente ejemplito va dedicado a las luces del coche fantastico, ese movimiento de un lateral a otro y viceversa:

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"04
//                   7/Agosto/05
//
//   Programa:   Coche Fantastico
//   Version:   0.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.227
//   Entorno IDE: MPLAB IDE v7.20      Simulador:    Proteus 6.7sp3
//
//   Notas: Barrido de led"s simulando la iluminacion del coche fantastico por el
//       puerto A
//
//            RA0 -> 1º Led
//            RA1 -> 2º Led
//            RA2 -> 3º Led
//            RA3 -> 4º Led
//////////////////////////////////////////////////////////////////////////////////

#include <16f648a.h>            //pic a utilizar
#fuses XT,NOWDT,NOPROTECT,PUT      //ordenes para el programador
#use delay (clock=4000000)         //Fosc=4Mhz
#use standard_io(A)               //puerto A como salida

///DECLARACIONES DE FUNCIONES
void derecha(void);               //ilumina led"s derecha a izquierda
void izquierda(void);            //ilumina led"s izquierda a derecha

///PROGRAMA
void main(void)
{
   set_tris_a(0xF0);            //porta como salida menos RA4(desactivado)
   disable_interrupts(GLOBAL);      //todas las interrupciones desactivadas

   do{                        //bucle...
      derecha();
      izquierda();
      }while(TRUE);            //...infinito
}

void derecha(void)
{
   output_high(PIN_A0);
   delay_ms(300);
   output_low(PIN_A0);
   output_high(PIN_A1);
   delay_ms(300);
   output_low(PIN_A1);
   output_high(PIN_A2);
   delay_ms(300);
   output_low(PIN_A2);
   output_high(PIN_A3);
   delay_ms(300);
}

void izquierda(void)
{
   output_low(PIN_A3);
   output_high(PIN_A2);
   delay_ms(300);
   output_low(PIN_A2);
   output_high(PIN_A1);
   delay_ms(300);
   output_low(PIN_A1);
}

Pondre el mismo programa pero realizado de otra manera.....Kit!!!te necesito! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 14 de Agosto de 2005, 12:57:00

De esta direccion podeis descargaros los ficheros c,hex y el dsn(proteus) del programa anterios: coche fantastico I

Que alegria que alboroto......toma otro perrito pilotooo!!! :wink:

Título: RE: Ejemplitos en C para 16F648A
Publicado por: LordLafebre en 14 de Agosto de 2005, 13:49:00

Hola:

Una cosita mas que no me a quedado claro es esto:

#bit RB1=0x106.1

Que es lo que hace?

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 14 de Agosto de 2005, 14:19:00

La instruccion #bit RB1=0x106.1 define el pin RB1 del portb, si vas al data sheet del micro:
http://www.microchip.com/stellent/idcplgidcplg?IdcService=SS_GET_PAGE&nodeId=1335&dDocName=en010212
y miras en el mapa de memoria del portb veras que se puede definir el portb como la direccion 06h o la 106h, y veras que el pin RB1 es el bit 1 de dicho puerto, por lo tanto para definir el pin RB1 primero decimos que puerto queremos definir, en este caso el puerto b (ponemos 0x106) y despues definimos el pin seleccionado, en este caso el pin RB1(ponemos un puntito para especificar el pin y su bit que le corresponde, en este caso la instruccion quedaria asi: 0x106.1) y para poder manejarlo en el programa definimos un bit con la instruccion en c #bit, y todo en total quedara #bit RB1=0x106.1....asi se define el portb y concretamente un bit concreto(en este caso el RB1), asi tendremos definido el pin RB1 del portb para poder manejarlo en nuestro programa!, si me he explicado mal dimelo!!!!jeje Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 14 de Agosto de 2005, 14:25:00

Bien lo prometido es deuda!!!jeje aqui pongo otra forma d hacer el colorido del coche fantastico con led"s......las cosas con estos cacharros no s elimitan a una sola manera sino a las maneras x-proporcionales de los que se paran a pensarlo jeje pos aqui esta:

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"05
//                   12/Agosto/05
//
//   Programa:   Coche Fantastico
//   Version:   1.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.227
//   Entorno IDE: MPLAB IDE v7.20      Simulador:    Proteus 6.7sp3
//
//   Notas: Barrido de led"s simulando la iluminacion del coche fantastico por el
//       puerto B por medio de la instruccion de rotar.
//
//            RB0 -> 1º Led
//            RB1 -> 2º Led
//            RB2 -> 3º Led
//            RB3 -> 4º Led
//////////////////////////////////////////////////////////////////////////////////

#include <16f648a.h>            //pic a utilizar
#fuses XT,NOWDT,NOPROTECT,PUT      //ordenes para el programador
#use delay (clock=4000000)         //Fosc=4Mhz
#use standard_io(B)               //puerto B como salida
#byte portb= 0x6               //direccion port b

///PROGRAMA
void main(void)
{
   int led_on=0b0001;            //led a iluminar
   set_tris_b(0xf0);            //portb como salida (algunas desactivadas)
   disable_interrupts(GLOBAL);      //todas las interrupciones desactivadas

   do{                        //bucle...

      do{      //iluminacion hacia izquierda
         portb=led_on;
         rotate_left(&led_on,1);
         delay_ms(300);
         }while(bit_test(led_on,3)==0);

      do{      //iluminacion hacia derecha
         portb=led_on;
         rotate_right(&led_on,1);
         delay_ms(300);
         }while(bit_test(led_on,0)==0);

      }while(TRUE);            //...infinito
}

La diferencia con el otro es que se ha utilizado una variable y sa usado la funcion de rotar hacia la derecha y hacia la izquierda... Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: RaDoN en 14 de Agosto de 2005, 14:27:00

El programa de las luces del coche fantastico, seria mas facil rotando los bits del puerto en que esten los leds. Si estamos con el puerto B por ejemplo (y 8 leds).

Encendemos el led de rb0 y rotamos (<< Giño

a la izquierda 7 veces, por ejemplo con un for, y luego a la derecha otras 7 (>> Giño

y todo dentro de un buque (while(1)). Creo que así es mas sencillo y eficaz que ir encendiendo/apagando led a led con "output_bit".

Si alguien esta interesado subo el programa, pero weno, es una chorrada Payaso

Edito: woo, esta puesto arriba, posteamos a la vez jeje Avergonzado

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 14 de Agosto de 2005, 14:29:00

De aqui os podeis descargar la otra forma del programa coche fantastico

Kit!!!!!!super turbooo!!!jeje :wink:

Título: RE: Ejemplitos en C para 16F648A
Publicado por: LordLafebre en 14 de Agosto de 2005, 14:47:00

Hola:

Amigo vszener perdon por meter basic en la seccion C pero me interesaria ir comparando los ejemplos en basic y en C, yo tengo hecho un ejemplo en basic que es este:

I var byte
cont var word

TRISB=0

inicio:
cont=1
for i=1 to 7
PORTB=cont
pause 100
cont=cont*2
next I
for i=1 to 7
PORTB=cont
pause 100
cont=cont/2
next I
goto inicio
end

Es para hacer el juego de luces del auto fantastico.... con 8 leds conectados al puerto B...

La descripcion del programa es el siguiente:

Tiene un bucle infinito que es inicio: GOTO inicio...y para la secuencia de luces hice un bucle que generelos valores 1-2-4-8-16-32-64-128 eso lo hago multiplicando la variable cont que empieza en 1 y luego se va multiplicando *2 i asi obtengo los valores, luego estos valores los asigno al puerto B y voy obteniendo la secuencia con la intruccion PORTB=dato... como puedo hacerlo en C de esta manera...

Quiero ir aprendiendo de acuerdo a los ejemplos que yo he ido haciendo... Digo si no es mucha molestia...!

Y una preguntita mas:

xq en algunas ocaciones utilizas esto: #use standard_io(B)
y en otras esto...................................: #use fast_io(b)

Tenme un poco de paciencia porfis.....!!!!!!!!!!!!!! Sonrisa Gigante

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 14 de Agosto de 2005, 16:17:00

La adaptacion del codigo en basic que escribiste en c es la siguiente:

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"05
//                   14/Agosto/05
//
//   Programa:   Coche Fantastico
//   Version:   2.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.227
//   Entorno IDE: MPLAB IDE v7.20      Simulador:    Proteus 6.7sp3
//
//   Notas: Barrido de led"s simulando la iluminacion del coche fantastico por el
//       puerto B. Adaptacion del codigo en basic de lordlafebre
//
//            RB0 -> 1º Led
//            RB1 -> 2º Led
//            RB2 -> 3º Led
//            RB3 -> 4º Led
//            RB4 -> 5º Led
//            RB5 -> 6º Led
//            RB6 -> 7º Led
//            RB7 -> 8º Led
//       En la variable cont se va almacenando los valores 1-2-4-8-16-32-64-128
//       que en binario corresponden a la secuencia 00000001-00000010-00000100...
//       son los led"s a iluminar, coincidiendo con la secuencia de iluminacion
//       del coche fantastico(version Ecuatoriana: auto fantastico)
//////////////////////////////////////////////////////////////////////////////////

#include <16f648a.h>            //pic a utilizar
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP      //ordenes para el programador
#use delay (clock=4000000)         //Fosc=4Mhz
#use standard_io(B)               //puerto B como salida

///PROGRAMA
void main(void)
{
   int i,cont;                  //variables definidas
   set_tris_b(0x00);            //portb como salida
   disable_interrupts(GLOBAL);      //todas las interrupciones desactivadas

   do{                        //bucle...
      cont=1;                  //inicializar...
      i=1;                  //...variables

      do{                     //led"s on derecha
         output_b(cont);         //ilumino led correspondiente
         delay_ms(100);
         cont=cont*2;
         i++;               //incremento i
         }while(i<8);

      i=1;                  //reset valor i

      do{                     //led"s on izquierda
         output_b(cont);         //ilumino led correspondiente
         delay_ms(100);
         cont=cont/2;
         i++;               //incremento i
         }while(i<8);

      }while(TRUE);            //...infinito
}

He cambiado los dos bucles for que en basic estan escritos por dos while....el cambio la verdad lo he realizado porque con los bucles for me da un problema y no se de ke es!!!!jeje puede ser un bug del compilador al tratar la segunda asignacion del for o puede ser un bug en mi cabeza jeje(todo es posible).
Con respecto a tu pregunta de porque algunas veces pongo #use standard_io(B) y otras veces pongo #use fast_io(b) es simplemente segun la asignacion que le quiero dar al puerto en cuestion a tratar(en este caso el B), la #use standar_io() declara el puerto seleccionado como entrada y salida mientras que la otra debes configurar la accion especifica de cada pin del puerto(si tienen comparadores,interrupciones,etc), una cosita mas respecto a esta pregunta es que la asignacion #use fast_io() da problemas muchas veces y cuando vas a simular el programa ves que los puertos no responden como quisiera, por lo tanto recomendarte que uses la primera #use standard_io() aunque mirate el manual que lo explica mejor que yo jeje si tienes alguna duda ya sabes!!! :wink:

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 14 de Agosto de 2005, 16:27:00

Jeje al final era un bug de mi cabezita......ainssssss jeje aqui esta el codigo adaptado en c con las mismas sentencias que tu codigo en basic!!!!

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"05
//                   14/Agosto/05
//
//   Programa:   Coche Fantastico
//   Version:   2.1
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.227
//   Entorno IDE: MPLAB IDE v7.20      Simulador:    Proteus 6.7sp3
//
//   Notas: Barrido de led"s simulando la iluminacion del coche fantastico por el
//       puerto B. Adaptacion del codigo en basic de lordlafebre
//
//            RB0 -> 1º Led
//            RB1 -> 2º Led
//            RB2 -> 3º Led
//            RB3 -> 4º Led
//            RB4 -> 5º Led
//            RB5 -> 6º Led
//            RB6 -> 7º Led
//            RB7 -> 8º Led
//       En la variable cont se va almacenando los valores 1-2-4-8-16-32-64-128
//       que en binario corresponden a la secuencia 00000001-00000010-00000100...
//       son los led"s a iluminar, coincidiendo con la secuencia de iluminacion
//       del coche fantastico(version Ecuatoriana: auto fantastico)
//////////////////////////////////////////////////////////////////////////////////

#include <16f648a.h>            //pic a utilizar
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP      //ordenes para el programador
#use delay (clock=4000000)         //Fosc=4Mhz
#use standard_io(B)               //puerto B como salida

///PROGRAMA
void main(void)
{
   int i,cont;                  //variables definidas
   set_tris_b(0x00);            //portb como salida
   disable_interrupts(GLOBAL);      //todas las interrupciones desactivadas

   do{                        //bucle...
      cont=1;                  //inicializar...

      for(i=1;i<8;i++){         //led"s on derecha
         output_b(cont);         //ilumino led correspondiente
         delay_ms(100);
         cont=cont*2;
         }

      for(i=1;i<8;i++){
         output_b(cont);         //ilumino led correspondiente
         delay_ms(100);
         cont=cont/2;
         }

      }while(TRUE);            //...infinito
}

Miratelo y me rpeguntas lo que no entiendas okis???? :wink:

Título: RE: Ejemplitos en C para 16F648A
Publicado por: LordLafebre en 14 de Agosto de 2005, 22:27:00

Hola:

Vamos bien, con estos ejemplos voy aprendiendo rapidoconosco los comandos de C++ (for,while,switch....).... aqui tengo otro ejemplo de luces que a diferencia del otro que iva de derecha a izquierda y viceversa ahora este juego de luces empieza desde los extremos al centro y del centro a los extremos, son solo cuatro valores que almaceno en un vector y con un bucle for me muevo en las posiciones del mismo y asigno el valor al puerto B

I var byte
leds var byte[5]

TRISB=0

leds[1]=%10000001
leds[2]=%01000010
leds[3]=%00100100
leds[4]=%00011000

Leds=1
inicio:
for i=1 to 4
PORTB=leds
pause 100
next I
for i=4 to 1 step-1
PORTB=leds
pause 100
next i
goto inicio
end

Si estoy incomodando o causando molestias pidiendo que pases el codigo a C pos este es el ultimo pedido.... ji ji ji

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 15 de Agosto de 2005, 04:40:00

Al final voy a tener que dejar de lado mis ejemplos para adaptar los tuyos!!!jeje es broma, pero puedes intentarlo migrar tus ejemplos en basic a c y preguntar las dudas...pero vamos para mi no es ninguna molestia asi programo mas jeje aqui tienes la adaptacion en c de tu codigo, decir, mas bien recordar, que todos los programas se pueden programar de mil formas diferentes....pero vamos de momento me voy a limitar a traducir linea por linea de basic a c jeje aqui eta el ejemplito!!!!por cierto queda muy bonito la secuencia de luces:

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"05
//                   15/Agosto/05
//
//   Programa:   Juego de luces
//   Version:   0.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.227
//   Entorno IDE: MPLAB IDE v7.20      Simulador:    Proteus 6.7sp3
//
//   Notas: Iluminacion de juego de luces fuera-dentro y viceversa por el puerto B.
//       Adaptacion a c por vszener del codigo en basic de lordlafebre.
//
//            RB0 -> 1º Led
//            RB1 -> 2º Led
//            RB2 -> 3º Led
//            RB3 -> 4º Led
//            RB4 -> 5º Led
//            RB5 -> 6º Led
//            RB6 -> 7º Led
//            RB7 -> 8º Led
//////////////////////////////////////////////////////////////////////////////////

#include <16f648a.h>            //pic a utilizar
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP      //ordenes para el programador
#use delay (clock=4000000)         //Fosc=4Mhz
#use standard_io(B)               //puerto B

///PROGRAMA
void main(void)
{
   signed char i;      //variable indice
   int leds[4]={0b10000001,0b01000010,0b00100100,0b00011000}; //led"s

   set_tris_b(0x00);            //portb como salida
   disable_interrupts(GLOBAL);      //todas las interrupciones desactivadas

   do{                        //bucle...

      for(i=0;i<4;i++){         //led"s on fuera-dentro
         output_b(leds[ i ]);      //ilumino led"s correspondientes
         delay_ms(100);
         }
      for(i=3;i>-1;i--){         //led"s on dentro-fuera
         output_b(leds[ i ]);      //ilumino led"s correspondientes
         delay_ms(100);
         }

      }while(TRUE);            //...infinito
}

Despacito pero sin pausa! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 15 de Agosto de 2005, 04:52:00

Aqui la direccion para descargarse los archivos c, hex y dsn del ejemplo anterior: juego de luces

Suerte!!! :wink:

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 15 de Agosto de 2005, 06:11:00

Bien aqui la nueva entrega de programitas en c jeje!!!, esta vez no voy a poner un programa nuevo, sino la recopilacion de dos que ya hemos realizado, me explico la idea es que con el programa del coche fantastico y el programa este ultimo del juego de luces....¿porque no realizar el pic los dos?es decir, con un switch si esta cerrado que ejecute un programa y si esta abierto realice el otro...para ello debemos hacernos nuestra libreria(nuestro include fichero.h)y alli definir nuestras funciones(digo hacer librerias porque no vamos a programar otra vez lo que ya hemos hecho!!!): aqui la libreria:

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"04
//                   14/Agosto/05
//
//   Programa:   Coche Fantastico
//   Version:   2.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.227
//   Entorno IDE: MPLAB IDE v7.20      Simulador:    Proteus 6.7sp3
//
//   Notas: Barrido de led"s simulando la iluminacion del coche fantastico por el
//       puerto B. Adaptacion del codigo en basic de lordlafebre
//
//            RB0 -> 1º Led
//            RB1 -> 2º Led
//            RB2 -> 3º Led
//            RB3 -> 4º Led
//            RB4 -> 5º Led
//            RB5 -> 6º Led
//            RB6 -> 7º Led
//            RB7 -> 8º Led
//       En la variable cont se va almacenando los valores 1-2-4-8-16-32-64-128
//       que en binario corresponden a la secuencia 00000001-00000010-00000100...
//       son los led"s a iluminar, coincidiendo con la secuencia de iluminacion
//       del coche fantastico(version Ecuatoriana: auto fantastico)
//////////////////////////////////////////////////////////////////////////////////
#use delay (clock=4000000)         //Fosc=4Mhz,define funcion delay
///FUNCION COCHE FANTASTICO
void kit(void)
{
   int i,cont;                  //variables definidas

   cont=1;                  //inicializar...
   for(i=1;i<8;i++){         //led"s on derecha
      output_b(cont);         //ilumino led correspondiente
      delay_ms(100);
      cont=cont*2;
      }
   for(i=1;i<8;i++){
      output_b(cont);         //ilumino led correspondiente
      delay_ms(100);
      cont=cont/2;
      }
}

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"05
//                   15/Agosto/05
//
//   Programa:   Juego de luces
//   Version:   0.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.227
//   Entorno IDE: MPLAB IDE v7.20      Simulador:    Proteus 6.7sp3
//
//   Notas: Iluminacion de juego de luces fuera dentro por el puerto B.
//       Adaptacion a c por vszener del codigo en basic de lordlafebre.
//
//            RB0 -> 1º Led
//            RB1 -> 2º Led
//            RB2 -> 3º Led
//            RB3 -> 4º Led
//            RB4 -> 5º Led
//            RB5 -> 6º Led
//            RB6 -> 7º Led
//            RB7 -> 8º Led
//////////////////////////////////////////////////////////////////////////////////

///FUNCION JUEGO_LUCES
void juego_luces(void)
{
   signed char i;      //variable indice
   int leds[4]={0b10000001,0b01000010,0b00100100,0b00011000}; //led"s

   for(i=0;i<4;i++){         //led"s on fuera-dentro
      output_b(leds[ i ]);      //ilumino led"s correspondientes
      delay_ms(100);
      }
   for(i=3;i>-1;i--){         //led"s on dentro-fuera
      output_b(leds[ i ]);      //ilumino led"s correspondientes
      delay_ms(100);
      }
}
la guardamos con el nombre de vs_lib_luces.h
Y aqui el programa principal:

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"05
//                   15/Agosto/05
//
//   Programa:   Luces
//   Version:   0.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.227
//   Entorno IDE: MPLAB IDE v7.20      Simulador:    Proteus 6.7sp3
//
//   Notas: Programa que consiste en que si por el pin A0 del porta lee un "0" logico
//       es decir, esta en low, se ejecuta la iluminacion del coche fantastico
//       por el portb, en cambio si por el pin A0 del porta se recibe un estado alto
//       un "1" logico(high), se ejecuta por el portb la iluminacion de encender les"s
//       de fuera-dentro y viceversa. Tener en cuenta que hay que poner la
//       directiva NOLVP para que el pin B4 sea de salida
//////////////////////////////////////////////////////////////////////////////////

#include <16f648a.h>            //pic a utilizar
#include <vs_lib_luces.h>         //nuestra libreria para las funciones kit(),juego_luces()
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP      //ordenes para el programador
#use standard_io(B)
#use standard_io(A)

///PROGRAMA
void main(void)
{
   set_tris_a(0xFF);            //porta como entrada
   set_tris_b(0x00);            //portb como salida
   disable_interrupts(GLOBAL);      //todas las interrupciones desactivadas

   do{                     //bucle...
      if(!input(PIN_A0))      //¿switch cerrado?
         kit();            //SI ->ejecuta coche fantastico(kit)
      else
         juego_luces();      //NO ->ejecuta juego luces
      }while(TRUE);         //...infinito
}

Yo trabajo en el MPlab y hago los siguientes pasos(eso si como compilador el ccs): realizo un nuevo proyecto con el dispositivo programado y en source files agrego el programa principal: vs_luces.c despues en headers files agrego nuestra libreria: vs_lib_luces.h compilo y woala! ya tengo el hex listo para simular!!! Giño

PD: SUbire los archivos lo antes que pueda

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 15 de Agosto de 2005, 06:28:00

Aqui os podeis descargar los archivos .c, .h y el .hex....que pena que solo pueda subir tres archivos no hay un cuarto para el dsn(proteus) ainsss bueno montarlo vosotros no??jeje os vale el mismo del coche fantastico y el de juego de luces añadiendo un swicht por en porta...bueno con sus respectivas cositas(la resistencia de 10k conectada al power va al pin A0 y el swicht va al pin A0 y a tierra(GND)):

   º POWER
   |
   -
   - res 10k
   -
   |
A0 -----------swicth------GND

vale??????jeje :wink:

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 16 de Agosto de 2005, 07:30:00

El ejemplito de hoy se basa en hacer un contador ascendente del 0 al 9 y volver a empezar, para ello trabajaremos con el periferico 7segmentos de catodo comun, aqui el codigo:

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"04
//                   14/Agosto/05
//
//   Programa:   Contador ascendente 0-9
//   Version:   0.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.227
//   Entorno IDE: MPLAB IDE v7.20      Simulador:    Proteus 6.7sp3
//
//   Notas: Contador del 0 al 9 cada 0,5s y vuelta a empezar. Tener en cuenta
//       que hay que poner la directiva NOLVP para que el pin B4 sea de salida
//////////////////////////////////////////////////////////////////////////////////

#include <16f648a.h>            //pic a utilizar
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP      //ordenes para el programador
#use delay (clock=4000000)         //Fosc=4Mhz
#use standard_io(B)

///PROGRAMA
void main(void)
{
   char i=0;   //contador para tabla 7 seg
   int tab7seg[10]={0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x67};   //7seg hex 0-9

   set_tris_b(0x00);            //portb como salida
   disable_interrupts(GLOBAL);      //todas las interrupciones desactivadas

   do{                        //bucle...
      output_b(tab7seg[ i ]);      //muestra por portb digito 7 segmentos
      delay_ms(500);
      i++;                  //incremento contador para visualizar siguiente digito
      if(i>9)                  //¿ya se ha mostrado el digito 9?
      {
         i=0;               //SI -> vuelve a empezar(digito 0)
      }
      }while(TRUE);            //...infinito
}

Hasta la proxima entrega!!! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 16 de Agosto de 2005, 07:36:00

Aqui os podeis descargar los archivos del ejemplito: contador ascendente:

Suerte!!! :wink:

Título: RE: Ejemplitos en C para 16F648A
Publicado por: xootraoox en 16 de Agosto de 2005, 23:37:00

ufff amigo mio Rebotado

Grande vszener Rebotado

la verdad es que realmete eres muy bueno...

solo una pregunta

cual seria una buena metodologia para ir aprendiendo a escribir en C???

bueno en realidad que decir... eres esencial en este foro

despide nuevamente
-==XooTRAooX==-

apsss se me olvidaba... te envio un privado espero lo leas pronto

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 17 de Agosto de 2005, 03:35:00

GRacias por lod e grande!!!pero soy un NOVATO simplemente jeje...haber metodologia si te digo la verdad yo aprendi a programar por mi cuenta el c adaptado a los pic"s (ya sabia programar en c y c++) lo unico que hice fue buscarme un compilador medio en condiciones(ccs) que la verdad esta bastante documentado tanto en librerias como en funciones y empezar a trastear con el...lo recomendable es que tengas siempre a mano la ayuda del compilador(alli estara las funciones que realizar para los pic"s) y por aqui pusieron un .pdf con la ayuda traducida al español(bastante buena por cierto) aqui los enlaces:

http://miarroba.com/foros/ver.php?foroid=46840&temaid=4023657

Y bueno programar y programar!!!jeje por eso aqui abri este post, para que la gente que empieza como yo tenga ejemplos de referencias.....o eso intento jeje suertee!!! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 17 de Agosto de 2005, 03:38:00

Bien el ejemplito de hoy es igual que el anterior, es decir un contador descendente 9-0 y vuelta a empezar.....digo que es igual en tema de codigo, solamente cambia algun que otro comando.......aqui esta:

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"04
//                   14/Agosto/05
//
//   Programa:   Contador descendente 9-0
//   Version:   0.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.227
//   Entorno IDE: MPLAB IDE v7.20      Simulador:    Proteus 6.7sp3
//
//   Notas: Contador del 9 al 0 cada 0,5s y vuelta a empezar. Tener en cuenta
//       que hay que poner la directiva NOLVP para que el pin B4 sea de salida
//////////////////////////////////////////////////////////////////////////////////

#include <16f648a.h>            //pic a utilizar
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP      //ordenes para el programador
#use delay (clock=4000000)         //Fosc=4Mhz
#use standard_io(B)

///PROGRAMA
void main(void)
{
   char i=9;   //contador para tabla 7 seg(apunta al digito 9 de tab7seg)
   int tab7seg[10]={0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x67};   //7seg hex 0-9

   set_tris_b(0x00);            //portb como salida
   disable_interrupts(GLOBAL);      //todas las interrupciones desactivadas

   do{                        //bucle...
      output_b(tab7seg[ i ]);      //muestra por portb digito 7 segmentos
      delay_ms(500);
      i--;                  //decremento contador para visualizar siguiente digito
      if(i==-1)               //¿ya se ha mostrado el digito 0?
      {
         i=9;               //SI -> vuelve a empezar(digito 9)
      }
      }while(TRUE);            //...infinito
}

Bueno...ya sabemos contar de 0 al 9 y del 9 al 0 por separado....... Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 17 de Agosto de 2005, 03:46:00

Aqui os podeis descargar los archivos para el programa: contador descendente 9-0

Suerte!!! :wink:

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 18 de Agosto de 2005, 05:12:00

Ya que sabemos contar del 0 al 9 y del 9 al 0 mediante el periferico 7 segmentos.....esta vez el ejemplito propuesto es incorporarle un switch por el porta(pin A0) y si dicho switch esta abierto el contador sera ascendente(del 0 al 9) y si esta cerrado el switch el contador sera descendente(del 9 al 0)....aqui el codigo:

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"04
//                   14/Agosto/05
//
//   Programa:   Contador reversible 0-9
//   Version:   0.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.227
//   Entorno IDE: MPLAB IDE v7.20      Simulador:    Proteus 6.7sp3
//
//   Notas: Contador reversible 0 al 9 viceversa cada 0,5s y vuelta a empezar. Tener
//       en cuenta que hay que poner la directiva NOLVP para que el pin B4 sea de
//       salida. Cuando el switch esta cerrado se lee por el pin A0 del porta un
//       "0" logico(pin A0 low)y el contador se configura como descendente encambio
//       si el switch esta abierto se lee por el pin A0 del porta un "1"
//       logico(pin A0 high) por lo tanto el contador se configura como ascendente
//
//   Conexiones:      A0 -> switch       a
//               B0 -> a 7seg         ____
//               B1 -> b 7seg      f | | b
//               B2 -> c 7seg       | g |
//               B3 -> d 7seg ----
//               B4 -> e 7seg      e | | c
//               B5 -> f 7seg |____|
//               B6 -> g 7seg d
//////////////////////////////////////////////////////////////////////////////////

#include <16f648a.h>            //pic a utilizar
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP      //ordenes para el programador
#use delay (clock=4000000)         //Fosc=4Mhz
#use fixed_io(b_outputs=PIN_B0,PIN_B1,PIN_B2,PIN_B3,PIN_B4,PIN_B5,PIN_B6)
#use standard_io(A)

///DECLARACION DE FUNCIONES
void up(void);      //funcion cuenta ascendente
void down(void);   //funcion cuenta descendente

///DECLARACION VARIABLES GLOBALES
signed char i;   //contador para tabla 7 seg (se tiene en cuenta el signo)
int tab7seg[10]={0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x67};   //7seg hex 0-9

///PROGRAMA
void main(void)
{
   set_tris_a(0xFF);            //porta como entrada
   set_tris_b(0x00);            //portb como salida
   disable_interrupts(GLOBAL);      //todas las interrupciones desactivadas
///inicializamos el contador
   if(!input(PIN_A0))      //para ello leemos el estado del pin A0 del porta
      i=10;            //contador descendente
   else
      i=-1;            //contador ascendente

   do{                        //bucle...
      if(input(PIN_A0))         //¿switch abierto?
         up();               //SI -> contador ascendente
      else
         down();               //NO -> contador descendente

      output_b(tab7seg[ i ]);      //muestra por portb digito 7 segmentos
      delay_ms(500);
      }while(TRUE);            //...infinito
}

void up(void)                  //funcion cuenta ascendente
{
      i++;                  //incremento contador para visualizar siguiente digito
      if(i>9)                  //¿ya se ha mostrado el digito 9?
         i=0;               //SI -> vuelve a empezar(digito 0)
}

void down(void)                  //funcion cuenta descendente
{
      i--;                  //decremento contador para visualizar siguiente digito
      if(i==-1)               //¿ya se ha mostrado el digito 0?
         i=9;               //SI -> vuelve a empezar(digito 9)
}

Ya tenemos nuestro contador reversible!!! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 18 de Agosto de 2005, 05:16:00

Aqui os podeis descargar los archivos para el contador reversible

Suerte!!! :wink:

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 20 de Agosto de 2005, 18:21:00

Buenasss jeje!!!bien, aqui otro ejmeplito mas con el periferico 7seg...ya sabemos contar desde 0 a 9, desde 9 a 0 e incluso de 0 a 9 y viceversa!!!!!vamos a seguir contando jeje esta vez aqui un ejemplito de un contador desde 00 a 99 y vuelta a empezar...aqui el programita:

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"05
//                   18/Agosto/05
//
//   Programa:   Contador del 00 al 99
//   Version:   0.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.227
//   Entorno IDE: MPLAB IDE v7.20      Simulador:    Proteus 6.7sp3
//
//   Notas: Contador del 00 al 99 cada 1s y vuelta a empezar. Tener en cuenta
//       que hay que poner la directiva NOLVP para que el pin B4 sea de salida.
//       Se utiliza variables locales:
//            * i -> indice tabla 7seg para mostrar digito por 1º 7seg
//            * j -> indice tabla 7seg para mostrar digito por 2º 7seg
//            * flag -> variable que cuenta 1s
//            * var -> ajuste fino para que desborde cada segundo
//       Utilizamos la funcion de interrupcion para actualizar indices de la
//       tabla de 7seg para mostrar el digito correspondiente en el respectivo
//       7seg, para ello el TMR0 se desborda cada 1s, para ello debe ser cargado
//       con 61(equivale a un desbordamiento cada 50ms mas o menos), para obtener
//       un desbordamiento de 1s utilizamos una variable(flag) que no entra en
//       la actualizacion de indices hasta transcurrido 1s.
//   Conexiones:
//         · RA0 -> Display 1º 7seg
//         · RA1 -> Display 2º 7seg
//         · RB0 -> a 7seg
//         · RB1 -> b 7seg
//         · RB2 -> c 7seg
//         · RB3 -> d 7seg
//         · RB4 -> e 7seg
//         · RB5 -> f 7seg
//         · RB6 -> g 7seg
//////////////////////////////////////////////////////////////////////////////////

#include <16f648a.h>            //pic a utilizar
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP      //ordenes para el programador
#use delay (clock=4000000)         //Fosc=4Mhz
#use standard_io(B)
#use fixed_io(a_outputs=PIN_A0,PIN_A1)   //A0,A1 como salidas en porta

char i=0,j=0,flag=0,var=20;   //variables globales

///LLAMADA FUNCION INTERRUPCION
#INT_TIMER0
void interrupcion()
{
   if(flag>var){      //¿ya es 1 segundo?
      var--;         //SI -> decremento var...
      if(var<18)
         var=20;      //...ajuste fino de 1s
      flag=0;         //reset flag para contar 1s
      if(i>8){      //¿se ha mostrado por 1º 7seg digito 9?
         i=0;      //SI -> i=0 (muestra digito 0) (*)
         j++;      //incremento indice j
         if(j>9){   //¿se ha mostrado por 2º 7seg digito 9?
            j=0;}   //SI -> j=0 (muestra digito 0)
            }
      else{         //(*) NO -> incrementa i
         i++;}
      }
   set_timer0(61);      //reset TMR0
   flag++;            //incremento variable flag
}

///PROGRAMA
void main(void)
{
   int tab7seg[10]={0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x67};   //7seg hex 0-9

   set_tris_b(0x00);                     //portb como salida
   enable_interrupts(INT_TIMER0);            //interrupcion TIMER0 activada
   setup_counters(RTCC_INTERNAL,RTCC_DIV_256);   //configuracion interrupcion TMR0
   set_timer0(61);                        //carga TMR0
   enable_interrupts(GLOBAL);               //activadas interrupciones

   do{                        //bucle...
      output_high(PIN_A1);      //2º 7seg off
      output_low(PIN_A0);         //1º 7seg on
      delay_ms(15);
      output_b(tab7seg[ i ]);      //muestra por portb digito 7 segmentos
      output_low(PIN_A1);         //2º 7seg on
      output_high(PIN_A0);      //1º 7seg off
      delay_ms(15);
      output_b(tab7seg[ j ]);      //muestra por portb digito 7 segmentos
      }while(TRUE);            //...infinito
}

Decir que este ejemplito es bastante curioso aparte por manejar display"s de 7 segmentos multiplexados, por utilizar el TIMER0...es decir la cuenta de 1 segundo se hace atraves del desbordamiento del TMR0.....asi ya sabeis como programar interrupciones..... Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 20 de Agosto de 2005, 18:29:00

Aqui os podeis descargar el ejemplo del contador ascendente 00 al 99

Suerte!!! :wink:

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 20 de Agosto de 2005, 18:36:00

Recordar la formula para temporizaciones con los timers.....respecto al tmer de 8 bits(como es el caso del TMR0), esta es la formula a seguir:

Temporizacion = Tcm · Prescaler · (256-Carga TMR0)

Tcm = 4·Tosc = 4· 1/f ;f=frecuencia del cristal
Carga TMR0 = valor cargado a principio el el TMR0 como es de 8 bits 2^8=256 pero si se carga con 256 la temporizacion es cero...por lo tanto el valor del Carga del TMR0 debe estar comprendido entre [0,255]

Bueno aqui un pequeñisimo recuerdo de como funciona los timers.... Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 22 de Agosto de 2005, 10:24:00

Aqui estamos de nuevo!!!jeje ya que sabemos contar desde 0 al 99, ¿porque no contar desde 99 a 00?ummmm pero de forma automatica, es decir, nuestro contador empezara a contar de forma ascendente de 00 a 99 y cuando alcance el digito 99 que empiece a contar de forma descendente de 99 a 00 y vuelta a empezar!!!! aqui va el codigo:

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"05
//                   22/Agosto/05
//
//   Programa:   Contador del 00 al 99 y viceversa automaticamente
//   Version:   0.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.227
//   Entorno IDE: MPLAB IDE v7.20      Simulador:    Proteus 6.7sp3
//
//   Notas: Contador del 00 al 99 cada 1s y vuelta a empezar. Tener en cuenta
//       que hay que poner la directiva NOLVP para que el pin B4 sea de salida.
//       Se utiliza variables locales:
//            * i -> indice tabla 7seg para mostrar digito por 1º 7seg
//            * j -> indice tabla 7seg para mostrar digito por 2º 7seg
//            * flag -> variable que cuenta 1s
//            * var -> ajuste fino para que desborde cada segundo
//            * cuenta -> cuenta=0 -> Contador ascendente ; cuenta=1 -> Contador descendente
//       Utilizamos la funcion de interrupcion para actualizar indices de la
//       tabla de 7seg para mostrar el digito correspondiente en el respectivo
//       7seg, para ello el TMR0 se desborda cada 1s, para ello debe ser cargado
//       con 61(equivale a un desbordamiento cada 50ms mas o menos), para obtener
//       un desbordamiento de 1s utilizamos una variable(flag) que no entra en
//       la actualizacion de indices hasta transcurrido 1s. Configuramos una
//       variable tipo short,bit, llamada "cuenta" que si vale 1 significa que
//       el contador es descendente y si vale 0 significa que el contador es ascendente.
//   Conexiones:
//         · RA0 -> Display 1º 7seg
//         · RA1 -> Display 2º 7seg
//         · RB0 -> a 7seg
//         · RB1 -> b 7seg
//         · RB2 -> c 7seg
//         · RB3 -> d 7seg
//         · RB4 -> e 7seg
//         · RB5 -> f 7seg
//         · RB6 -> g 7seg
//////////////////////////////////////////////////////////////////////////////////

#include <16f648a.h>            //pic a utilizar
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP      //ordenes para el programador
#use delay (clock=4000000)         //Fosc=4Mhz
#use standard_io(B)
#use fixed_io(a_outputs=PIN_A0,PIN_A1)   //A0,A1 como salidas en porta

//VARIABLES GLOBALES
signed char i=0,j=0;   //indices(se tiene en cuenta signo para comprobaciones de fin tab7seg)
char flag=0,var=20;
short cuenta=0;         //cuenta=0 -> Contador ascendente ; cuenta=1 -> Contador descendente

///LLAMADA FUNCION INTERRUPCION
#INT_TIMER0
void interrupcion()
{
   if(flag>var){      //¿ya es 1 segundo?rutina:actualizar indices y contador ascendente/descendente
      var--;         //SI -> decremento var...
      if(var<18)
         var=20;      //...ajuste fino de 1s
      flag=0;         //reset flag para contar 1s
      if(cuenta==0){   //¿Contador ascendente?
      if(i>8){      //SI -> ¿se ha mostrado por 1º 7seg digito 9?
         i=0;      //SI -> i=0 (muestra digito 0) (*)
         j++;      //incremento indice j
         if(j>9){      //¿se ha mostrado digito 99?
            cuenta=1;   //SI -> contador descendente...
            j=9;      //restauro...
            i=8;      //...indices
            }
         }
      else{         //(*) NO -> incrementa i
         i++;}
      }
      else{               //Contador descendente
         i--;            //decremento indice i
         if(i<0){         //¿fin tab7seg en indice i?
            i=9;         //SI -> restauro i
            j--;         //decremento indice j
            if(j<0){      //¿fin tab7seg en indice j 00?
               cuenta=0;   //SI -> Contador descendente
               i=1;      //restauro...
               j=0;      //...indices
               }
            }
         }
      } //fin actualizar indices y contador ascendente/descendente
   set_timer0(61);      //reset TMR0
   flag++;            //incremento variable flag
}

///PROGRAMA
void main(void)
{
   int tab7seg[10]={0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x67};   //7seg hex 0-9

   set_tris_b(0x00);                     //portb como salida
   enable_interrupts(INT_TIMER0);            //interrupcion TIMER0 activada
   setup_counters(RTCC_INTERNAL,RTCC_DIV_256);   //configuracion interrupcion TMR0
   set_timer0(61);                        //carga TMR0
   enable_interrupts(GLOBAL);               //activadas interrupciones

   do{                        //bucle...
      output_high(PIN_A1);      //2º 7seg off
      output_low(PIN_A0);         //1º 7seg on
      delay_ms(15);
      output_b(tab7seg[ i ]);      //muestra por portb digito 7 segmentos
      output_low(PIN_A1);         //2º 7seg on
      output_high(PIN_A0);      //1º 7seg off
      delay_ms(15);
      output_b(tab7seg[ j ]);      //muestra por portb digito 7 segmentos
      }while(TRUE);            //...infinito
}

Hasta el siguiente ejemplito!!! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 22 de Agosto de 2005, 10:28:00

Aqui os podeis descargar los archivos en .c, .hex y .dsn del ejemplo: Contador del 00 al 99 y viceversa de forma automatica

Suerte!!! :wink:

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 22 de Agosto de 2005, 16:32:00

Misteriosamente este programa no estaba....asi que lo pongo de nuevo(simplemente estaba su descarga...), es un contador ascendente bcd que cuenta pulsando el boton:

Código: C

////////////////////////////////////////////////////////////////////////////////////
//                                                      VsZeNeR'05              
//                                                 22/Agosto/05
//                                                      vszener@gmail.com
//      Programa:       Contador 0-9 display BDC & Boton
//      Version:        0.0
//
//      Dispositivo: PIC 16F648A                        Compilador:      CCS vs3.227
//      Entorno IDE: MPLAB IDE v7.20            Simulador:       Proteus 6.7sp3
//
//      Notas: Contador 0 al 9 cada vez que pulsemos el boton y vuelta a empezar. Tener
//                 en cuenta que hay que poner la directiva NOLVP para que el pin B4 sea de 
//                 salida. Cuando agregamos un boton a nuestro circuito hay que tener en cuenta
//                 que este dispositivo genera 'rebotes' que hay que ser eliminados para
//                 una correcta visualizacion en el display del digito seleccionado. Esta vez
//                 la eliminacion de 'los rebotes' se ha realizado mediante software. 
//                 Cuando por el pin A0 del porta se introduce un '0' logico(low), se 
//                 incrementa un digito en el display BCD.
//
//      Conexiones:             A0 -> boton                   
//                                      B0 -> a 
//                                      B1 -> b 
//                                      B2 -> c 
//                                      B3 -> d 
//      BCD:
//                              d c b a   NUM
//                              0 0 0 0    0
//                              0 0 0 1    1
//                              0 0 1 0    2
//                              0 0 1 1    3
//                              0 1 0 0    4
//                              0 1 0 1    5
//                              0 1 1 0    6
//                              0 1 1 1    7
//                              1 0 0 0    8
//                              1 0 0 1    9
//////////////////////////////////////////////////////////////////////////////////
 
#include <16f648a.h>                            //pic a utilizar                        
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP             //ordenes para el programador 
#use delay (clock=4000000)                      //Fosc=4Mhz
#use fixed_io(b_outputs=PIN_B0,PIN_B1,PIN_B2,PIN_B3)
#use standard_io(A)
                
///PROGRAMA
void main(void)
{
        char i=0;       //contador para tabla BCD
        int tabBCD[10]={0b0000,0b0001,0b0010,0b0011,0b0100,0b0101,0b0110,0b0111,0b1000,0b1001}; //BCD 0-9
                
        set_tris_a(0xFF);                               //porta como entrada    
        disable_interrupts(GLOBAL);             //todas las interrupciones desactivadas
        
        output_b(tabBCD[i]);                    //inicializa displayBCD digito 0
 
        for(;;){                                                //bucle...
                if(!input(PIN_A0))                      //¿se ha pulsado el boton?
                        {
                                delay_ms(151);          //SI -> retardo para evitar los rebotes
                                i++;                            //incremento contador indice tabBCD
                                if(i>9)                         //¿se ha mostrado digito 9?
                                        i=0;                    //SI -> restaura valor indice(para mostrar digito 0)
                                output_b(tabBCD[i]); //muestra por portb digito 7 segmentos
                        }                       
                }                                                       //...infinito
}

Suerte!!! :wink:

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 22 de Agosto de 2005, 18:20:00

Y aqui va la version de contador de 0a9 en display de 7 segmento formato BCD y boton...peo esta vez dos botones, uno por el pin A0 que sis e pulsa se incrementa un digito y s emuestra por el 7seg BCD y otro boton por el pin A1 que si se pulsa se decrementa en una unidad y s emuestra por display de 7seg BCD:

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"05
//                   22/Agosto/05
//
//   Programa:   Contador 0-9 display BDC & Boton para cuenta ascendente o descendente
//   Version:   0.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.227
//   Entorno IDE: MPLAB IDE v7.20      Simulador:    Proteus 6.7sp3
//
//   Notas: Contador 0 al 9 cada vez que pulsemos el boton y vuelta a empezar. Tener
//       en cuenta que hay que poner la directiva NOLVP para que el pin B4 sea de
//       salida. Cuando agregamos un boton a nuestro circuito hay que tener en cuenta
//       que este dispositivo genera "rebotes" que hay que ser eliminados para
//       una correcta visualizacion en el display del digito seleccionado. Esta vez
//       la eliminacion de "los rebotes" se ha realizado mediante software.
//       Cuando por el pin A0 del porta se introduce un "0" logico(low), se
//       incrementa un digito en el display BCD, encambio si por el pin A1 se introduce
//       un "0" logico(low) se decrementa en una unidad el digito a mostrar.
//
//   Conexiones:      A0 -> boton   up(cuenta ascendente)
//               A1 -> boton down(cuenta descendente)
//               B0 -> a
//               B1 -> b
//               B2 -> c
//               B3 -> d
//   BCD:
//            d c b a NUM
//            0 0 0 0 0
//            0 0 0 1 1
//            0 0 1 0 2
//            0 0 1 1 3
//            0 1 0 0 4
//            0 1 0 1 5
//            0 1 1 0 6
//            0 1 1 1 7
//            1 0 0 0 8
//            1 0 0 1 9
//////////////////////////////////////////////////////////////////////////////////

#include <16f648a.h>            //pic a utilizar
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP      //ordenes para el programador
#use delay (clock=4000000)         //Fosc=4Mhz
#use fixed_io(b_outputs=PIN_B0,PIN_B1,PIN_B2,PIN_B3)
#use standard_io(A)

///PROGRAMA
void main(void)
{
   signed char i=0;   //contador para tabla BCD
   int tabBCD[10]={0b0000,0b0001,0b0010,0b0011,0b0100,0b0101,0b0110,0b0111,0b1000,0b1001};   //BCD 0-9

   set_tris_a(0xFF);            //porta como entrada
   disable_interrupts(GLOBAL);      //todas las interrupciones desactivadas

   output_b(tabBCD[ i ]);         //inicializa displayBCD digito 0

   for( ; ; ){                  //bucle...
      if(!input(PIN_A0))         //¿se ha pulsado el boton up?
         {
            delay_ms(151);      //SI -> retardo para evitar los rebotes
            i++;            //incremento contador indice tabBCD
            if(i>9)            //¿se ha mostrado digito 9?
               i=0;         //SI -> restaura valor indice(para mostrar digito 0)
         }
      if(!input(PIN_A1))         //¿se ha pulsado el boton down?
         {
            delay_ms(151);      //SI -> retardo para evitar los rebotes
            i--;            //decremento contador indice tabBCD
            if(i<0)            //¿se ha mostrado digito 0?
               i=9;         //SI -> restaura valor indice(para mostrar digito 9)
         }
      output_b(tabBCD[ i ]);       //muestra por portb digito BCD
      }                     //...infinito
}
Recordad que los botones generan los llamados "rebotes" que deben ser eliminados bien hardware o bien por software(el cual es este ejemplo mediante una pausa de 151ms)....corto y cambio!!! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 22 de Agosto de 2005, 18:23:00

De este enlace os podeis bajar los archivos del ejemplo anterior: contador 0a9 en 7seg BCD con dos botones uno ascendente y otro descendente:

Suerte!!! :wink:

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 24 de Agosto de 2005, 07:40:00

Bueno celebrando mi mensaje numero 100!!!(parece que fue ayer...)aqui un ejemplito massss de contador en display"s de 7seg...ya se que estais cansados de ver numeritos y mas numeritossss jeje pero weno asi ya sabemos programar display"s de 7seg multiplexados, interrupciones y demas cositas...esta vez es un SUPER CONTADOR!!!!!jeje ascendente(de momento) que cuenta de 0000 a 9999 y vuelta a empezar....bueno compañeros, ya no hay excusa que no sabemos contar!!!!:

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"05
//                   23/Agosto/05
//
//   Programa:   Contador del 0000 al 9999
//   Version:   0.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.227
//   Entorno IDE: MPLAB IDE v7.20      Simulador:    Proteus 6.7sp3
//
//   Notas: Contador del 0000 al 9999 cada 1s y vuelta a empezar. Tener en cuenta
//       que hay que poner la directiva NOLVP para que el pin B4 sea de salida.
//       Se utiliza variables locales:
//            * i -> indice tabla 7seg para mostrar digito por 1º 7seg
//            * j -> indice tabla 7seg para mostrar digito por 2º 7seg
//            * w -> indice tabla 7seg para mostrar digito por 3º 7seg
//            * z -> indice tabla 7seg para mostrar digito por 4º 7seg
//            * flag -> variable que cuenta 1s
//            * var -> ajuste fino para que desborde cada segundo
//       Utilizamos la funcion de interrupcion para actualizar indices de la
//       tabla de 7seg para mostrar el digito correspondiente en el respectivo
//       7seg, para ello el TMR0 se desborda cada 1s, para ello debe ser cargado
//       con 61(equivale a un desbordamiento cada 50ms mas o menos), para obtener
//       un desbordamiento de 1s utilizamos una variable(flag) que no entra en
//       la actualizacion de indices hasta transcurrido 1s.
//   Conexiones:
//         · RA0 -> Display 1º 7seg
//         · RA1 -> Display 2º 7seg
//         · RA2 -> Display 3º 7seg
//         · RA3 -> Display 4º 7seg
//         · RB0 -> a 7seg
//         · RB1 -> b 7seg
//         · RB2 -> c 7seg
//         · RB3 -> d 7seg
//         · RB4 -> e 7seg
//         · RB5 -> f 7seg
//         · RB6 -> g 7seg
//////////////////////////////////////////////////////////////////////////////////

#include <16f648a.h>            //pic a utilizar
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP      //ordenes para el programador
#use delay (clock=4000000)         //Fosc=4Mhz
#use standard_io(B)
#use fixed_io(a_outputs=PIN_A0,PIN_A1,PIN_A2,PIN_A3)   //A0,A1,A2,A3 como salidas en porta

char i=0,j=0,w=0,z=0,flag=0,var=20;   //variables globales

///LLAMADA FUNCION INTERRUPCION
#INT_TIMER0
void interrupcion()
{
   if(flag>var){            //¿ya es 1 segundo?
      var--;               //SI -> decremento var...
      if(var<18)
         var=20;            //...ajuste fino de 1s
      flag=0;               //reset flag para contar 1s
      if(i>8){            //¿se ha mostrado por 1º 7seg digito 9?
         i=0;            //SI -> i=0 (muestra digito 0) (*)
         j++;            //incremento indice j
         if(j>9){         //¿se ha mostrado por 2º 7seg digito 9?
            j=0;          //SI -> j=0 (muestra digito 0)
            w++;         //incremento indice w
            if(w>9){      //¿se ha mostrado por 3º 7seg digito 9?
               w=0;      //SI -> w=0 (muestra digito 0)
               z++;      //incremento indice z
               if(z>9)      //¿se ha mostrado por 4º 7seg digito 9?
                  z=0;   //SI -> z=0 (muestra digito 0)
               }
            }
            }
      else{         //(*) NO -> incrementa i
         i++;}
      }
   set_timer0(61);      //reset TMR0
   flag++;            //incremento variable flag
}

///PROGRAMA
void main(void)
{
   int tab7seg[10]={0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x67};   //7seg hex 0-9

   set_tris_b(0x00);                     //portb como salida
   enable_interrupts(INT_TIMER0);            //interrupcion TIMER0 activada
   setup_counters(RTCC_INTERNAL,RTCC_DIV_256);   //configuracion interrupcion TMR0
   set_timer0(61);                        //carga TMR0
   enable_interrupts(GLOBAL);               //activadas interrupciones

   do{                        //bucle...
      output_high(PIN_A0);
      output_high(PIN_A1);
      output_high(PIN_A2);
      output_low(PIN_A3);         //activado...
      output_b(tab7seg[ i ]);      //...1º 7seg
      delay_ms(10);
      output_high(PIN_A0);
      output_high(PIN_A1);
      output_low(PIN_A2);         //activado...
      output_high(PIN_A3);
      output_b(tab7seg[ j ]);      //...2º 7seg
      delay_ms(10);
      output_high(PIN_A0);
      output_low(PIN_A1);         //activado...
      output_high(PIN_A2);
      output_high(PIN_A3);
      output_b(tab7seg[ w ]);      //...3º 7seg
      delay_ms(10);
      output_low(PIN_A0);         //activado...
      output_high(PIN_A1);
      output_high(PIN_A2);
      output_high(PIN_A3);
      output_b(tab7seg[ z ]);      //...4º 7seg
      delay_ms(10);
      }while(TRUE);            //...infinito
}

Mi mensajee numero 100 ole!!!!! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 24 de Agosto de 2005, 07:44:00

Aqui la direccion para descargarse los archivos .c, .hex y .dsn del ejemplito anterior: contador ascendente de 0000 a 9999:

Suerte!!! :wink:

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 25 de Agosto de 2005, 06:04:00

Este ejemplito de hoy es para animar al BETI!!!aunque perdiera la supercopa españa....ainsss, el programa consiste en 7 display"s de 7seg multiplexados parpadeando la palabra "beti":

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"05
//                   24/Agosto/05
//
//   Programa:   BETI parpadeo
//   Version:   0.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.227
//   Entorno IDE: MPLAB IDE v7.20      Simulador:    Proteus 6.7sp3
//
//   Notas: Muestra el mensaje de BETI por cuatro display"s de 7 segmentos
//       multiplexados. El mensaje aparece cada 0,5s parpadeando
//       Tener en cuenta que hay que poner la directiva NOLVP
//       para que el pin B4 sea de salida.
//       Se utiliza variables locales:
//            * i -> contador para visualizar BETI
//   Conexiones:
//         · RA0 -> Display 1º 7seg
//         · RA1 -> Display 2º 7seg
//         · RA2 -> Display 3º 7seg
//         · RA3 -> Display 4º 7seg
//         · RB0 -> a 7seg
//         · RB1 -> b 7seg
//         · RB2 -> c 7seg
//         · RB3 -> d 7seg
//         · RB4 -> e 7seg
//         · RB5 -> f 7seg
//         · RB6 -> g 7seg
//////////////////////////////////////////////////////////////////////////////////

#include <16f648a.h>            //pic a utilizar
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP      //ordenes para el programador
#use delay (clock=4000000)         //Fosc=4Mhz
#use standard_io(B)
#use standard_io(A)

///PROGRAMA
void main(void)
{
   char i;                     //contador de visualizacion BETI

   set_tris_b(0x00);            //portb como salida
   set_tris_a(0x00);            //porta como salida
   disable_interrupts(GLOBAL);      //activadas interrupciones

   do{                        //bucle...
      for(i=0;i<15;i++){         //bucle visualizacion beti
      output_a(0b1110);
    output_b(0x7C);            //1º 7seg on B
      delay_ms(10);
      output_a(0b1101);
      output_b(0x79);            //2º 7seg on E
      delay_ms(10);
      output_a(0b1011);
      output_b(0x78);            //3º 7seg on T
      delay_ms(10);
      output_a(0b0111);
      output_b(0x30);            //4º 7seg on I
      delay_ms(10);
      }

      output_b(0x00);            //todo...
      output_a(0b0000);
      delay_ms(500);            //...apagado durante 0,5s
      }while(TRUE);            //...infinito
}

Musho betiii man ke pierda!!!!jeje Giño

PD: Aunque yo soy del Depor.....

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 25 de Agosto de 2005, 06:07:00

Desde este enlace os podeis descargar los archivos necesarios para el programa anterior del parpadeo de la palabra Beti en 4 display"s de 7seg multiplexados

Suerte!!! :wink:

Título: RE: Ejemplitos en C para 16F648A
Publicado por: Nocturno en 25 de Agosto de 2005, 06:13:00

Anda, amigo, cámbialo por Depor, que me temo que ahora mismo los ánimos los necesita más que el Betis.

De todas formas, podrías poner algo como: "musho Beti y Aupa Depor"

Título: RE: Ejemplitos en C para 16F648A
Publicado por: RaDoN en 25 de Agosto de 2005, 06:18:00

la "m" con el display va esta complicada xD Muchas risas

tal vez si lo tumbamos ... :P

Título: RE: Ejemplitos en C para 16F648A
Publicado por: Nocturno en 25 de Agosto de 2005, 06:32:00

Glub, no me dí cuenta que hablabas de 7-seg.
Bueno, puedes poner AUPA DEPO

Título: RE: Ejemplitos en C para 16F648A
Publicado por: RaDoN en 25 de Agosto de 2005, 06:44:00

Weno, todo es ponerse jejeje, en el foro de modding que yo frecuento, hay un chaval algo bruto que hizo lo siguien, sin multiplexar (que sera como consumir 2A) !! loco

P.D.: perdon por la publi, pero lo "interesante" es lo que hizo el "becerro" este ...

Título: RE: Ejemplitos en C para 16F648A
Publicado por: xootraoox en 25 de Agosto de 2005, 07:30:00

MMMM... Algunos de uds ha visto por hay este chip??? TLC5904..... bueno este mismo es capas de controlar hasta 16 salidas de leds permitiendonos ajustar el error de los leds.... asi tambien es capas de variar la intensidad de los leds por medio de PWM

osea en pocas palabras con solo 4 de estos mas 3 pines de un micro podemos hacer una matriz de 32 x 32 con la capacidad de generar hasta 4096 tonos de escalas de grizes osea sin problemas podemos mostrar imagenes

bueno si quieren un poco mas de info en realidad vealla uds mismos en la hoja de datos del mismo

http://www-s.ti.com/sc/ds/tlc5940.pdf

apsss..... se me olvidaba lo mas importante Flash

si alguien genera alguna libreria para el mismo se agadece de antemano que la compartiera en este mismo

-==XooTRAooX==-

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 25 de Agosto de 2005, 08:43:00

jejeje la virgen!!!!jeje la verdad que el chiko no se compliko la cabeza mucho....y yo ke kreia ke radon estaba hablando en broma de eso de tumbar los 7seg.....jeje ke descaro!..ainsss por cierto xootraoox interesante el data sheet que pusiste haber si lo leo detenidamente me interesan los "chismes" esos....bueno se que al Depor le hace mas falta los animos ya que no estamos en europa ni nada asi que haciendole caso a nocturno66 aqui va el programita que anima al depor diciendo: AUPA DEPO y suena un pitidito....como mejor he podido poner las letras en display"s de 7seg jeje:

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"05
//                   25/Agosto/05
//
//   Programa:   AUPA DEPO parpadeo
//   Version:   0.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.227
//   Entorno IDE: MPLAB IDE v7.20      Simulador:    Proteus 6.7sp3
//
//   Notas: Muestra el mensaje de AUPA DEPO por cuatro display"s de 7 segmentos
//       multiplexados. El mensaje aparece cada 0,5s parpadeando primero la
//       frase AUPA y luego la frase DEPO y suena un pitido al cambio de frase.
//       Tener en cuenta que hay que poner la directiva NOLVP
//       para que el pin B4 sea de salida.
//       Se utiliza variables locales:
//            * i -> indice 1º 7seg
//            * j -> indice 2º 7seg
//            * w -> indice 3º 7seg
//            * z -> indice 4º 7seg
//            * cont -> contador: cont=0 -> AUPA
//                           cont=1 -> DEPO
//            * rep -> variable para visualizar mensaje
//            * tab7seg[] -> vector donde se almacenan letras mensajes
//   Conexiones:
//         · RA0 -> Display 1º 7seg
//         · RA1 -> Display 2º 7seg
//         · RA2 -> Display 3º 7seg
//         · RA3 -> Display 4º 7seg
//         · RB0 -> a 7seg
//         · RB1 -> b 7seg
//         · RB2 -> c 7seg
//         · RB3 -> d 7seg
//         · RB4 -> e 7seg
//         · RB5 -> f 7seg
//         · RB6 -> g 7seg
//         · RB7 -> Buzzer
//////////////////////////////////////////////////////////////////////////////////

#include <16f648a.h>            //pic a utilizar
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP      //ordenes para el programador
#use delay (clock=4000000)         //Fosc=4Mhz
#use standard_io(B)
#use standard_io(A)

///PROGRAMA
void main(void)
{
   char rep,cont=0,i=0,j=1,w=2,z=0;   //variables
   int tab7seg[6]={0x77,0x3E,0x73,0x5E,0x79,0x3F};   //A U P D E O

   set_tris_b(0x00);            //portb como salida
   set_tris_a(0x00);            //porta como salida
   disable_interrupts(GLOBAL);      //desactivadas interrupciones

   do{                        //bucle...
      for(rep=0;rep<15;rep++){   //bucle visualizacion aupa/depo
      output_a(0b1110);
    output_b(tab7seg[ i ]);      //1º 7seg on
      delay_ms(10);
      output_a(0b1101);
      output_b(tab7seg[ j ]);      //2º 7seg on
      delay_ms(10);
      output_a(0b1011);
      output_b(tab7seg[ w ]);      //3º 7seg on
      delay_ms(10);
      output_a(0b0111);
      output_b(tab7seg[ z ]);      //4º 7seg on
      delay_ms(10);
      }

      cont=!cont;               //cont=~cont
      if(cont==1){            //muestra:
         i=3;               //D
         j=4;               //E P
         z=5;}               //O
      else{                  //muestra:
         i=0;               //A
         j=1;               //U P
         z=0;}               //A

      output_b(0b10000000);      //Buzzer on...todo...
      output_a(0b0000);
      delay_ms(500);            //...apagado durante 0,5s
      }while(TRUE);            //...infinito
}
aupa depoooo piiii piiii piiiiiii jeje Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 25 de Agosto de 2005, 08:46:00

Aqui los archivos necesarios para el programa anterior: Aupa Depo

Suerte!!! :wink:

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 26 de Agosto de 2005, 09:12:00

Un ejemplito mas!!!!y seguimos machacando los display"s de 7 segmentos de catodo comun...esta vez el ejemplo consiste en 4 display"s de 7seg mostrar la palabra "hola" e ir rotandola hacia la izquierda:

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"05
//                   21/Agosto/05
//
//   Programa:   HOLA
//   Version:   0.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.227
//   Entorno IDE: MPLAB IDE v7.20      Simulador:    Proteus 6.7sp3
//
//   Notas: Muestra el mensaje de HOLA por cuatro display"s de 7 segmentos
//       multiplexados. El mensaje se va rotando por los display"s hacia la
//       izquierda. Tener en cuenta que hay que poner la directiva NOLVP
//       para que el pin B4 sea de salida.
//       Se utiliza variables locales:
//            * i -> indice tabla 7seg para mostrar 1º 7seg
//            * j -> indice tabla 7seg para mostrar 2º 7seg
//            * z -> indice tabla 7seg para mostrar 3º 7seg
//            * w -> indice tabla 7seg para mostrar 4º 7seg
//            * flag -> variable que cuenta 0.5s
//            * var -> ajuste fino para que desborde cada medio segundo.
//       Utilizamos la funcion de interrupcion para actualizar indices de la
//       tabla de 7seg para mostrar la palabra correspondiente en el respectivo
//       7seg, para ello el TMR0 se desborda cada 0.5s, para ello debe ser cargado
//       con 61(equivale a un desbordamiento cada 50ms mas o menos), para obtener
//       un desbordamiento de 0.5s utilizamos una variable(flag) que no entra en
//       la actualizacion de indices hasta transcurrido 0.5s.
//   Conexiones:
//         · RA0 -> Display 1º 7seg
//         · RA1 -> Display 2º 7seg
//         · RA2 -> Display 3º 7seg
//         · RA3 -> Display 4º 7seg
//         · RB0 -> a 7seg
//         · RB1 -> b 7seg
//         · RB2 -> c 7seg
//         · RB3 -> d 7seg
//         · RB4 -> e 7seg
//         · RB5 -> f 7seg
//         · RB6 -> g 7seg
//////////////////////////////////////////////////////////////////////////////////

#include <16f648a.h>            //pic a utilizar
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP      //ordenes para el programador
#use delay (clock=4000000)         //Fosc=4Mhz
#use standard_io(B)
#use standard_io(A)

char i=0,j=1,z=2,w=3,var=10,flag=0;   //indices para tabla 7 seg

///LLAMADA FUNCION INTERRUPCION
#INT_TIMER0
void interrupcion()
{
   if(flag>var){      //¿ya es 1 segundo?
      var--;         //SI -> decremento var...
      if(var<18)
         var=10;      //...ajuste fino de 1s
      flag=0;         //reset flag para contar 1s
      i++;         //incrementos...
      j++;
      z++;
      w++;         //...indices para mostrar en 7seg
      if(i>3)         //¿Ha llegado fin tab7seg?
         i=0;      //SI -> restaura indice i
      if(j>3)         //¿Ha llegado fin tab7seg?
         j=0;      //SI -> restaura indice j
      if(z>3)         //¿Ha llegado fin tab7seg?
         z=0;      //SI -> restaura indice z
      if(w>3)         //¿Ha llegado fin tab7seg?
         w=0;      //SI -> restaura indice w
      }

   set_timer0(61);      //reset TMR0
   flag++;            //incremento variable flag
}

///PROGRAMA
void main(void)
{
   int tab7seg[4]={0x76,0x3F,0x38,0x77};      //7seg H O L A

   set_tris_b(0x00);                     //portb como salida
   set_tris_a(0x00);                     //porta como salida
   enable_interrupts(INT_TIMER0);            //interrupcion TIMER0 activada
   setup_counters(RTCC_INTERNAL,RTCC_DIV_256);   //configuracion interrupcion TMR0
   set_timer0(61);                        //carga TMR0
   enable_interrupts(GLOBAL);               //activadas interrupciones


   do{                        //bucle...
      output_low(PIN_A0);         //activado...
      output_high(PIN_A1);
      output_high(PIN_A2);
      output_high(PIN_A3);
      output_b(tab7seg[ i ]);      //...1º 7seg
      delay_ms(10);
      output_high(PIN_A0);
      output_low(PIN_A1);         //activado...
      output_high(PIN_A2);
      output_high(PIN_A3);
      output_b(tab7seg[ j ]);      //...2º 7seg
      delay_ms(10);
      output_high(PIN_A0);
      output_high(PIN_A1);
      output_low(PIN_A2);         //activado...
      output_high(PIN_A3);
      output_b(tab7seg[ z ]);      //...3º 7seg
      delay_ms(10);
      output_high(PIN_A0);
      output_high(PIN_A1);
      output_high(PIN_A2);
      output_low(PIN_A3);         //activado...
      output_b(tab7seg[ w ]);      //...4º 7seg
      delay_ms(10);
      }while(TRUE);            //...infinito
}

Bueno....terminada la publicidad y animos a los equipos de futbol como el que no quiere la cosa sabemos contar de forma ascendente,descendente,automatica,con botones,parpadeo de palabras,parpadeo de dos palabras y ahora rotar palabras....ya sabemos algo mas!!!! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 26 de Agosto de 2005, 09:15:00

De este enlace os podeis descargar los archivos necesarios del programa anterior:hola

Suerte!!! :wink:

Título: RE: Ejemplitos en C para 16F648A
Publicado por: RaDoN en 26 de Agosto de 2005, 09:17:00

Joder tio, eres una máquina, no paras de trabajar Rebotado

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 26 de Agosto de 2005, 16:53:00

Jeje bueno trabajar con estos "cacharros" es un placer(hasta que se atraganta algun que otro programita...jeje)..ummmm le han puesto una xincheta al post!!!!jeje bueno asi esta mas visible para que este mas a mano los ejemplitos....bueno decir que microchip acaba de lanzar la version del Mplab 7.21, lo digo porque ya los nuevos ejemplos estaran integrados en el nuevo software(eso si recordando que el compilador utilizado es el CCS), aqui la dire para descargarse la nueva version del Mplab 7.21:

http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=1406&dDocName=en019469&part=SW007002

PD: Es GRATISSS!!!!!jeje Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 26 de Agosto de 2005, 17:15:00

Aqui va otro ejemplito mas!!!!y mas con 7seg!!!!jeje ke jartura de estos dispositivos......ainsss jeje, bueno esta vez consiste en mostrar por pantaya un cuadradito ke se desplaza de izquierda a derechas y viceversa:

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"05
//                   26/Agosto/05
//
//   Programa:   Cuadrado que recorre 4 display"s de 7seg de izuiqerda a derechas
//   Version:   0.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.227
//   Entorno IDE: MPLAB IDE v7.20      Simulador:    Proteus 6.7sp3
//
//   Notas: Simbolo recorre cuatro display"s de 7 segmentos de izquierda
//       a derechas y viceversa.
//       Tener en cuenta que hay que poner la directiva NOLVP
//       para que el pin B4 sea de salida.
//       Se utiliza variables locales:
//            * i -> contador de display on
//            * display_on[] -> vector con el display on
//   Conexiones:
//         · RA0 -> Display 1º 7seg
//         · RA1 -> Display 2º 7seg
//         · RA2 -> Display 3º 7seg
//         · RA3 -> Display 4º 7seg
//         · RB0 -> a 7seg
//         · RB1 -> b 7seg
//         · RB2 -> c 7seg
//         · RB3 -> d 7seg
//         · RB4 -> e 7seg
//         · RB5 -> f 7seg
//         · RB6 -> g 7seg
//////////////////////////////////////////////////////////////////////////////////

#include <16f648a.h>            //pic a utilizar
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP      //ordenes para el programador
#use delay (clock=4000000)         //Fosc=4Mhz
#use standard_io(B)
#use standard_io(A)

///PROGRAMA
void main(void)
{
   char i=0;                  //contador de display on
   int display_on[4]={0b1110,0b1101,0b1011,0b0111}; //tabla display on

   set_tris_b(0x00);            //portb como salida
   set_tris_a(0x00);            //porta como salida
   disable_interrupts(GLOBAL);      //desactivadas interrupciones

   output_b(0x63);               //muestra por pantalla simbolo
   output_a(display_on[ i ]);      //inicializo display

   do{                        //bucle...
      for(i=0;i<3;i++){         //hacia la izquierda
         delay_ms(100);
         output_a(display_on[ i ]);
      }

      for(i=3;i>0;i--){         //hacia la derecha
         delay_ms(100);
         output_a(display_on[ i ]);
      }
      }while(TRUE);            //...infinito
}

Hasta el sigiente programa!!!! :wink:

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 27 de Agosto de 2005, 14:58:00

Bien aqui el ejemplito numero 22!!!!jeje esta vez consiste en hacer un dado electronico, se utilizada un display de 7seg en formato BCD(que ya conocemos) y un pulsador(los cuales producen los molestos "rebotes" que pueden ser eliminados mediante hardware o como este caso emdiante software pero esta vez no realizamos una espera sino que lo eliminamos mediante un bucle), el programa llama a una funcion definida en la libreria #include <STDLIB.H> la cual tiene la funcion srand() y rand() , esta ultima para generar numeros aleatorios, tener en cuenta que tenemos que definir esta variable como sigue: #define RAND_MAX 10 para que solo contemos del 0 al 9:

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"05
//                   25/Agosto/05
//
//   Programa:   Dado digital
//   Version:   0.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.227
//   Entorno IDE: MPLAB IDE v7.20      Simulador:    Proteus 6.7sp3
//
//   Notas: Dado digital, que al presionar el boton conectado al pin A0 del porta
//       genera un numero pseudo-aleatorio mediante la funcion rand() que se
//       encuentra en la libreria STDLIB.H. El numero pseudo-aleatorio es elegido
//       mediante la funcion rand() y segun los "rebotes" producidos por el boton.Tener
//       en cuenta que hay que poner la directiva NOLVP para que el pin B4 sea de
//       salida. Cuando agregamos un boton a nuestro circuito hay que tener en cuenta
//       que este dispositivo genera "rebotes" que hay que ser eliminados para
//       una correcta visualizacion en el display del digito seleccionado. Esta vez
//       la eliminacion de "los rebotes" se ha realizado mediante software.
//
//   Conexiones:      A0 -> boton
//               B0 -> a
//               B1 -> b
//               B2 -> c
//               B3 -> d
//   BCD:
//            d c b a NUM
//            0 0 0 0 0
//            0 0 0 1 1
//            0 0 1 0 2
//            0 0 1 1 3
//            0 1 0 0 4
//            0 1 0 1 5
//            0 1 1 0 6
//            0 1 1 1 7
//            1 0 0 0 8
//            1 0 0 1 9
//////////////////////////////////////////////////////////////////////////////////

#include <16f648a.h>            //pic a utilizar
#include <STDLIB.H>               //libreria donde esta la funcion rand();
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP      //ordenes para el programador
#use delay (clock=4000000)         //Fosc=4Mhz
#use fixed_io(b_outputs=PIN_B0,PIN_B1,PIN_B2,PIN_B3)
#use standard_io(A)

///PROGRAMA
void main(void)
{
   char num=0;                  //variable almacena numero aleatorio

   set_tris_a(0xFF);            //porta como entrada
   disable_interrupts(GLOBAL);      //todas las interrupciones desactivadas

   srand(10);                  //maximo hasta 9
   for( ; ; ){                  //bucle...
      if(!input(PIN_A0))         //¿se ha pulsado el boton?
         {
            do{                     //elimina...
               num=rand();            //genera numero pseudo-aleatorio
               }while(!input(PIN_A0));   //...rebotes
         }
      output_b(num);                   //muestra por portb digito 7 segmentos
      }                     //...infinito
}

Parece que fue ayer cuando encendiamos y apagabamos un led y ya vamos por el programa numero 22!!!jeje hasta pronto! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 27 de Agosto de 2005, 15:01:00

Desde este enlace os podeis descargar los archivos necesarios para el programa anterior: Dado

Suerte!!! :wink:

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 29 de Agosto de 2005, 05:03:00

Ke tal!!!bien, decir que vamos a practicar con pantallas lcd por lo tanto me parece bueno que tengamos referencias sobre la lcd a utilizar, la elegida es la Hitachi 44780(LM016L) para ello utilizaremos la libreria que viene incluida en el CCS llamada lcd.c, esta libreria maneja nuestra lcd ya que se compone de 2x16 LCD Panel. La idea es hacer funcionar estos "cacharros" y segun pasen los ejemplos poder modificar la libreria para poder conectar nuestra lcd a nuestro pic de la forma que queramos okis??, bien aqui van algunos enlaces sobre nuestra lcd a utilizar(decir que la libreria lcd.c es compatible con otras pantallas lcd que cumplan 2x16 LCD Panel):
Data sheet del lcd Hitachi 44780(con info sobre ella):
http://www.x-robotics.com/rutinas.htm#LCD
Y aqui un enlace que CCS da sobre sus librerias, siempre es bueno tenerlo a mano ya que asi sabremos sobre que material esta realizada la libreria lcd.c(teneis que buscar en la tabla el nombre de lcd.c y a la derecha estara el data sheet en pdf del lcd patron de dicha libreria que ha utilizado CCS para realizarla):
http://www.ccsinfo.com/data.shtml

PD: Comentar que el manejo a priori de las lcd"s son facil...pero a la hora de simularlas o montaje real viene las complicaciones, normalmentee estas complicaciones son debidas la mayoria de veces al conexionado mal de la lcd con nuestro pic, asi que si el programa compila sin errores revisar bien el conexionado de la lcd con el pic.

Vamos al lio!!! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 29 de Agosto de 2005, 05:04:00

Y para empezar con estos "cacharros" que mejor que decir "hola mundo" jeje pues aqui esta!!!!:

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"05
//                   26/Agosto/05
//
//   Programa:   Hola mundo
//   Version:   0.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.227
//   Entorno IDE: MPLAB IDE v7.21      Simulador:    Proteus 6.7sp3
//
//   Notas: Se muestra por pantalla de lcd(LM016L) en la primera linea la
//       frase "hola mundo Giño

" y en la segunda linea "VsZeNeR"05". Tener
//       en cuenta que hay que poner la directiva NOLVP para que el pin B4 sea de
//       salida.
//
//   Conexiones:      B0 -> E
//               B1 -> RS
//               B2 -> RW
//               B4 -> D4
//               B5 -> D5
//               B6 -> D6
//               B7 -> D7
//////////////////////////////////////////////////////////////////////////////////

#include <16f648a.h>            //pic a utilizar
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP      //ordenes para el programador
#use delay (clock=4000000)         //Fosc=4Mhz
#define use_portb_lcd TRUE         //definir portb lcd
#include<lcd.c>                  //libreria manejo lcd

///PROGRAMA
void main(void)
{
   lcd_init();         //inicializa lcd
   printf(lcd_putc,"hola mundo ; )
VsZeNeR"05" );   //muestra por pantalla el mensaje
}

Jeje ya sabemos encender las lcd"s..... Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 29 de Agosto de 2005, 05:10:00

Aqui los archivos necesarios para el programa: hola mundo

Suerte!!! :wink:

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 29 de Agosto de 2005, 18:30:00

Buenas!!!!decir que el ejemplo que propongo es igual al anterior excepto una salvedad, esta vez nos ahorraremos un pin, es decir, el programa dira la frase "hola mundo...." pero utilizando un pin menos conectado al lcd, el pin que nos vamos ahorrar es el conectado a RW de la lcd, esto tiene sus ventajas y sus inconvenientes, VENTAJAS: tenemos un pin mas sobre el cual poder actuar de nuestro dispositivo, menos lineas de ruteo, etc... INCONVENIENTES: en vez de mandar los datos al lcd empaquetados en 8bits lo mandamos empaquetados en 4 por lo tanto la informacion se procesa de modo mas lenta lo que nos obliga a realizar un retraso de unos 2ms antes de mostrar el mensaje para que pueda ser apreciado todos los caracteres, no podemos leer datos de la lcd, etc.....Bueno decir que segun sea nuestro programa utilizaremos la forma ahorro de un pin o utilizaremos la forma normal...aqui el codigo:

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"05
//                   26/Agosto/05
//
//   Programa:   Hola mundo VsZeNeR"05 ahorrando 1 pin
//   Version:   0.1
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.227
//   Entorno IDE: MPLAB IDE v7.20      Simulador:    Proteus 6.7sp3
//
//   Notas: Se muestra por pantalla de lcd(LM016L) en la primera linea la
//       frase "hola mundo ; )" y en la segunda linea "VsZeNeR"05". Para ahorrar un
//       pin conectamos RW a tierra(GND) y en nuestro programa generamos un retraso de
//       2ms para poder apreciarse todos los caracteres. La ventaja es que nos ahorramos
//       1 pin pero la desventaja es menor rapidez ya que empaquetamos en bloques de 4 bit.
//       Tener en cuenta que hay que poner la directiva NOLVP para que el pin B4 sea de
//       salida.
//
//   Conexiones:      B0 -> E
//               B1 -> RS
//               B4 -> D4
//               B5 -> D5
//               B6 -> D6
//               B7 -> D7
//////////////////////////////////////////////////////////////////////////////////

#include <16f648a.h>            //pic a utilizar
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP      //ordenes para el programador
#use delay (clock=4000000)         //Fosc=4Mhz
#define use_portb_lcd TRUE         //definir portb lcd
#include<lcd.c>                  //libreria manejo lcd

///PROGRAMA
void main(void)
{
   lcd_init();         //inicializa lcd
   delay_ms(2);      //retardo para apreciarse todos los caracteres
   printf(lcd_putc,"hola mundo ; )
VsZeNeR"05" ) ;   //muestra por pantalla el mensaje
}

PD: Recordar que nuestro dispositivo tiene 18 patitas asi que muchas veces esta opcion sera muy util a la hora de realizar nuestros diseños Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 29 de Agosto de 2005, 18:36:00

Desde este enlace os podeis bajar los archivitos del programa: hola mundo ahorrando 1 pin

Suerte!!! :wink:

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 29 de Agosto de 2005, 18:41:00

Decir que nuestro simulador hasta hoy solo podiamos verlo trabajar en el circuito pero no mediante nuestro codigo escrito en c....aqui en este enlace hay un tutorial de como integrar el lenguaje c al simulador PROTEUS y asi poder verlo paso a paso y resolver antes los problemas de programacion que hubieramos tenido!!
[MANUAL] Integrar CCS en PROTEUS (http://www.todopic.com.ar/foros/index.php?topic=12184.0)

PD: Antes, en el archivo .dsn(simulacion de PROTEUS) cargabamos el archivito .hex y simulabamos y veiamos el comportamiento del circuito, ahora mediante esta adaptacion podemos ver tanto el comportamiento del circuito como simularlo paso a paso y las variables definidas y demas!!!asi que apartir de ahora junto al documento .hex agregare el documento .cof que sera el que cargemos en el pic(para simular en PROTEUS!!!!)para asi poder ver paso a paso nuestro programa escrito en c :wink:

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 30 de Agosto de 2005, 07:33:00

Hola!!!el programita de hoy consiste en mostrar por pantalla del lcd el abecedario carcater por carcater(eso si teniendo en cuenta los caracteres imprimibles de la lcd-ver data sheet que esta indicado en unos de los mensajes anteriores Flash

-)uno al lado del otro y borra pantalla y vuelta a empezar:

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"05
//                   26/Agosto/05
//
//   Programa:   Abecedario
//   Version:   0.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.227
//   Entorno IDE: MPLAB IDE v7.21      Simulador:    Proteus 6.7sp3
//
//   Notas: Se muestra por pantalla de lcd(LM016L) el abecedario y vuelta a empezar
//       Tener en cuenta que hay que poner la directiva NOLVP para que el pin B4 sea de
//       salida.
//            ·abecedario[] -> vector donde se almacena abecedario
//            ·x -> indice para vector abecedario e indice para columna lcd
//          ·y -> indice para fila lcd: y=1 -> Fila 1
//                                 y=2 -> Fila 2
//   Conexiones:      B0 -> E
//               B1 -> RS
//               B2 -> RW
//               B4 -> D4
//               B5 -> D5
//               B6 -> D6
//               B7 -> D7
//////////////////////////////////////////////////////////////////////////////////

#include <16f648a.h>            //pic a utilizar
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP      //ordenes para el programador
#use delay (clock=4000000)         //Fosc=4Mhz
#define use_portb_lcd TRUE         //definir portb lcd
#include<lcd.c>                  //libreria manejo lcd

///PROGRAMA
void main(void)
{
   char abecedario[27]={" ","a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"},x,y=1;   //tabla y variables definidas

   lcd_init();         //inicializa lcd

   do{                        //bucle...
   for(x=1;x<27;x++){            //bucle para mostrar digito
      if(y==1)               //1º fila del lcd
         lcd_gotoxy(x,y);
      else                  //2º fila del lcd
         lcd_gotoxy((x-16),y);

      if(x>15)               //¿ya esta completa la 1º fila del lcd?
         y=2;               //SI -> escribe en 2º fila

      printf(lcd_putc,"%c",abecedario[ x ]);   //muestra por pantalla el caracter
      delay_ms(300);
      }
   printf(lcd_putc,"f " ) ;   //borra pantalla del lcd
   y=1;               //restablece indice
   }while(TRUE);               //...infinito
}

Ya sabemos recitar el abecedario...a, b ,c...... Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 30 de Agosto de 2005, 07:36:00

Aqui los archivos necesarios para el programa anterior: abecedario

Suerte!!! :wink:

Título: RE: Ejemplitos en C para 16F648A
Publicado por: Algec en 31 de Agosto de 2005, 02:17:00

Para quien use Displays de anodo comun pego en el almacen la rutina del contador de 0 a 9999 correspondiente y el porteus para un display de 8 digitos.
(pido perdon por modificar codigo pero creo que puede servir a alguien)
Pero tengo una duda, en proteus funciona, pero alguien lo monto?
Vereis, la max corriente de salida o entrada de un puerto pic es de 25 mAmp, si esta patilla da salida o entrada (depende de si es anodo comun o catodo comun) para los 7 seg de un display, necesitaras mas de 100 MAmp, por lo que pienso que es necesario al menos un transistor.
¿QUien lo ha montado?

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 31 de Agosto de 2005, 04:53:00

Ke tal Algec!!!jeje gracias por modificar el ejemplito para anodo comun!!!!asi ya sabemos utilizar las variantes del 7seg(ami se me olvido hacer ejemplos con esa variante!!!jeje gracias de nuevo!),bien decirte hacerca de los 100ma que muchos display"s de 7seg no le hacen falta tanta intensidad....se conforman con 20ma e incluso 10ma(es cuestion de ver el data sheet del dispositivo), aunque tienes razon con respecto a los transistores siempre y cuando queramos amplificar la intensidad entrante por las patitas de seleccion del 7seg....para aquellos que utilicen dispositivos de 7seg que requieran una intensidad mayor decir que simplemente deben conectar un transistor BC327:

Codigo:
7seg CC
     |
     |
     ->|
       |----------porta(pin de seleccion display: RA0,RA1.....)
  GND--|

Mas o menos asi.....que mal dibujo joe!jeje
Pero antes que nada recordar que lo importante de estos ejemplos son los programas en si, es decir la simulacion en PROTEUS no se puede pasar tal cual es a la vida real, ya que si os fijais, nosotros programamos los fuses del dispositivo con cristal externo de 4MHz tipo XL peor en cambio en la simulacion NO aparece, si no aparece es simplemente para ahorrar componentes que creo que son innecesarios para ver si el funcionamiento del programa es el correcto, mi idea antes de iniciar este post era poner fotitos sobre los ejemplos tratados pero se me escacharro la fuente de alimentacio y hasta que no termine de hacerme la nueva pues......jeje(espero que no tarde tanto como la catedral de burgos!!! loco

),tb decir que para pasar del PROTEUS a la vida real simplemente habra que poner el cristal con sus respectivos condensadores,poner el reset externo(aunque esto lo tengo para algun que otro ejemplo con lcd) y poquita cosa mas, decir tb que pasa lo mismo con los programas de lcd, le falta poner el potenciometro del contraste...pero mi intencion es simplemente ver si funcionan los ejemplos aunque si hay que hacerlos completos pues se hace!!!!jeje Giño

PD: Por cierto la modificacion de Algec del SUPER CONTADOR para display"s de 7seg de anodo comun esta en esta direccion:
http://miarroba.com/foros/ver.php?foroid=348538&temaid=3541309

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 31 de Agosto de 2005, 06:25:00

Wenas!!!!jeje bien el programa ke ofrezco hoy es mostrar una frase por lcd e ir moviendola primero por la 1ºfila de la lcd cuando se haya mostrado completo por la primera fila se traslada a la 2ºfila hasta recorrer toda esta 2ºfila y mostrarse completo y vuelta a empezar!!!:

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"05
//                   29/Agosto/05
//
//   Programa:   VsZeNeR"05 mov pantalla
//   Version:   0.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.227
//   Entorno IDE: MPLAB IDE v7.21      Simulador:    Proteus 6.7sp3
//
//   Notas: Se muestra por pantalla de lcd(LM016L) como la palabra VsZeNeR"05
//       se va moviendo por pantalla, empieza en la 1ºfila y termina en la 2ºfila.
//       Se utiliza variables locales:
//            ·x -> indice filas, es de tipo char signed porque necesitamos nº negativos
//             para que en la 2ºfila del lcd aparezca primero el final del mensaje.
//            ·y -> indice de columnas: y=1 -> 1ºcolumna
//                               y=2 -> 2ºcolumna
//       La "x" se comprende en pantalla desde 1 hasta 16 y la "y" desde 1 hasta 2.
//       Tener en cuenta que hay que poner la directiva NOLVP para que el pin B4 sea de
//       salida.
//
//   Conexiones:      B0 -> E
//               B1 -> RS
//               B2 -> RW
//               B4 -> D4
//               B5 -> D5
//               B6 -> D6
//               B7 -> D7
//////////////////////////////////////////////////////////////////////////////////

#include <16f648a.h>            //pic a utilizar
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP      //ordenes para el programador
#use delay (clock=4000000)         //Fosc=4Mhz
#define use_portb_lcd TRUE         //definir portb lcd
#include<lcd.c>                  //libreria manejo lcd

///PROGRAMA
void main(void)
{
   char y=1;               //indice columnas
   signed char x=1;         //indice filas

   lcd_init();               //inicializa lcd

   while(TRUE){      //bucle...
      lcd_gotoxy(x,y) ;      //cursor para escribir mensaje
      lcd_putc("VsZeNeR"05" ) ;   //muestra por pantalla el mensaje
      delay_ms(150);
      x++;               //incremento indice de filas
      if(x>16){            //¿ya se ha mostrado mensaje entero por 1ºfila?
         x=-8;            //SI -> indice fila x=-8
         y++;            //incremento indice columnas
         if(y>2)            //¿ya se ha mostrado mensaje por 2º columna?
            y=1;         //SI -> restauro indice columna
         }
      lcd_putc("f" ) ;         //borra pantalla
      }            //...infinito
}

Ainnsss que pokito kea pa ke termine agosto.... Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 31 de Agosto de 2005, 06:27:00

Desde esta dire os podeis descargar lo necesario para el programa anterior:mover frase por lcd

Suerte!!! :wink:

Título: RE: Ejemplitos en C para 16F648A
Publicado por: Algec en 31 de Agosto de 2005, 07:02:00

Gracias por tu respuesta. El diagrama de proteus es una chapuza (el mio) pero funciona, y ya puestos, ¿porque no hacemos una rutina para libreria en que pasandole un float en coma flotante los visualice en el display poniendo el numero de digitos que tenga el float y el punto decimal en su sitio?
Seria un buen ejercicio para todos el tratar de realizar algo asi
void visualizar_display(float x)
en el que x tuviese valores de hasta 8 digitos y la coma flotante
Fijaos la de codigo que ahorraria en una aplicacion con displays de 7 seg.

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 31 de Agosto de 2005, 12:10:00

Suena bien eso del float..ummmm haber si consigo algo de tiempo y me pongo a trabajar en ello, lo suyo es abrir un post sobre el tema para ir poneindo los avances y las dudas y de camino no llenar este post de dudas y tal sino que sirva de ejemplos para tenerlos a mano(a no ser que sean dudas de los ejemplos expuestos) no se es una sugerencia, de todas formas voy a empezar a trabajar en ello en cuanto tenga algo de tiempo me ha gustado la idea....jeje gracias de nuevo Algec!!!!!

PD: Tendriamos que definir formato y forma de mandar informacion a la funcion y el codigo en si haber como seria lo mas optimo posible....ummmmm neuronas ya en funcionamiento! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: Algec en 31 de Agosto de 2005, 12:15:00

Veras, yo acostumbraba a programar para Pc donde el problema de tamaño del programa era minimo, aqui las rutinas si se usan deben ser lo mas pequeñas posibles ya que el espacio del pic es minimo, y por eso las librerias deben estar muy bien hechas.
Se puede usar tu programita de ejmplo a modo de inicio. Quien tenga algo hecho ya que lo publique, y luego depurar, depurar y depurar el codigo hasta reducir reducir y reducir.
Entre todos una vez hecho quien tenga una idea para reducir codigo aplicarla y postearla.
VEremos si se suma alguien mas. Como veo que controlas el tema inicialo tu, y cuando tengas algo lo publicas y aportamos soluciones.
Por cierto, tengo a medio diseñar una placa estandar (siguiendo un estandar propio) para 8 o menos displays de 7 seg, para pics el que quieras. cuando este lista y probada la publico. LAs del 16F877 16F84 etc estan ya listas probadas y diseñadas. Funcionan bien, siguen un estandar de conexionado y si alguien las necesita tengo algunas tambien para pruebas etc. Estan en uso con librerias , teclado etc.

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 01 de Septiembre de 2005, 09:43:00

Ke tal Algec!!!jeje yo tb acostumbraba a programar para PC jeje(memorias dinamicas jeje) bien la verdad que creo que esa libreria podria ser beneficiosa incluso se podria ampliar para hacer funciones de manejo de display"s de 7seg(ya sean anodo o catodo comun o incluso formato BCD), lo suyo es hacer una libreria digamos "universal" para el manejo de estos dispositivos de cualquier forma....en cuanto termine las vacaciones y ya me ponga a la rutina diaria me pongo a meterle mano y abro el post sobre esa libreria que la verdad suena bien....por cierto lo d las entrenadoras yo tb me hice algunas, estaria bien que las publicaras asi podras ayudar a gente que este buscando fabricarse una(que si no creo recordar mal, lei un post sobre como realizarse una entrenadora...ummm), bueno hasta la proxima!!! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 01 de Septiembre de 2005, 09:46:00

Bueno el programa de hoy se basa ver los limites de la lcd a nivel de pantalla, vamos es igual que el ejemplo anterior pero esta vez la frase en vez de volver al principio(1º fila) sale por la 2ºfila y vuelve a la primera y vuelta a empezar, recorre 1ºfila->2ºfila->2ºfila->1ºfila y asi sucesivamente:

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"05
//                   30/Agosto/05
//
//   Programa:   VsZeNeR"05 mov limites
//   Version:   0.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.227
//   Entorno IDE: MPLAB IDE v7.21      Simulador:    Proteus 6.7sp3
//
//   Notas: Se muestra por pantalla de lcd(LM016L) como la palabra VsZeNeR"05
//       se va moviendo por pantalla, empieza en la 1ºfila y termina en la 2ºfila y
//       empieza a moverse en sentido contrario,2ºfila hasta la 1ºfila.
//       Se utiliza variables globales:
//            ·x -> indice filas, es de tipo char signed porque necesitamos nº negativos
//             para que en la 2ºfila del lcd aparezca primero el final del mensaje.
//            ·y -> indice de columnas: y=1 -> 1ºcolumna
//                               y=2 -> 2ºcolumna
//            ·derecha() -> funcion que muestra mensaje de izquierda a derecha
//            ·izquierda() -> funcion que muestra mensaje de derecha a izquierda
//       La "x" se comprende en pantalla desde 1 hasta 16 y la "y" desde 1 hasta 2.
//       Tener en cuenta que hay que poner la directiva NOLVP para que el pin B4 sea de
//       salida.
//
//   Conexiones:      B0 -> E
//               B1 -> RS
//               B2 -> RW
//               B4 -> D4
//               B5 -> D5
//               B6 -> D6
//               B7 -> D7
//////////////////////////////////////////////////////////////////////////////////

#include <16f648a.h>            //pic a utilizar
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP      //ordenes para el programador
#use delay (clock=4000000)         //Fosc=4Mhz
#define use_portb_lcd TRUE         //definir portb lcd
#include<lcd.c>                  //libreria manejo lcd

///DEFINICION VARIABLES GLOBALES
char y=1;               //indice columnas
signed char x=1;         //indice filas

///DECLARACION DE FUNCIONES
void derecha(void);         //mensaje hacia la derecha
void izquierda(void);      //mensaje hacia la izquierda

///PROGRAMA
void main(void)
{
   lcd_init();         //inicializa lcd

   while(TRUE){      //bucle...
      derecha() ;
      izquierda() ;
      }            //...infinito
}

///FUNCION MUESTRA MENSAJE DE IZQUIERDA -> DERECHA
void derecha(void)
{
   do{
      lcd_gotoxy(x,y);      //cursor para escribir mensaje
      lcd_putc("VsZeNeR"05" );   //muestra por pantalla el mensaje
      delay_ms(150);
      x++;               //incremento indice de filas
      if(x>17){            //¿ya se ha mostrado mensaje entero por 1ºfila?
         x=-8;            //SI -> indice fila x=-8
         y++;            //incremento indice columnas
         if(y>2){         //¿ya se ha mostrado mensaje entero por 2ºfila?
            x=16;         //SI -> actualiza indice filas
            y=2;         //actualiza indice columnas
            return;}      //sal de la funcion derecha()
         }
      lcd_putc("f" );         //borra pantalla
      }while(TRUE);
}
///FUNCION MUESTRA MENSAJE DE DERECHA -> IZQUIERDA
void izquierda(void)
{
   do{
      x--;               //decremento indice de filas
      if(x<-9){            //¿ya se ha mostrado mensaje entero por 2ºfila?
         x=16;            //SI -> indice fila x=16
         y--;            //decremento indice columnas
         if(y<1){         //¿ya se ha mostrado mensaje por 1º fila?
            x=-8;         //SI -> restauro indice filas
            y=1;         //restauro indice columnas
            return;}      //sal de la funcion izquierda()
         }
      lcd_gotoxy(x,y) ;      //cursor para escribir mensaje
      lcd_putc("VsZeNeR"05" ) ;   //muestra por pantalla el mensaje
      delay_ms(150) ;
      lcd_putc("f" ) ;         //borra pantalla
      }while(TRUE) ;
}

Uno mas!!!! :wink:

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 03 de Septiembre de 2005, 06:11:00

Buenass!!!el programita de hoy consiste en sacar por pantalla(lcd) 4 mensajes que grabaremos previamente mediante software, en la eeprom interna del pic:

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"05
//                   30/Agosto/05
//
//   Programa:   Escribir & leer eeprom interna del PIC y mostrarla por lcd
//   Version:   0.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.227
//   Entorno IDE: MPLAB IDE v7.21      Simulador:    Proteus 6.7sp3
//
//   Notas: Se muestra por pantalla de lcd(LM016L) la informacion grabada en la memoria
//       interna del PIC(eeprom) y luego se muestra por la lcd
//       Se utiliza variables locales:
//            ·LAST_VOLUME -> posicion a grabar en la eeprom del pic
//            ·mensaje1[] -> contiene 1º mensaje a escribir en eeprom y mostrar en lcd
//            ·mensaje2[] -> contiene 2º mensaje a escribir en eeprom y mostrar en lcd
//            ·mensaje3[] -> contiene 3º mensaje a escribir en eeprom y mostrar en lcd
//            ·mensaje4[] -> contiene 4º mensaje a escribir en eeprom y mostrar en lcd
//            ·volume -> contiene mensaje leido por la eeprom interna del pic
//       Tener en cuenta que hay que poner la directiva NOLVP para que el pin B4 sea de
//       salida.
//   Conexiones:      B0 -> E
//               B1 -> RS
//               B2 -> RW
//               B4 -> D4
//               B5 -> D5
//               B6 -> D6
//               B7 -> D7
//////////////////////////////////////////////////////////////////////////////////

#include <16f648a.h>            //pic a utilizar
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP      //ordenes para el programador
#use delay (clock=4000000)         //Fosc=4Mhz
#define use_portb_lcd TRUE         //definir portb lcd
#include<lcd.c>                  //libreria manejo lcd


///PROGRAMA
void main(void)
{
   char LAST_VOLUME=0,volume;      //variables de direccion escritura eeprom y mensaje
   char mensaje1[]="VsZeNeR"05";   //mensajes...
   char mensaje2[]="HOLA";
   char mensaje3[]="FORO";
   char mensaje4[]="TODOPIC!";      //a escribir en eeprom interna y mostrar en lcd

   lcd_init();                  //inicializa lcd

   write_eeprom(LAST_VOLUME,mensaje1);   //escritura de los mensajes...
   LAST_VOLUME++;
   write_eeprom(LAST_VOLUME,mensaje2);
   LAST_VOLUME++;
   write_eeprom(LAST_VOLUME,mensaje3);
   LAST_VOLUME++;
   write_eeprom(LAST_VOLUME,mensaje4);   //...en la eeprom interna(0 hasta la 3)

   for( ; ; ){   //bucle...
      for(LAST_VOLUME=0;LAST_VOLUME<4;LAST_VOLUME++){   //bucle que recorre las posiciones de eeprom
      volume = read_EEPROM (LAST_VOLUME);            //almacena mensaje de la direccion eeprom
      printf(lcd_putc,"%s",volume) ;               //muestra mensaje por pantalla lcd
      delay_ms(500);
      lcd_putc("f" );                           //borra pantalla lcd
      }      //...infinito
   }
}
Este ejemplito esinteresante ya que utilizamos la eeprom interna de nuestro dispositivo para almacenar 4 mensajes y despues sacralos por pantalla, recordar que la eeprom es una porcion de memoria no volatil, es decir los tres mensajes grabados se quedaran almacenados en el pic incluso quitandole la alimentacion al pic! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 03 de Septiembre de 2005, 06:15:00

Desde este enlace os podeis descargar los archivos necesarios del programa anterior:escritura y lectura eeprom interna y lo muestra por lcd:

Suerte!!! :wink:

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 05 de Septiembre de 2005, 06:01:00

Vamos con un ejemplito mas de manejo de lcd!!!esta vez haremos un contador de 0 a 9 y vuelta a empezar pero con un pulsador, es decir cada vez que presionemos el pulsador se mostrara el siguiente digito de nuestro contador hasta llegar a 9 que entonces si volvemos a pulsar el boton volvera a cero y se escuchara un beep del zumbador conectado al pic:

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"05
//                   27/Agosto/05
//
//   Programa:   Contador 0a9 por LCD con pulsador y buzzer
//   Version:   0.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.227
//   Entorno IDE: MPLAB IDE v7.21      Simulador:    Proteus 6.7sp3
//
//   Notas: Se muestra por pantalla de lcd(LM016L) un mensaje de inicio del programa
//       y se espera hasta que pulsemos el boton, entonces se borra pantalla y cada vez
//       que presionemos el boton se ira incrementando en un valor el digito mostrado en
//       la mitad de la fila 1º del lcd hasta llegar a 9 que entonces volvera a 0 y se
//    emitira un beep.
//       Tener en cuenta que hay que poner la directiva NOLVP para que el pin B4 sea de
//       salida.
//            ·tabNum[] -> vector donde se almacenan numeros del contador 0a9
//            ·i -> indice para vector tabNum
//   Conexiones:      B0 -> E
//               B1 -> RS
//               B2 -> RW
//               B4 -> D4
//               B5 -> D5
//               B6 -> D6
//               B7 -> D7
//               B3 -> Buzzer(beep)
//////////////////////////////////////////////////////////////////////////////////

#include <16f648a.h>            //pic a utilizar
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP      //ordenes para el programador
#use delay (clock=4000000)         //Fosc=4Mhz
#define use_portb_lcd TRUE         //definir portb lcd
#include<lcd.c>                  //libreria manejo lcd

///PROGRAMA
void main(void)
{
   char tabNum[10]={"0","1","2","3","4","5","6","7","8","9"},i=0;   //tabla y variable definida

   lcd_init();         //inicializa lcd
   printf(lcd_putc,"Presione boton
para contador0a9" );   //muestra mensaje inicio

   do{                     //espera hasta que se pulse boton...
   }while(input(PIN_A0)==1);
   printf(lcd_putc,"f" );      //...para borrar pantalla e iniciar contador

   printf(lcd_putc,"
         VsZeNeR"05" );   //auto publicidad en la 2ºfila lcd
   lcd_gotoxy(8,1);                  //vuelve 1ºfila lcd y apunta la mitad de la columna

   for( ; ; ){                     //bucle...
      if(!input(PIN_A0)){                  //¿se ha pulsado el boton?
         do{                           //SI -> eliminar...
         }while(!input(PIN_A0));            //...rebotes del boton
         if(i>9){                     //¿se ha mostrado digito 9?
            i=0;                     //SI -> restaura valor indice(para mostrar digito 0)
            output_high(PIN_B3);         //activa buzzer(beep)
            delay_ms(50);               //tiempo de escucha del beep
            output_low(PIN_B3);            //desactiva buzzer(beep)
            }
         printf(lcd_putc,"%c",tabNum[ i ]);   //muestra por pantalla el numero
         printf(lcd_putc,"" );            //retrasa el cursor una posicion(escribe encima)
         i++;                        //incremento contador indice tabNum
         }
      }                     //...infinito
}

Ya tenemos nuestro primer contador en lcd!!! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 05 de Septiembre de 2005, 06:05:00

Aqui os podeis descargar los archivos necesarios para el programa anterior: lcd contador 0a9 pulsador&zumbador

Suerte!!! :wink:

Título: RE: Ejemplitos en C para 16F648A
Publicado por: pocher en 06 de Septiembre de 2005, 00:51:00

Hola vszener.

Felicitarte por prestar tus conocimientos de forma desiinteresada.

He estado probando alguno de los ejemplillos y en el del contador BCD de 0 a 9 he detectado un pequeño error.

Codigo:
////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"05      
//                     22/Agosto/05
//
//   Programa:   Contador 0-9 display BDC & Boton
//   Version:   0.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.227
//   Entorno IDE: MPLAB IDE v7.20      Simulador:    Proteus 6.7sp3
//
//   Notas: Contador 0 al 9 cada vez que pulsemos el boton y vuelta a empezar. Tener
//         en cuenta que hay que poner la directiva NOLVP para que el pin B4 sea de 
//         salida. Cuando agregamos un boton a nuestro circuito hay que tener en cuenta
//         que este dispositivo genera "rebotes" que hay que ser eliminados para
//         una correcta visualizacion en el display del digito seleccionado. Esta vez
//         la eliminacion de "los rebotes" se ha realizado mediante software. 
//         Cuando por el pin A0 del porta se introduce un "0" logico(low), se 
//         incrementa un digito en el display BCD.
//
//   Conexiones:      A0 -> boton            
//               B0 -> a 
//               B1 -> b 
//               B2 -> c 
//               B3 -> d 
//   BCD:
//            d c b a   NUM
//            0 0 0 0    0
//            0 0 0 1    1
//            0 0 1 0    2
//            0 0 1 1    3
//            0 1 0 0    4
//            0 1 0 1    5
//            0 1 1 0    6
//            0 1 1 1    7
//            1 0 0 0    8
//            1 0 0 1    9
//////////////////////////////////////////////////////////////////////////////////

#include <16f648a.h>            //pic a utilizar          
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP      //ordenes para el programador 
#use delay (clock=4000000)         //Fosc=4Mhz
#use fixed_io(b_outputs=PIN_B0,PIN_B1,PIN_B2,PIN_B3)
#use standard_io(A)
      
///PROGRAMA
void main(void)
{
   char i=0;   //contador para tabla BCD
   int tabBCD[10]={0b0000,0b0001,0b0010,0b0011,0b0100,0b0101,0b0110,0b0111,0b1000,0b1001};   //BCD 0-9
      
   set_tris_a(0xFF);            //porta como entrada   
   disable_interrupts(GLOBAL);      //todas las interrupciones desactivadas
   
   output_b(tabBCD);         //inicializa displayBCD digito 0

   for(;{                  //bucle...
      if(!input(PIN_A0))         //¿se ha pulsado el boton?
         {
            delay_ms(151);      //SI -> retardo para evitar los rebotes
            i++;            //incremento contador indice tabBCD
            if(i>9)            //¿se ha mostrado digito 9?
               i=0;         //SI -> restaura valor indice(para mostrar digito 0)
            output_b(tabBCD); //muestra por portb digito 7 segmentos
         }
      
      }                     //...infinito
}

Si no levantas el dedo deprisa del pulsador cuenta varios números. Se solucionaría detectando el levantamiento del pulsador, así:

Codigo:
for(;{                  //bucle...
      if(!input(PIN_A0))         //¿se ha pulsado el boton?
         {
            delay_ms(151);      //SI -> retardo para evitar los rebotes
            i++;            //incremento contador indice tabBCD
            if(i>9)            //¿se ha mostrado digito 9?
               i=0;         //SI -> restaura valor indice(para mostrar digito 0)
            output_b(tabBCD); //muestra por portb digito 7 segmentos
         }
      while(!input(PIN_A0));
      delay_ms(151);
      }                     //...infinito
}

Un saludo

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 06 de Septiembre de 2005, 06:56:00

Ke tal pocher!!!gracias por la rectificacion....los malditos "rebotes" jeje aunque en algun que otro ejemplo ya se programo como tu indicas...de todas formas muchas gracias!, bien decir que el ejemplo siguiente vamos a utilizar una memoria eeprom externa, concretamente la 24LC256 (32KB I2C EEPROM), asi que os dejare los enlaces para que os relacioneis con el dipositivo a tratar:
El espacio que microchip dedica a este dispositivo:
http://www.microchip.com/stellent/idcplgidcplg?IdcService=SS_GET_PAGE&nodeId=1335&dDocName=en010823
La tabla librerias de CCS(es igual que el anterior...):
http://www.ccsinfo.com/data.shtml
Bueno para trabajar con esta memoria lo haremos mediante la libreria incluida en el compilador CCS llamada 24256.c la cual tiene definidas las funciones a tratar de lectura/escritura del dispositivo.
Manos a la obra!!!! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 06 de Septiembre de 2005, 06:58:00

Holaaaa!!!!el programita de hoy consiste en grabar 4 mensajes en la memoria externa 24LC256(32KB I2C EEPROM) y despues leerlos para mostrarlos por la lcd:

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"05
//                   30/Agosto/05
//
//   Programa:   Escribir & leer eeprom externa 24LC256 y mostrarla por lcd
//   Version:   0.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.227
//   Entorno IDE: MPLAB IDE v7.21      Simulador:    Proteus 6.7sp3
//
//   Notas: Se muestra por pantalla de lcd(LM016L) la informacion grabada en la memoria
//       externa 24LC256(eeprom) y luego se muestra por la lcd
//       Se utiliza variables locales:
//            ·dir-> posicion a grabar en la eeprom 24LC256
//            ·men1[] -> contiene 1º mensaje a escribir en eeprom y mostrar en lcd
//            ·men2[] -> contiene 2º mensaje a escribir en eeprom y mostrar en lcd
//            ·men3[] -> contiene 3º mensaje a escribir en eeprom y mostrar en lcd
//            ·men4[] -> contiene 4º mensaje a escribir en eeprom y mostrar en lcd
//       En la pantalla lcd se muestra la direccion de memoria donde esta grabado el
//       mensaje a mostrar y el correspondiente mensaje.
//       Tener en cuenta que hay que poner la directiva NOLVP para que el pin B4 sea de
//       salida.
//   Conexiones:      A0 -> SCK eeprom externa
//               A1 -> SDA eeprom externa
//               B0 -> E
//               B1 -> RS
//               B2 -> RW
//               B4 -> D4
//               B5 -> D5
//               B6 -> D6
//               B7 -> D7
//////////////////////////////////////////////////////////////////////////////////

#include <16f648a.h>            //pic a utilizar
#use delay(CLOCK=4000000)         //Fosc=4Mhz
#fuses HS,NOPUT,NOPROTECT,NOBROWNOUT,NOLVP,NOWDT   //comandos para el programador
#define use_portb_lcd TRUE         //utilizar el port b para lcd
#define EEPROM_SDA PIN_A1          //definimos los pines donde...
#define EEPROM_SCL PIN_A0          //la eeprom ira conectada
#include <24256.c>               //libreria de eeprom externa 24LC256
#include <lcd.c>                //libreria de lcd

///PROGRAMA
void main(void){
   int dir=0;               //direccion de eeprom a escribir y leer mensajes
   char men1[]="VsZeNeR"05";   //declaracion de...
   char men2[]="Hola";
   char men3[]="Foro";
   char men4[]="TODOPIC!";      //...mensajes a escribir y leer por 25LC256

   lcd_init();             //inicializa lcd
   init_ext_eeprom();          //inicializa eeprom

   lcd_putc("~ Escribiendo en...
24LC256
" ) ;
   delay_ms(500);
   write_ext_eeprom(dir,men1 ) ;      //proceso de escribir...
   dir++;
   write_ext_eeprom(dir,men2 ) ;
   dir++;
   write_ext_eeprom(dir,men3 ) ;
   dir++;
   write_ext_eeprom(dir,men4) ;      //...los mensajes en la eeprom externa
   lcd_putc("fFin de escritura en
24LC25" ) ;
   delay_ms(1500) ;

   lcd_putc("f>>>Leyendo...
" ) ;
    for(dir=0;dir<4;dir++){         //bucle para leer mensajes en eeprom externa y muestra por lcd
      printf(lcd_putc,"
%d ~ %s",dir,read_ext_eeprom(dir) ) ;
      delay_ms(1500);                  //retraso para que se vea en pantalla los mensajes
      lcd_putc("
" );      //borrado 2ºlinea de lcd
      }
   output_a(0b00);                     //apago port a
   lcd_putc("fFin de lectura!" ) ;

   for( ; ; ){                     //animacion...
      for(dir=1;dir<8;dir++){
         lcd_gotoxy(dir,2);
         lcd_putc("VsZeNeR"05" ) ;
         delay_ms(200);
         lcd_putc("
" );
         }
      for(dir=6;dir>1;dir--){
         lcd_gotoxy(dir,2);
         lcd_putc("VsZeNeR"05" ) ;
         delay_ms(200);
         lcd_putc("
" ) ;
         }
      }                        //...final
}

Ya sabemos grabar tanto en memoria eeprom del pic(memoria interna) como memoria externa!!!!jeje joeee que lejano se ve ahora eso de iluminar un led!!! Giño

PD: Decir que la instruccion lcd_putc("
" ); despues de la
debe haber 16 espacios en blanco para poder borrar la 2ºlinea del lcd(2x16) okis???lo que pasa que aqui no sale, no mantiene los espacios.....

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 06 de Septiembre de 2005, 07:05:00

De aqui os podeis descargar los ficheros del programa anterior: escritura y lectra de eeprom externa 24LC256y lectura por lcd

Suerte!!! :wink:

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 08 de Septiembre de 2005, 07:28:00

Buenas!!!!hoy vamos a trasladar un programa anterirmente realizado en display de 7seg a la lcd....esta vez vamos hacer un dado y su resultado se mostrara por la lcd:

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"05
//                   08/Septiembre/05
//
//   Programa:   Dado digital con lcd y buzzer
//   Version:   0.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.227
//   Entorno IDE: MPLAB IDE v7.21      Simulador:    Proteus 6.7sp3
//
//   Notas: Dado digital, que al presionar el boton conectado al pin A0 del porta
//       genera un numero pseudo-aleatorio mediante la funcion rand() que se
//       encuentra en la libreria STDLIB.H. El numero pseudo-aleatorio es elegido
//       mediante la funcion rand() y segun los "rebotes" producidos por el boton.Tener
//       en cuenta que hay que poner la directiva NOLVP para que el pin B4 sea de
//       salida. Cuando agregamos un boton a nuestro circuito hay que tener en cuenta
//       que este dispositivo genera "rebotes" que hay que ser eliminados para
//       una correcta visualizacion en la lcd del digito seleccionado. Esta vez
//       la eliminacion de "los rebotes" se ha realizado mediante software.
//
//   Conexiones:      A0 -> boton
//               B0 -> E
//               B1 -> RS
//               B2 -> RW
//               B4 -> D4
//               B5 -> D5
//               B6 -> D6
//               B7 -> D7
//               B3 -> Buzzer(beep)
//////////////////////////////////////////////////////////////////////////////////

#include <16f648a.h>            //pic a utilizar
#define RAND_MAX 7               //dado solamente 6 numeros
#include <STDLIB.H>               //libreria donde esta la funcion rand();
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP      //ordenes para el programador
#use delay (clock=4000000)         //Fosc=4Mhz
#use standard_io(B)
#use fast_io(A)
#define use_portb_lcd TRUE         //definir portb lcd
#include<lcd.c>                  //libreria manejo lcd

///PROGRAMA
void main(void)
{
   char num=0;                  //variable almacena numero aleatorio

   set_tris_a(0xFF);            //porta como entrada
   disable_interrupts(GLOBAL);      //todas las interrupciones desactivadas

   lcd_init();                  //inicializa lcd

   srand(10);                  //maximo hasta 9
   lcd_putc("Dado Electronico
Pulse boton..." );

   while(input(PIN_A0)){}         //Se mantiene cabecera hasta que se pulse el boton

   lcd_putc("fDado:
VsZeNeR"05" );
   lcd_gotoxy(7,1);            //Coordenadas dond se muestra el numero

   for( ; ; ){                  //bucle...
      if(!input(PIN_A0))         //¿se ha pulsado el boton?
         {
            do{                     //SI -> elimina...
               num=rand();            //genera numero pseudo-aleatorio
               }while(!input(PIN_A0));   //...rebotes

            printf(lcd_putc,"%d",num);   //muestra por lcd numero
            lcd_putc("" );            //retrocede un espacio
            output_high(PIN_B3);      //activa buzzer(beep)
            delay_ms(50);            //tiempo de escucha del beep
            output_low(PIN_B3);         //desactiva buzzer(beep)
         }
      }                     //...infinito
}

Ya tenemos nuestro dado formato lcd.... Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 08 de Septiembre de 2005, 07:30:00

Aqui os podeis descargar los archivitos necesarios para el programa anterior: Dado en lcd

Suerte!!! :wink:

Título: RE: Ejemplitos en C para 16F648A
Publicado por: RaDoN en 08 de Septiembre de 2005, 10:13:00

Joer... ahi librerias para hacer numeros aleatorios¿? juas Sonrisa Gigante

que paranoya, algo nuevo que aprendo Vacilando

Por cierto, porque desactivas las interrupciones ¿?¿? el micro comienza así ya Idea

Título: RE: Ejemplitos en C para 16F648A
Publicado por: nordestenica en 08 de Septiembre de 2005, 10:33:00

la verdad es que si no aprendemos lo que nos ensenha el maestro e profesor vszener , mas nos vale dejar la escuela de los pics e dedicarnos a otra cosa es que es un genio, ademas que sus esplicaciones son claras e intuitivas

lo que estoi aprendiendo com el prof vszener la ingeniera Xelene los maestros noturno66 , pocher , todopic , MGLSOFT , pacalaconcurso e todos los demas que no menciono por que iba a quedar sim espacio sois unos genios gracias por lo que estoi aprendiendo com ustedes

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 08 de Septiembre de 2005, 10:42:00

Lo de desactivar las interrupciones es simple metodoligia....costumbre de programacion jeje....y gracias nordestenica por lo de maestro!!!jeje pero todavia me keda un pokitin para serlo jeje!!!aqui aprendemos todos de todos como buenos hermanos.... Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: MGLSOFT en 08 de Septiembre de 2005, 12:20:00

Si que hay librerias para generar numeros aleatorios...
El problema es que igual que PBP genera numeros pseudo aleatorios, si revisas luego lo que larga veras que hay una constante para hacerlos.
La ventaja del CCS es que tiene una funcion SRand() que es similar pero permite dos cosas, una generarlo a partir de una semilla y otra proponer uno mismo el alcance numerico sobre el cual calcular el numero aleatorio.
Estas dos ventajas lo convierten en menos influenciable por la caracteristica pseudo aleatoria mencionada anteriormente.
Sonrisa Gigante

Título: RE: Ejemplitos en C para 16F648A
Publicado por: RaDoN en 08 de Septiembre de 2005, 13:43:00

Bueno sí, eso esta claro, en programacion no hay nada "aleatorio", todo tiene una secuencia, si no que se o pregunten a los que se curran los generadores de claves Vacilando

Título: RE: Ejemplitos en C para 16F648A
Publicado por: Nocturno en 09 de Septiembre de 2005, 02:30:00

¿No creeis que se podría generar una semilla aleatoria realmente aleatoria si formamos un byte con 8 lecturas consecutivas sobre un pin que esté configurado como entrada "al aire"?

Título: RE: Ejemplitos en C para 16F648A
Publicado por: pocher en 09 de Septiembre de 2005, 03:51:00

Sí esa sería una forma.

Otra leyendo el valor de un TMR en un momento al hazar.

Título: RE: Ejemplitos en C para 16F648A
Publicado por: Nocturno en 09 de Septiembre de 2005, 04:10:00

Sí, pero ese momento al azar sólo puede venir de un evento externo, ¿no?.

Título: RE: Ejemplitos en C para 16F648A
Publicado por: RaDoN en 09 de Septiembre de 2005, 04:21:00

Escrito originalmente por nocturno66
¿No creeis que se podría generar una semilla aleatoria realmente aleatoria si formamos un byte con 8 lecturas consecutivas sobre un pin que esté configurado como entrada "al aire"?

Tenia entendido que eso no es especialmente bueno para la entrada loco

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 11 de Septiembre de 2005, 05:30:00

Bueno el siguiente ejemplito vamos a utilizar un RTC(real time clock), es decir un reloj de tiempo real, el dispositivo rtc a tratar es el DS1302 de Dallas Semiconductor, este dispositivo aparte de dar la hora en tiempo real, tambien da la fecha, es decir es un dispositivo que se comporta como reloj-calendario, la pagina que dedica Dallas al dispositivo:
http://www.maxim-ic.com/quick_view2.cfm/qv_pk/2685
Y vamos a trabajar con la libreria que trae CCS para este dispositivo la cual es DS1302.C donde estan todas las funciones definidas para el manejo del dispositivo en cuestion, la pagina web donde esta la libreria mencionada:
http://www.ccsinfo.com/data.shtml
Bien, mirarse los enlaces anteriores(los data sheet) para saber con que nos enfrentamos!!!!jeje
Al lio!!!! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 11 de Septiembre de 2005, 05:39:00

Y bien he aqui el programita!!!jeje bien decir que he intentado utilizar las funciones basicas del DS1302, es decir, su configuracion(escribir la hora y la fecha) y despues su posterior lectura para mostrarla por la lcd, la programacion es algo extensa pero creo que asi es mas clara, se puede eliminar ciertas lineas de codigo e incluso hacerse de otra forma(la cual ya pondre), pero entonces resulta mas lioso de entender el funcionamiento del programa....jeje, bueno aqui el programita:

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"05
//                   09/Septiembre/05
//
//   Programa:   Reloj-Calendario DS1302
//   Version:   0.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.227
//   Entorno IDE: MPLAB IDE v7.21      Simulador:    Proteus 6.7sp3
//
//   Notas: Se muestra por pantalla de lcd(LM016L) la fecha y hora obtenida mediante la
//       lectura del DS1302. Pudiendose modificar mediante los botones Conf/Ok y up.
//       Se utiliza variables globales:
//            ·day-> dia ds1302
//            ·mth -> mes ds1302
//            ·year -> año ds1302
//            ·hour -> hora ds1302
//            ·min -> minutos ds1302
//            ·sec-> segundos ds1302
//            ·menu -> variable que muestra opcion del menu configurar
//            ·flag -> variable que cuenta hasta 130ms aprox.
//            ·var -> ajuste fino para que desborde cada 130ms aprox.
//       Se carga el TMR0 con 0 por lo tanto se desborda en 65ms aprox, queremos
//       visualizar y restaurar valores cogidos del ds1302 cada 130ms aprox por lo tanto
//       utilizamos una variable llamada flag que sera la encargada de dicha tarea.
//       Al inicio del programa debe ser configurado el reloj, siendo el boton "up" el
//       encargado de ir moviendose mediante las opciones del menu:hora,minutos,....
//       y el boton "Conf/Ok" el encargado de configurar el reloj(cuando estemos en modo ver
//       hora y fecha) o el encargado de salir de la configuracion de las opciones(cuando
//       estemos en formato de configurar fecha y hora).
//       Tener en cuenta que hay que poner la directiva NOLVP para que el pin B4 sea de
//       salida.
//   Conexiones:      A0 -> RST DS1302
//               A1 -> SCLK DS1302
//               A2 -> I/O DS1302
//               A3 -> Boton "up"
//               A5 -> Boton "Conf/Ok"
//               B0 -> E
//               B1 -> RS
//               B2 -> RW
//               B4 -> D4
//               B5 -> D5
//               B6 -> D6
//               B7 -> D7
//               B3 -> Zumbador(beep)
//////////////////////////////////////////////////////////////////////////////////

#include <16f648a.h>            //pic a utilizar
#use delay(CLOCK=4000000)         //Fosc=4Mhz
#fuses HS,NOPUT,NOPROTECT,NOBROWNOUT,NOLVP,NOWDT,NOMCLR   //comandos para el programador
#use standard_io(a)
#use standard_io(b)
#define use_portb_lcd TRUE         //utilizar el port b para lcd
#define RTC_SCLK PIN_A1            //definimos pin"s...
#define RTC_IO PIN_A2
#define RTC_RST PIN_A0            //...de conexion de la rtc ds1302
#include <ds1302.c>               //libreria de rtc ds1302
#include <lcd.c>                //libreria de lcd

///VARIABLES GLOBALES
byte day,mth,year,dow,hour,min,sec;   //variabes para ds1302
byte menu=0,flag=0,var=2;         //variables para menu configurar

///DEFINICION DE FUNCIONES
void configurar(void);
void horas(void);
void minutos(void);
void dia(void);
void mes(void);
void anio(void);
void beep(void);

///LLAMADA FUNCION INTERRUPCION
#INT_TIMER0
void interrupcion()
{
   if(flag>var){      //¿ya es 130ms aprox?
      var--;         //SI -> decremento var...
      if(var==0)
         var=2;      //...ajuste fino de 130ms aprox
      flag=0;         //reset flag para contar 130ms aprox
      rtc_get_date(day,mth,year,dow);      //coge dia,mes,año
   rtc_get_time(hour,min,sec );      //coge hora,minuto,segundo
      printf(lcd_putc,"fFecha: %2X/%2X/%2X
Hora: %2X:%2X:%2X",day,mth,year,hour,min,sec);

//lcd
      }

   set_timer0(0);      //reset TMR0
   flag++;            //incremento variable flag
}

///PROGRAMA
void main(void){

   enable_interrupts(INT_TIMER0);            //interrupcion TIMER0 activada
   setup_counters(RTCC_INTERNAL,RTCC_DIV_256);   //configuracion interrupcion TMR0
   set_timer0(0);                        //carga TMR0

   lcd_init();          //inicializa lcd
   rtc_init();          //inicializa rtc

   lcd_putc("Reloj Calendario
VsZeNeR"05" );   //presentacion...
   delay_ms(800);                           //...inicial

   configurar();                        //ve a menu configurar
   enable_interrupts(GLOBAL);               //activadas interrupciones

    for( ; ; ){         //bucle...
      if(input(PIN_A5)==0){            //Si se pulsa Conf....
         while(!input(PIN_A5)){}         //elimina rebotes
         beep();
         configurar();
         }                        //ve a menu

configurar
      }             //...infinito
}

///FUNCION CONFIGURAR
void configurar(void){
   disable_interrupts(GLOBAL);               //desactivadas interrupciones

   do{
      switch(menu){
         case 0:   lcd_putc("fConfigurar
horas?" );      //horas
               if(!input(PIN_A5)){
                  while(!input(PIN_A5)){}
                  beep();
                  horas();
                  menu=1;

   //apunta siguiente opcion
                  }
               break;
         case 1: lcd_putc("fConfigurar
minutos?" );      //minutos
               if(!input(PIN_A5)){
                  while(!input(PIN_A5)){}
                  beep();
                  minutos();
                  menu=2;

   //apunta siguiente opcion
                  }
               break;
         case 2: lcd_putc("fConfigurar
dia?" );         //dias
               if(!input(PIN_A5)){
                  while(!input(PIN_A5)){}
                  beep();
                  dia();
                  menu=3;

   //apunta siguiente opcion
                  }
               break;
         case 3: lcd_putc("fConfigurar
mes?" );         //mes
               if(!input(PIN_A5)){
                  while(!input(PIN_A5)){}
                  beep();
                  mes();
                  menu=4;

   //apunta siguiente opcion
                  }
               break;
         case 4: lcd_putc("fConfigurar
anio?" );      //años
               if(!input(PIN_A5)){
                  while(!input(PIN_A5)){}
                  beep();
                  anio();
                  menu=5;

   //apunta siguiente opcion
                  }
               break;
         case 5: lcd_putc("fSalir
configurar?" );      //salir configuracion
               if(!input(PIN_A5)){
                  menu=6;
                  beep();
                  }
         }

      if(!input(PIN_A3)){            //controla el boton up...
         while(!input(PIN_A3)){}
         menu++;
         if(menu>5)
            menu=0;
         }                     //...para mostrar menu

por lcd

      delay_ms(130);               //retardo para ver lcd
      }while(menu<6);

      menu=0;

//actualiza indices menu
      rtc_set_datetime(day,mth,year,dow,hour,min);   //nueva hora,minuto,...
      enable_interrupts(GLOBAL);                  //activadas

interrupciones
      set_timer0(0);

//carga TMR0
}
///FUNCION CONFIGURA HORAS
void horas(void){
   printf(lcd_putc,"fConf.Horas:
Hora: %2X:%2X:%2X",hour,min,sec);   //muestra por lcd
   do{
      if(!input(PIN_A3)){                  //¿se ha pulsado up?
         while(!input(PIN_A3)){}            //elimina rebotes
         hour++;                        //SI ->

incremento hour
         switch(hour){                  //limites...
            case 0x0A:   hour=0x10;break;
            case 0x1A:   hour=0x20;break;
            case 0x24:   hour=0x00;
            }

//...hour
         printf(lcd_putc,"
Hora: %2X:%2X:%2X",hour,min,sec);   //muestra por lcd hour
         }
      }while(input(PIN_A5));
   while(!input(PIN_A5)){}         //elimina rebotes
}
///FUNCION CONFIGURA MINUTOS
void minutos(void){
   printf(lcd_putc,"fConf.Minutos:
Hora: %2X:%2X:%2X",hour,min,sec);   //muestra por lcd
   do{
      if(!input(PIN_A3)){            //¿se ha pulsado up?
      while(!input(PIN_A3)){}         //elimina rebotes
      min++;                     //SI -> incremento min
      switch(min){               //limites...
         case 0x0A:   min=0x10;break;
         case 0x1A:   min=0x20;break;
         case 0x2A:   min=0x30;break;
         case 0x3A:   min=0x40;break;
         case 0x4A:   min=0x50;break;
         case 0x5A:   min=0x00;
         }                     //...min
      printf(lcd_putc,"
Hora: %2X:%2X:%2X",hour,min,sec);   //muestra por lcd min
      }
      }while(input(PIN_A5));
   while(!input(PIN_A5)){}         //elimina rebotes
}
///FUNCION CONFIGURA DIAS
void dia(void){
   printf(lcd_putc,"fConf.Dias:
Fecha: %2X/%2X/%2X",day,mth,year);   //muestra por lcd
   do{
      if(!input(PIN_A3)){               //¿se ha pulsado up?
         while(!input(PIN_A3)){}         //elimina rebotes
         day++;                     //SI -> incremento day
         switch(day){               //limites...
            case 0x0A:   day=0x10;break;
            case 0x1A:   day=0x20;break;
            case 0x2A:   day=0x30;break;
            case 0x32:   day=0x01;
            }                     //...day
         printf(lcd_putc,"fConf.Dias:
Fecha: %2X/%2X/%2X",day,mth,year);

//muestra por lcd day
         }
      }while(input(PIN_A5));
   while(!input(PIN_A5)){}         //elimina rebotes
}
///FUNCION CONFIGURA MES
void mes(void){
   printf(lcd_putc,"fConf.Mes:
Fecha: %2X/%2X/%2X",day,mth,year);   //muestra por lcd
   do{
      if(!input(PIN_A3)){               //¿se ha pulsado up?
         while(!input(PIN_A3)){}         //elimina rebotes
         mth++;                     //SI -> incremento mth
         switch(mth){               //limites...
            case 0x0A:   mth=0x10;break;
            case 0x13:   mth=0x01;
            }                     //...mth
      printf(lcd_putc,"fConf.Mes:
Fecha: %2X/%2X/%2X",day,mth,year);   //muestra por

lcd
         }
      }while(input(PIN_A5));
   while(!input(PIN_A5)){}         //elimina rebotes
}
///FUNCION CONFIGURA AÑOS
void anio(void){
   printf(lcd_putc,"fConf.Anio:
Fecha: %2X/%2X/%2X",day,mth,year);   //muestra por lcd
   do{
      if(!input(PIN_A3)){               //¿se ha pulsado up?
         while(!input(PIN_A3)){}         //elimina rebotes
         year++;                     //SI -> incremento mth
         switch(year){               //limites...
            case 0x0A:   year=0x10;break;
            case 0x1A:   year=0x20;break;
            case 0x2A:   year=0x30;break;
            case 0x3A:   year=0x40;break;
            case 0x4A:   year=0x50;break;
            case 0x5A:   year=0x60;break;
            case 0x6A:   year=0x70;break;
            case 0x7A:   year=0x80;break;
            case 0x8A:   year=0x90;break;
            case 0x9A:   year=0x00;
            }                     //...year
      printf(lcd_putc,"fConf.Anio:
Fecha: %2X/%2X/%2X",day,mth,year);   //muestra por

lcd
         }
      }while(input(PIN_A5));
   while(!input(PIN_A5)){}         //elimina rebotes
}
///FUNCION BEEP
void beep(void){
   output_high(PIN_B3);   //activa zumbador
   delay_ms(50);
   output_low(PIN_B3);      //desactiva zumbador
}

Decir, que el programita aparte de manejar dispositivos externos(lcd,buzzer,ds1302), maneja tb la interrupcion del TMR0 para la visualizacion en formato visualizar fecha-hora en la lcd, aparte tb he quitado la funcion de reset externo mediante el MRCL y he utilizado ese pin para el boton "Conf/Ok" esto no es aconsejable ya que siempre es bueno tener un reset externo pero bueno era simplemente para poner un ejemplo de eliminar el reset externo y utilizar dicho pin como un puerto mas...
Pues ya tenemos un reloj-calendario!!!!ya no hay excusa de no saber que hora es ni en que dia vivimos!jeje Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 11 de Septiembre de 2005, 05:42:00

Desde este enlace os podeis descargar lo necesario para el programa anterior: Reloj-Calendario ds1302

Suerte!!! :wink:

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 13 de Septiembre de 2005, 10:14:00

Buenas!!!!jeje hoy hace un mes que inicie este post!!!!y ya van 33 ejemplitos creo!!!!!jeje ya sabemos encender y apagar led"s de casi todas las formas habidas por haber, sabemos utilizar display"s de 7seg(solos, multiplexados,de anodo comun, de catodo comun,bcd.....), sabemos utilizar lcd 2x16, sabemos leer y escribir en eeprom externa e interna, sabemos manejar un rtc.....jeje no veas en un mes lo que ha dado de si!jeje bien pues ahora el proposito es interaccionar con el PC, es decir "enchufar" el PIC al PC, debemos saber que tenemos tener en cuenta la compatibilidad de tensiones de los pines del pic con las del puerto RS232 a tratar!para ello usaremos un dispositivo llamado MAX232 que adapta las tensiones adecuandolas al PC y al PIC, aqui el enlace al MAX232 de dallas semiconductor:
http://www.maxim-ic.com/quick_view2.cfm/qv_pk/1798
Desde esta dire os explican el funcionamiento del MAX232:
http://www.x-robotics.com/

Giño

!!!

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 13 de Septiembre de 2005, 10:18:00

Holaa!!!!!aqui esta el ejemplito de interaccionar el pic con el pc, bien consiste en mostrar por lcd un mensaje y por el pc otro:

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"05
//                   11/Septiembre/05
//
//   Programa:   Comunicacion PC via RS232
//   Version:   0.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.227
//   Entorno IDE: MPLAB IDE v7.21      Simulador:    Proteus 6.7sp3
//
//   Notas: Se muestra por pantalla de lcd(LM016L) en la primera linea la
//       frase "hola mundo Giño

" y en la segunda linea "VsZeNeR"05". Se muestra el
//       mismo mensaje por el PC. Tener en cuenta que hay que poner la directiva
//       NOLVP para que el pin B4 sea de salida.
//
//   Conexiones:      B0 -> E
//               B1 -> RS
//               B2 -> RW
//               B4 -> D4
//               B5 -> D5
//               B6 -> D6
//               B7 -> D7
//               A0 -> T1IN MAX232
//               A1 -> R1OUT MAX232
//////////////////////////////////////////////////////////////////////////////////
#include <16f648a.h>            //pic a utilizar
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP,NOBROWNOUT      //ordenes para el programador
#use delay (clock=4000000)         //Fosc=4Mhz
#use rs232(baud=9600, xmit=PIN_A0, rcv=PIN_A1)   //manejo del RS232
#define use_portb_lcd TRUE         //definir portb lcd
#include<lcd.c>                  //libreria manejo lcd

///PROGRAMA
void main(void)
{
   lcd_init();         //inicializa lcd

   printf(lcd_putc,"hola mundo ; )
VsZeNeR"05" );   //mensaje por lcd
   printf("hola mundo VsZeNeR"05" );            //mensaje por PC
}

Decir que en la simulacion con PROTEUS, se utilizado el MAX232, esto no hace falta para la simulacon ya que directamente podriamos haber conectado las patitas Tx y Rx al correspondiente del virtual terminal de PROTEUS, se ha añadido para se vea su conexion del pic al pc......ya hace un mes que inicie el post!!!!!oleeeee!!!! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 13 de Septiembre de 2005, 10:21:00

Desde este enlace os podeis descargar los archivos necesarios para el programa anterior: lcd & RS232

Suerte!!! :wink:

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 16 de Septiembre de 2005, 07:58:00

Buenas!!!!Bien, el siguiente ejemplito es basado el un programa anteriormente realizado, es un reloj-calendario(ds1302) peor esta vez por el PC, es decir anteriormente hicimos un reloj-calendario pero en una lcd y esta vez es usando el RS232, la programacion se ha modificado muy poco, solamente se ha mejorado el modo configurar horas-fecha para que no diera tantos saltos y poquito mas(intentare con mas tiempo revisarlo entero para hacer un codigo optimo), aqui el programa:

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"05
//                   09/Septiembre/05
//
//   Programa:   Reloj-Calendario DS1302 y RS232
//   Version:   1.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.227
//   Entorno IDE: MPLAB IDE v7.21      Simulador:    Proteus 6.7sp3
//
//   Notas: Se muestra por virtual terminal la fecha y hora obtenida mediante la
//       lectura del DS1302. Pudiendose modificar mediante los botones Conf/Ok y up.
//       Se utiliza variables globales:
//            ·day-> dia ds1302
//            ·mth -> mes ds1302
//            ·year -> año ds1302
//            ·hour -> hora ds1302
//            ·min -> minutos ds1302
//            ·sec-> segundos ds1302
//            ·menu -> variable que muestra opcion del menu configurar
//            ·flag -> variable que cuenta hasta 130ms aprox./ tb vale como control menu
//            ·var -> ajuste fino para que desborde cada 130ms aprox.
//       Se carga el TMR0 con 0 por lo tanto se desborda en 65ms aprox, queremos
//       visualizar y restaurar valores cogidos del ds1302 cada 130ms aprox por lo tanto
//       utilizamos una variable llamada flag que sera la encargada de dicha tarea.
//       Al inicio del programa debe ser configurado el reloj, siendo el boton "up" el
//       encargado de ir moviendose mediante las opciones del menu:hora,minutos,....
//       y el boton "Conf/Ok" el encargado de configurar el reloj(cuando estemos en modo ver
//       hora y fecha) o el encargado de salir de la configuracion de las opciones(cuando
//       estemos en formato de configurar fecha y hora).
//       Tener en cuenta que hay que poner la directiva NOLVP para que el pin B4 sea de
//       salida.
//   Conexiones:      A0 -> RST DS1302
//               A1 -> SCLK DS1302
//               A2 -> I/O DS1302
//               A3 -> Boton "up"
//               A5 -> Boton "Conf/Ok"
//               B1 -> Tx
//               B2 -> Rx
//               B3 -> Zumbador(beep)
//////////////////////////////////////////////////////////////////////////////////

#include <16f648a.h>            //pic a utilizar
#use delay(CLOCK=4000000)         //Fosc=4Mhz
#fuses HS,NOPUT,NOPROTECT,NOBROWNOUT,NOLVP,NOWDT,NOMCLR   //comandos para el programador
#use standard_io(a)
#use standard_io(b)
#use rs232(baud=9600, xmit=PIN_B1, rcv=PIN_B2, FORCE_SW)   //manejo del RS232
#define RTC_SCLK PIN_A1            //definimos pin"s...
#define RTC_IO PIN_A2
#define RTC_RST PIN_A0            //...de conexion de la rtc ds1302
#include <ds1302.c>               //libreria de rtc ds1302

///VARIABLES GLOBALES
byte day,mth,year,dow,hour,min,sec;   //variabes para ds1302
byte menu=0,flag=0,var=2;         //variables para menu configurar

///DEFINICION DE FUNCIONES
void configurar(void);
void horas(void);
void minutos(void);
void dia(void);
void mes(void);
void anio(void);
void beep(void);

///LLAMADA FUNCION INTERRUPCION
#INT_TIMER0
void interrupcion()
{
   if(flag>var){      //¿ya es 130ms aprox?
      var--;         //SI -> decremento var...
      if(var==0)
         var=2;      //...ajuste fino de 130ms aprox
      flag=0;         //reset flag para contar 130ms aprox
      rtc_get_date(day,mth,year,dow);      //coge dia,mes,año
   rtc_get_time(hour,min,sec );      //coge hora,minuto,segundo
      printf("fFecha: %2X/%2X/%2X
Hora: %2X:%2X:%2X",day,mth,year,hour,min,sec);   //lcd
      }

   set_timer0(0);      //reset TMR0
   flag++;            //incremento variable flag
}

///PROGRAMA
void main(void){

   enable_interrupts(INT_TIMER0);            //interrupcion TIMER0 activada
   setup_counters(RTCC_INTERNAL,RTCC_DIV_256);   //configuracion interrupcion TMR0
   set_timer0(0);                        //carga TMR0

   rtc_init();          //inicializa rtc

   puts("Reloj Calendario" );
   puts("VsZeNeR"05" );
   delay_ms(800);                           //...inicial

   configurar();                        //ve a menu configurar
   enable_interrupts(GLOBAL);               //activadas interrupciones

    for( ; ; ){         //bucle...
      if(input(PIN_A5)==0){            //Si se pulsa Conf....
         while(!input(PIN_A5)){}         //elimina rebotes
         beep();
         configurar();
         }                        //ve a menu configurar
      }             //...infinito
}

///FUNCION CONFIGURAR
void configurar(void){
   disable_interrupts(GLOBAL);               //desactivadas interrupciones

   do{
      switch(menu){
         case 0:   printf("fConfigurar
horas?" );      //horas
               if(!input(PIN_A5)){
                  while(!input(PIN_A5)){}
                  beep();
                  horas();
                  menu=1;                        //apunta siguiente opcion
                  flag=1;                        //para el retorno funcion ver sig
                  }
               break;
         case 1: printf("fConfigurar
minutos?" );      //minutos
               if(!input(PIN_A5)){
                  while(!input(PIN_A5)){}
                  beep();
                  minutos();
                  menu=2;                        //apunta siguiente opcion
                  flag=1;                        //para el retorno funcion ver sig
                  }
               break;
         case 2: printf("fConfigurar
dia?" );         //dias
               if(!input(PIN_A5)){
                  while(!input(PIN_A5)){}
                  beep();
                  dia();
                  menu=3;                        //apunta siguiente opcion
                  flag=1;                        //para el retorno funcion ver sig
                  }
               break;
         case 3: printf("fConfigurar
mes?" );         //mes
               if(!input(PIN_A5)){
                  while(!input(PIN_A5)){}
                  beep();
                  mes();
                  menu=4;                        //apunta siguiente opcion
                  flag=1;                        //para el retorno funcion ver sig
                  }
               break;
         case 4: printf("fConfigurar
año?" );         //años
               if(!input(PIN_A5)){
                  while(!input(PIN_A5)){}
                  beep();
                  anio();
                  menu=5;                        //apunta siguiente opcion
                  flag=1;                        //para el retorno funcion ver sig
                  }
               break;
         case 5: printf("fSalir
configurar?" );      //salir configuracion
               if(!input(PIN_A5)){
                  while(!input(PIN_A5)){}         //elimina rebotes
                  menu=6;
                  flag=1;
                  beep();
                  }
         }

      do{                        //controla pulsador...
         if(!input(PIN_A3)){
            while(!input(PIN_A3)){}
            menu++;
            flag++;
            if(menu>5)
               menu=0;
            }
         if(!input(PIN_A5))         //controla pulsador...
            flag++;               //..."Conf/Ok"
         }while(!flag);            //.."Up"

      flag=0;
      }while(menu<6);

      menu=0;                                 //actualiza indices menu
      rtc_set_datetime(day,mth,year,dow,hour,min);   //nueva hora,minuto,...
      enable_interrupts(GLOBAL);                  //activadas interrupciones
      set_timer0(0);                           //carga TMR0
}
///FUNCION CONFIGURA HORAS
void horas(void){
   printf("fConf.Horas:
Hora: %2X:%2X:%2X",hour,min,sec);   //muestra por v.terminal
   do{
      if(!input(PIN_A3)){                  //¿se ha pulsado up?
         while(!input(PIN_A3)){}            //elimina rebotes
         hour++;                        //SI -> incremento hour
         switch(hour){                  //limites...
            case 0x0A:   hour=0x10;break;
            case 0x1A:   hour=0x20;break;
            case 0x24:   hour=0x00;
            }                        //...hour
         printf("
Hora: %2X:%2X:%2X",hour,min,sec);   //muestra por v.terminal
         }
      }while(input(PIN_A5));
   while(!input(PIN_A5)){}         //elimina rebotes
}
///FUNCION CONFIGURA MINUTOS
void minutos(void){
   printf("fConf.Minutos:
Hora: %2X:%2X:%2X",hour,min,sec);   //muestra por v.terminal
   do{
      if(!input(PIN_A3)){            //¿se ha pulsado up?
      while(!input(PIN_A3)){}         //elimina rebotes
      min++;                     //SI -> incremento min
      switch(min){               //limites...
         case 0x0A:   min=0x10;break;
         case 0x1A:   min=0x20;break;
         case 0x2A:   min=0x30;break;
         case 0x3A:   min=0x40;break;
         case 0x4A:   min=0x50;break;
         case 0x5A:   min=0x00;
         }                     //...min
      printf("
Hora: %2X:%2X:%2X",hour,min,sec);   //muestra por v.terminal
      }
      }while(input(PIN_A5));
   while(!input(PIN_A5)){}         //elimina rebotes
}
///FUNCION CONFIGURA DIAS
void dia(void){
   printf("fConf.Dias:
Fecha: %2X/%2X/%2X",day,mth,year);   //muestra por v.terminal
   do{
      if(!input(PIN_A3)){               //¿se ha pulsado up?
         while(!input(PIN_A3)){}         //elimina rebotes
         day++;                     //SI -> incremento day
         switch(day){               //limites...
            case 0x0A:   day=0x10;break;
            case 0x1A:   day=0x20;break;
            case 0x2A:   day=0x30;break;
            case 0x32:   day=0x01;
            }                     //...day
         printf("fConf.Dias:
Fecha: %2X/%2X/%2X",day,mth,year);   //muestra por v.terminal
         }
      }while(input(PIN_A5));
   while(!input(PIN_A5)){}         //elimina rebotes
}
///FUNCION CONFIGURA MES
void mes(void){
   printf("fConf.Mes:
Fecha: %2X/%2X/%2X",day,mth,year);   //muestra por v.terminal
   do{
      if(!input(PIN_A3)){               //¿se ha pulsado up?
         while(!input(PIN_A3)){}         //elimina rebotes
         mth++;                     //SI -> incremento mth
         switch(mth){               //limites...
            case 0x0A:   mth=0x10;break;
            case 0x13:   mth=0x01;
            }                     //...mth
      printf("fConf.Mes:
Fecha: %2X/%2X/%2X",day,mth,year);   //muestra por v.terminal
         }
      }while(input(PIN_A5));
   while(!input(PIN_A5)){}         //elimina rebotes
}
///FUNCION CONFIGURA AÑOS
void anio(void){
   printf("fConf.Año:
Fecha: %2X/%2X/%2X",day,mth,year);   //muestra por v.terminal
   do{
      if(!input(PIN_A3)){               //¿se ha pulsado up?
         while(!input(PIN_A3)){}         //elimina rebotes
         year++;                     //SI -> incremento mth
         switch(year){               //limites...
            case 0x0A:   year=0x10;break;
            case 0x1A:   year=0x20;break;
            case 0x2A:   year=0x30;break;
            case 0x3A:   year=0x40;break;
            case 0x4A:   year=0x50;break;
            case 0x5A:   year=0x60;break;
            case 0x6A:   year=0x70;break;
            case 0x7A:   year=0x80;break;
            case 0x8A:   year=0x90;break;
            case 0x9A:   year=0x00;
            }                     //...year
      printf("fConf.Año:
Fecha: %2X/%2X/%2X",day,mth,year);   //muestra por v.terminal
         }
      }while(input(PIN_A5));
   while(!input(PIN_A5)){}         //elimina rebotes
}
///FUNCION BEEP
void beep(void){
   output_high(PIN_B3);   //activa zumbador
   delay_ms(50);
   output_low(PIN_B3);      //desactiva zumbador
}

Decir que los comandos
, f y demas no me funcionan en la simulacion, no se si es un bug de PROTEUS o algo que se me esta pasando por alto y no me doy cuenta......pero bueno lo importante es el programa en si!jeje Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 16 de Septiembre de 2005, 08:00:00

Desde esta direccion os podeis descargar los archivos necesarios del ejemplo anterior: RS232 & DS1302

Suerte!!! :wink:

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 18 de Septiembre de 2005, 04:50:00

Mirando por el subforo de simuladores....encontre varios post con link"s a paginas donde se podian descargar models y librerias para el simulador PROTEUS, voy a dejar aqui los link"s ya que algunos de esos modelos lo usaremos nosotros:
http://uk.geocities.com/vsmlibs/
Aqui:
http://www.callbus.ru/

Y bueno si encuentro mas...los ire recopilando aqui Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 18 de Septiembre de 2005, 04:56:00

Y el ejemplito de hoy es seguir trabjando con el puerto serie RS232 peor esta vez introduciremos un periferico externo nuevo, el teclado, en este caso vamos a usar un teclado 3x4 donde cada tecla pulsada ira apareciendo en el v.terminal, aqui el programita:

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"05
//                   17/Septiembre/05
//
//   Programa:   RS232 y teclado 3x4
//   Version:   0.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.227
//   Entorno IDE: MPLAB IDE v7.21      Simulador:    Proteus 6.7sp3
//
//   Notas: Se muestra por virtual terminal(PC) la tecla pulsada conectado un
//       keypad 4x3 al pic. Tener en cuenta que hay que poner la directiva
//       NOLVP para que el pin B4 sea de salida.
//
//   Conexiones:      B1 -> Fila A keypad
//               B2 -> Fila B keypad
//               B3 -> Fila C keypad
//               B4 -> Fila D keypad
//               B5 -> Columna 1 keypad
//               B6 -> Columna 2 keypad
//               B7 -> Columna 3 keypad
//               A0 -> Rx
//               A1 -> Tx
//////////////////////////////////////////////////////////////////////////////////
#include <16f648a.h>            //pic a utilizar
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP,NOBROWNOUT      //ordenes para el programador
#use delay (clock=4000000)         //Fosc=4Mhz
#use rs232(baud=9600, xmit=PIN_A0, rcv=PIN_A1)   //manejo del RS232
#define use_portb_kbd TRUE         //definir portb keypad
#include<kbd.c>                  //libreria manejo keypad

///PROGRAMA
void main(void)
{
   char c;               //variable almacenamos tecla

   kbd_init();            //inicializa teclado

   port_b_pullups(TRUE);   //necesario para teclado

   puts("Manejo del teclado 3x4 VsZeNeR"05" );   //inicio...
   puts("====================" );
   puts("
Pulse una tecla: " );                  //...presentacion

   for( ; ; )   {   //bucle...
      do{               //hacer hasta...
         c=kbd_getc();   //recogemos tecla pulsada
      }while(c=="");    //...que no se pulse tecla

      printf("" );      //retrocede una posicion(borra ultima tecla)
      printf("%c",c);      //mensaje por v.terminal
      }      //...infinito
}

Decir que para el manejo del teclado he utilizado la libreria del CCS llamada KBD.C que es compatible con teclados 3x4, aqui dejo el link al sitio donde CCS tiene puesta sus librerias y sus data sheet patron de la realizacion de las mismas:
http://www.ccsinfo.com/data.shtml
Ya sabemos manejar un periferico mas! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 18 de Septiembre de 2005, 05:00:00

Desde este enlace os podeis descargar los ficheros necesarios para el programa anterior: RS232 & KEYPAD 3X4

Suerte!!! :wink:

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 20 de Septiembre de 2005, 10:57:00

Pues siguiendo la politica y filosofia de un profe mi de la universidad, el cual decia: "no pierdas el tiempo en hacer lo fabricado...." he mirado por internet y por el foro una libreria para la lcd y para el teclado, y he hallado una!!!jeje la libreria son de la empresa Microsystems Engineering...aqui dejo el enlace para que os bajeis los ejemplos donde estan la slibrerias kbd2.c y lcd2.c:
http://www.msebilbao.com/tienda/downloads_ejemplos.php
Decir que la libreria lcd2.c es de 8 bits y la del CCS es de 4 bits.....pero bueno ya buscaremos mas o me pondre yo mano a la obra haber que sale!!!jeje....decir quee stas librerias las vamos a usar y tb modificar.....aqui dejo el enlace para que os bajeis las librerias mencionadas y la modificacion del kbd2.c a kbd3x4.c...la modificacion la he hecho porque la kbd2.c es para teclado 4x4 y de momento nosotros vamos a usar teclados 3x4.....
http://miarroba.com/foros/ver.php?foroid=348538&temaid=3622968
Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 20 de Septiembre de 2005, 11:02:00

Y aqui esta un ejemplito mas!!!esta vez el ejemplo consiste en un teclado y una lcd conectados....decir que para este ejemplo hacen falta las librerias lcd2.c y kbd3x4.c que las podreis encontrar en el post anterior....lcd2.c maneja la lcd pero las lineas de control estan en el porta y las de datos en el b, tambien decir que usamos 8bits de datos, y la kbd3x4.c es para manejar teclados 3x4 y esta conectado al portb conjuntamente al lcd por lo tanto debemos hacer una seleccion dinamica para manejar conjuntamente el lcd y el teclado(de eso se encargan la slibrerias....jeje), bueno el programa consiste en mostrar por lcd la tecla pulsada en el teclado:

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"05
//                   17/Septiembre/05
//
//   Programa:   LCD y teclado 3x4
//   Version:   0.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.227
//   Entorno IDE: MPLAB IDE v7.21      Simulador:    Proteus 6.7sp3
//
//   Notas: Se muestra por lcd la tecla pulsada conectado un
//       keypad 3x4 al pic. Tener en cuenta que hay que poner la directiva
//       NOLVP para que el pin B4 sea de salida.
//
//   Conexiones:      B0 -> D0 LCD/Columna 1 keypad
//               B1 -> D1 LCD/Columna 2 keypad
//               B2 -> D2 LCD/Columna 3 keypad
//               B3 -> D3 LCD
//               B4 -> D4 LCD/Fila A keypad
//               B5 -> D5 LCD/Fila B keypad
//               B6 -> D6 LCD/Fila C keypad
//               B7 -> D7 LCD/Fila D keypad
//               A0 -> RS LCD
//               A1 -> RW LCD
//               A2 -> E LCD
//////////////////////////////////////////////////////////////////////////////////
#include <16f648a.h>            //pic a utilizar
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP,NOBROWNOUT      //ordenes para el programador
#use delay (clock=4000000)         //Fosc=4Mhz
#include<kbd3x4.c>               //libreria manejo keypad
#include<lcd2.c>               //libreria manejo lcd 8bits
#use fast_io(A)
#use fast_io(B)

///PROGRAMA
void main(void)
{
   char c;         //variable donde se almacena tecla pulsada

   lcd_init();      //inicializa lcd

   lcd_putc(" VsZeNeR"05
Tecla pulsada:" );   //presentacion
   lcd_gotoxy(15,2);                        //donde se va a mostrar tecla

   for( ; ; ){   //bucle...
      do{               //espera hasta...
         c=kbd_getc();
         }while(c==0);   //...pulsar una tecla

      lcd_putc(c);      //muestra tecla pulsada en lcd
      lcd_putc("" );      //retrocede una posicion(escribe encima de la ultima tecla mostrada)
      }      //...infinito


}

Pues ya sabemos usar lcd y teclado!!!jeje hasta pronto! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 20 de Septiembre de 2005, 11:04:00

Desde este enlace os podeis descargar los ficheros del programa anterior: LCD & KEYPAD 3x4

Suerte!!! :wink:

Título: RE: Ejemplitos en C para 16F648A
Publicado por: martinezavg en 20 de Septiembre de 2005, 13:29:00

Hola vszener, Te Felicito por el trabajo que estás realizando al mostrar tus proyectos y conocimientos.

Rebotado

Siempre estoy pendiente de los consejos y simulaciones que colocas. Aunque por los momentos no puedo ocuparme de experimentar por motivos de trabajo, por lo menos con tú muy nutrida información y con los otros hilos de esta GRAN Comunidad me pongo al día.....

Gracias por tú aporte y de todos que participan en este magnifico FORO, ya que con sus problemas y soluciones enriquecen el conocimiento!!! Rebotado

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 22 de Septiembre de 2005, 07:59:00

Ke tal martinezavg!!!GRACIAS por el apoyo y por estar pendiente de mis programitas!!!jeje eso da animos para seguir poniendo mas!jeje pues cuando tengas un huequito de tu timepo ya sabes....a probar los programas y trastearlos para asi aprender!que eso es lo que se pretende con este post de ejemplos, tener una referencia de como se programa el pic y perifericos tanto externos como internos....asi que seguimos adelante como los de alicante!!!jeje Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 22 de Septiembre de 2005, 08:08:00

Buenas!!!el programa de hoy consiste en manejar un pokitin mas el lcd y el keypad de forma dinamica...esta vez vamos a usar un keypad de 4x4 pero nos va hacer falta modificar en algo la libreria que os puse en algun mensaje anterior ya que necesitamos adaptarla al teclado que aparece en PROTEUS, decir que vamos a usar un teclado el cual no viene instalado en PROTEUS sino que os lo debeis bajar de los enlaces que os puse en un anterior post...ahi si vienen ya que yo lo he sacado de esos enlaces(es necesario ya que sino lo haceis PROTEUS dara un error de librerias....), bien el programita consiste en hacer una llave electronica, es decir nosotros introducimos un password/clave la cual se almacenara en una variable y despues tendremos un menu donde podremos cambiar la clave o comprobarla con una introducida por teclado....decir que la programacion se ha realizado caracter por caracter al introducir y comprobar la clave por lo que el codigo es mas extenso, peor creo que asi es mas ilustrativo.....ya en la revision de este ejemplito intentaremos modificarlo para hacerlo mas optimo!aqui el programita ke me enrollo jeje!!!:

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"05
//                   21/Septiembre/05
//
//   Programa:   Clave
//   Version:   0.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.227
//   Entorno IDE: MPLAB IDE v7.21      Simulador:    Proteus 6.7sp3
//
//   Notas: Se pide por lcd una clave a introducir, despues hay un menu de opciones:
//            0->Introducir password
//            1->Cambiar clave
//       Los caracteres * o # son fin de instruccion/accion, si estamos en cambiar clave
//       o en comprobar clave, cada vez que se pulsen dichos caracteres se terminara
//       la accion. Para introducir clave, tecleamos caracteres hasta pulsar * o # y la clave
//       ya estara almacenada. Para comprobar clave, tecleamos caracteres hasta pulsar * o #
//       y se comprobara la clave introducida con la nuestra almacenada.
//       Tener en cuenta que hay que poner la directiva NOLVP para que el pin B4 sea de salida.
//       Se utiliza variables globales:
//            ·c-> almacena letra pulsada del keypad
//            ·limit -> longitud de clave
//            ·i -> contador
//            ·var -> 1->Clave incorrecta
//            ·clave[16] -> almacena clave(maximo 16 caracteres)
//
//   Conexiones:      B0 -> D0 LCD/Columna 1 keypad
//               B1 -> D1 LCD/Columna 2 keypad
//               B2 -> D2 LCD/Columna 3 keypad
//               B3 -> D3 LCD/Columna 4 keypad
//               B4 -> D4 LCD/Fila A keypad
//               B5 -> D5 LCD/Fila B keypad
//               B6 -> D6 LCD/Fila C keypad
//               B7 -> D7 LCD/Fila D keypad
//               A0 -> RS LCD
//               A1 -> RW LCD
//               A2 -> E LCD
//               A3 -> Led red
//               A5 -> Led green
//////////////////////////////////////////////////////////////////////////////////
#include <16f648a.h>            //pic a utilizar
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP,NOBROWNOUT,NOMCLR      //ordenes para el programador
#use delay (clock=4000000)         //Fosc=4Mhz
#include<kbd4x4ABCD_PROTEUS.c>               //libreria manejo keypad
#include<lcd2.c>               //libreria manejo lcd 8bits
#use fixed_io(a_outputs=PIN_A3,PIN_A5)
#use fast_io(B)

///DEFINICION DE FUNCIONES
void nueva_clave(void);         //funcion que cambia clave
void comprueba_clave(void);      //funcion que comprueba clave

///VARIABLES GLOBALES
char clave[16],c,limit;
signed char i;
boolean var=0;

///PROGRAMA
void main(void)
{
   lcd_init();            //inicializa lcd

   delay_ms(50);         //presentacion...
   output_low(PIN_A5);
   delay_ms(50);
   output_high(PIN_A3);
   delay_ms(50);
   output_low(PIN_A3);
   lcd_putc(" VsZeNeR"05
Clave" );
   delay_ms(1000);         //...inicial

   nueva_clave();         //introducimos clave

   for( ; ; ){   //bucle...
      lcd_putc("f0->Password
1->Cambia Clave" );
      do{               //espera hasta...
         c=kbd_getc();
         }while(c==0);   //...pulsar una tecla

      if(c=="1")         //ve a introducir nueva clave
         nueva_clave();
      if(c=="0")         //ve a comprobar clave
         comprueba_clave();
      }      //...infinito
}
///FUNCION CAMBIAR CLAVE
void nueva_clave(void){
   lcd_putc("fNueva clave:
" );   //presentacion
   for(i=0;i<16;i++){
      do{               //espera hasta...
         c=kbd_getc();
         }while(c==0);   //...pulsar una tecla

      if(c=="*" || c=="#"){      //si se pulsa * o # se sale de la funcion
         if(i==0){            //no se sale...
            lcd_putc("
Escribe una!!!" );
            delay_ms(500);
            lcd_putc("
" );
            lcd_gotoxy(1,2);
            i=-1;
            continue;         //...hasta poner una clave valida
            }
         break;               //salir de funcion nueva_clave
         }
      lcd_putc("*" );
      limit=i+1;               //longitud de la clave
      clave[ i ]=c;               //almacena clave(maximo 16 caracteres)
      }
}
///FUNCION COMPROBAR CLAVE
void comprueba_clave(void){
   lcd_putc("fIntroduce clave:
" );   //presentacion

   for(i=0; ;i++){   //bucle no sale...
      do{               //espera hasta...
         c=kbd_getc();
         }while(c==0);   //...pulsar una tecla

      lcd_putc("*" );

      if(c=="#" || c=="*"){      //si se pulsa * o # se sale de la funcion
         if(i==0){            //no se sale...
            lcd_putc("
Escribe una!!!" );
            delay_ms(500);
            lcd_putc("
" );
            lcd_gotoxy(1,2);
            i=-1;
            continue;
            }         //...poner una clave valida
         if(i!=limit)   //para ser correcto debe tener tb longitud correcta
            var=1;
         break;         //salimos si se pulsa tecla * o #
         }

      if(c!=clave[ i ])      //comprobacion de caracteres correctos
         var=1;         //No es correcto->clave incorrecta
      }         //...hasta pulsar * o #

   if(var>0){      //Clave incorrecta
      lcd_putc("fClave
Incorrecta!" );
      output_high(PIN_A3);
      delay_ms(500);
      output_low(PIN_A3);
      }
   else{         //Clave correcta
      lcd_putc("fClave
Correcta!" );
      output_high(PIN_A5);
      delay_ms(500);
      output_low(PIN_A5);
      }
   var=0;         //reset var
}

Ya tenemos neustro sistema de claves!!!! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 22 de Septiembre de 2005, 08:28:00

Desde este enlace os podeis descargar lo necesario para el programa anterior: Claves

Suerte!!! :wink:

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 24 de Septiembre de 2005, 06:58:00

Aqui interaccionaremos entre el PC -> PIC (Este es otro post que no estaba...)

Código: C

////////////////////////////////////////////////////////////////////////////////////
//                                                      VsZeNeR'05              
//                                                24/Septiembre/05
//                                              vszener@gmail.com
//      Programa:       RS232 Y PIC
//      Version:        0.0
//
//      Dispositivo: PIC 16F648A                        Compilador:      CCS vs3.227
//      Entorno IDE: MPLAB IDE v7.21            Simulador:       Proteus 6.7sp3
//
//      Notas: Se interacciona el PC con el PIC mediante RS232, se pide por v.terminal 
//                 un numero comprendido entre 1 al 4, segun numero marcado por v.terminal
//                 se encendera un led 0,5s. Tener en cuenta que hay que poner la directiva 
//                 NOLVP para que el pin B4 sea de salida. 
//
//      Conexiones:             A0 -> led azul                
//                                      A1 -> led verde                 
//                                      A2 -> led rojo          
//                                      A4 -> led amarillo                
//                                      B2 -> TxD
//                                      B1 -> RxD                 
//////////////////////////////////////////////////////////////////////////////////
#include <16f648a.h>                            //pic a utilizar                        
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP,NOBROWNOUT                          //ordenes para el programador 
#use delay (clock=4000000)                      //Fosc=4Mhz
#use fixed_io(a_outputs=PIN_A0,PIN_A1,PIN_A2,PIN_A3)
#use rs232(baud=9600, xmit=PIN_B1, rcv=PIN_B2, FORCE_SW)        //manejo del RS232
 
///PROGRAMA
void main(void)
{       
        puts("Interaccion PC->PIC          VsZeNeR'05");        //presentacion...
        puts("=================");
        puts("Seleccione tecla:");
        puts("¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨");
        puts("   1->Led on Azul");
        puts("   2->Led on Verde");
        puts("   3->Led on Rojo");
        puts("   4->Led on Amarillo");                                          //...inicial
        
        for(;;){        //bucle...
                switch(getc()){         //coge tecla
                        case '1':       output_high(PIN_A0);    //led on azul
                                                delay_ms(500);
                                                output_low(PIN_A0);
                                                break;
                        case '2':       output_high(PIN_A1);    //led on verde
                                                delay_ms(500);
                                                output_low(PIN_A1);
                                                break;
                        case '3':       output_high(PIN_A2);    //led on rojo
                                                delay_ms(500);
                                                output_low(PIN_A2);
                                                break;
                        case '4':       output_high(PIN_A3);    //led on amarillo
                                                delay_ms(500);
                                                output_low(PIN_A3);
                        }
                }               //...infinito
}

Suerte!!! :wink:

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 27 de Septiembre de 2005, 10:26:00

Buenas!!!jeje despues de las minis-vacaciones que me he dado(isla magica....por cierto muy bonito las actuaciones en la calle y los teatros, hacer un examen pufff jeje aunque aprovado seguro!jeje...)he vuelto con mas programas!jeje, bien el siguiente programa vamos a trabajar con un periferico interno del PIC, en este caso con la interrupcion externa de la patita RB0, por dicha patita se recibira una señal cuadrada de 1Hz,eso significa que cada 1s habra un nivel logico alto(se puede programar para que atendamos a la interrupcion en nivel logico bajo) el cual producira una interrupcion, en dicha llamada de la interrupcion se mostrara por el porta en codigo BCD numeros del 0 al 9 y su correspondiente conversion a binario. Aqui el codigo:

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"05
//                   27/Septiembre/05
//
//   Programa:   Contador BCD y binario del 0 al 9
//   Version:   0.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.227
//   Entorno IDE: MPLAB IDE v7.20      Simulador:    Proteus 6.7sp3
//
//   Notas: Contador 0 al 9 usando interrupcion externa por el pin B0. Tener
//       en cuenta que hay que poner la directiva NOLVP para que el pin B4 sea de
//       salida.
//
//   Conexiones:      A0 -> A 74247/Led D1
//               A1 -> B 74247/Led D2
//               A2 -> C 74247/Led D3
//               A3 -> D 74247/Led D4
//               B0 -> Interrupcion externa
//   BCD:
//            d c b a NUM
//            0 0 0 0 0
//            0 0 0 1 1
//            0 0 1 0 2
//            0 0 1 1 3
//            0 1 0 0 4
//            0 1 0 1 5
//            0 1 1 0 6
//            0 1 1 1 7
//            1 0 0 0 8
//            1 0 0 1 9
//////////////////////////////////////////////////////////////////////////////////

#include <16f648a.h>            //pic a utilizar
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP      //ordenes para el programador
#use delay (clock=4000000)         //Fosc=4Mhz
#use standard_io(b)
#use fixed_io(a_outputs=PIN_A0,PIN_A1,PIN_A2,PIN_A3)

///VARIABLES GLOBALES
char i=0;   //contador para tabla BCD
char tabBCD[10]={0b0000,0b0001,0b0010,0b0011,0b0100,0b0101,0b0110,0b0111,0b1000,0b1001};//BCD 0-9

///LLAMADA FUNCION INTERRUPCION
#INT_EXT
void IntRB0()
{
   i++;               //incremento contador indice tabBCD
   if(i>9)               //¿se ha mostrado digito 9?
      i=0;            //SI -> restaura valor indice(para mostrar digito 0)
   output_a(tabBCD[ i ]);    //muestra por porta digito 7 segmentos
}

///PROGRAMA
void main(void)
{
   enable_interrupts(int_ext);      //activar interrupcion externa
   ext_int_edge(L_TO_H);         //configuracion:interrupcion cuando señal esta en alta
   enable_interrupts(GLOBAL);      //todas las interrupciones desactivadas

   for( ; ; ){}   //bucle infinito esperando interrupcion
}

Bien, decir que en la simulacion en PROTEUS para ahorra lineas se ha usado un decodificador BCD-7seg, concretamente el 74247 de TI, aqui el data sheet del dispositivo:
http://pdf.alldatasheet.com/datasheet-pdf/view/27400/TI/SN74247N.html
Hasta la proxima! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 27 de Septiembre de 2005, 10:28:00

Desde este enlace os podeis descargar los archivos necesarios para el programa anterior: INT RB0

Suerte!!! :wink:

Título: RE: Ejemplitos en C para 16F648A
Publicado por: monopic en 27 de Septiembre de 2005, 23:25:00

oye hasta hoy vi todo y esta de pelos se nota que sabes bastante de esta cosa, quisiera preguntarte si existe la posibilidad de convertir una lcd de 2x16 lineas en algo parecido a una lcd grafica tengo esa idea metida en la cabeza hace tiempo pero no he podido hacer nada,,, seria bueno crearla sin importar que la grafica se entrecortara por las diviciones que hay entre cada cuadrado de la lcd .. espero que me entiendas y escribe una respuesta ... gracias
Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: RaDoN en 28 de Septiembre de 2005, 02:16:00

No se puede poner puntos en donde se quiera (dentro de las matrices 7*5 que forman los caracteres), lo que si puedes hacer es crear unos carácteres personalizados y jugar con esto para conseguir algún tipo de gráfico, pero no esperes gran cosa ... Enfurruñado

Título: RE: Ejemplitos en C para 16F648A
Publicado por: Nocturno en 28 de Septiembre de 2005, 03:15:00

Oye vszener, ¿no has pensado en colgar todos tus ejemplitos en una web?, creo que estaría muy bien poder acceder a ellos a través de un índice.

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 28 de Septiembre de 2005, 05:27:00

Buenas!!!haber monopic con respecto al tema de tranformar una lcd 2x16 en una glcd pues.....se podria hacer pero como dice el amigo radon el resultado final seria un churro, date cuenta que la transformacion se haria por software, es decir creariamos una libreria donde nosotros debemos crear los caracteres, puntos lines, etc.....y el poco o mucho trabajo que supone eso no satisfasceria el resultado final(por lo menos a priori es lo que pienso, alomejor se pone uno a trabajar en la idea y se sorprende!jeje), pero para la transformacion ten en cuenta que se deberian crear como ya dicho puntos, lineas y demas caracteres que son necesarias para los dibujos......GRACIAS por ver mis programas!jeje.

Nocturno66 la verdad que me lo he planteado el crear una web, pero eso de tener que buscar un dominio gratuito ahora(que por cierto lo encontre .tk), tener que cumplir un minimo de visitas a mi web(hay programas que hacen eso por ti....) jeje yo solo me estoy dando las respuestas peroooo no me llama la atencion, de momento, en crear y diseñar una web.....lo que pense y lo he dejado algo parado(pero pienso retomarlo!)es realizar una aplicacion en vb tipo ayuda, hace tiempo me pasaron y creo recordar que todavia la tengo, un manual de programacion en c de esa forma y la verda que lo vi practico, haber si retomo ese proyecto y lo cuelgo....Pero la verdad que tienes razon, ya creo que los ejemplitos llegan a los 40!!!y lo ideal es mediante un indice aceder a ellos.....GRACIAS por la sugerencia! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: Nocturno en 28 de Septiembre de 2005, 05:36:00

Quizás sea suficiente de momento con poner los nombres de todos los ejemplitos en el mensaje nº 1 del post, y editarlo cada vez que añadas uno.
Ya se que es pedirte aún más, después de todo lo que nos ofreces a diario, pero quizás dotaría de mayor orden y riqueza a este hilo, que en vez de llamarse "Ejemplitos" debería llamarse "Ejemplazos".

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 28 de Septiembre de 2005, 05:46:00

El orden es importante...buena idea, lo ideal seria poner el nombre del programa, una brebe descripcion y el enlace para llegar al mismo,no? lo que pienso que el enlace para acceder al mismo no llegaria al programa en si sino a la pagina donde esta escrito, hay alguna forma de llegar al programa en si? pero bueno si no la hay de todas formas ordenados van a estar! espero tu respuesta para ponerme manos a la obra!GRACIAS de nuevo por la sugerencia! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: xootraoox en 28 de Septiembre de 2005, 05:48:00

mmmm... escuche host gratis????

bueno si quieres uno me avisas..... lo unico malo es que no tiene activada la funcion send mail, lo que trae un pooco de inconvenientes... descrivo un poco las caracteristicas

100MB
3GB transferesncia/mes
PHP, Perl/CGI-BIN
MySQL database 5mb
FTP access
Web-based file manager

bueno todo eso entre otras cosas mas... en realidad es el mejor que tengo

apsss se me olvidava algo

colocan una publicidad la cual no es gran problema eliminarla con un par de lineas de codigo

si te interesa hablamos por privado para que sea mas reservada la cosa asi durara mas la cosa Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: Nocturno en 28 de Septiembre de 2005, 05:53:00

Sí, claro, no podrías poner línks a los mensajes que tienen los programas. Aunque quizás con decir en qué pagina están sería suficiente.

Pero es sólo una sugerencia, no lo veas como una petición, eh.

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 28 de Septiembre de 2005, 06:04:00

Jeje...MUCHISIMAS GRACIAS!!! xootraoox por el dominio!pero no me hagas caer en la tentacion de crear una web!!!jeje repito, muchas gracias!pero de momento no quiero diseñar ni mantener una web....jeje

Nocturno66 la idea del orden y del indice es genial! hombre, mas que nada por si alguien le da por buscar un ejemplito de como se programa la interrupcion externa INT/RB0 no tenga que tragarse 39 ejemplos anteriores de encender/apagar un led, manejo lcd,.........termina por cerrar el post y preguntar si alguien tiene ejemplos de programacion sobre la interrupcion externa......GRACIAS por la sugerencia!

Y bueno me voy a poner mano a la obra...

Título: RE: Ejemplitos en C para 16F648A
Publicado por: xootraoox en 28 de Septiembre de 2005, 06:09:00

mmmm....

frimo mi compromiso de que yo me dedicare a recopilar los ejemplillos y colocarlos en una web....

apsss eso si cuando tenga un poquito de tiempo... que por esta semana es lo que mas me falta loco

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 28 de Septiembre de 2005, 09:07:00

Jeje bueno la primera version del indice de ejemplitos del post esta realizada!!!jeje haber si la puedo mejorar, pero vamos por lo menos ya estan ordenados como bien sugirio el amigo nocturno66, xootraoox cuando puedas!jeje tampoco corre prisa jeje GRACIAS! y ya hay algo nuevo....un INDICE!!!jeje Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: RaDoN en 28 de Septiembre de 2005, 09:14:00

joer, que curro vszener !! fantastico tio

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vitervi en 28 de Septiembre de 2005, 10:09:00

Hola a todos,

Una pregunta muy tonta, ya tengo el CCs como te dije, ahora mi pregunta es:

El proteus demo que hay por alli, es decir en la web de proteus ya me sirv, es que tengo un proteus algo viejo.

Gracias

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 28 de Septiembre de 2005, 10:26:00

Creo que el amigo Lordlafebre comento en algun post que la demo de PROTEUS solo sirve para simular los ejemplos que trae consigo, por lo tanto tendras que buscarte como minimo la version PROTEUS 6.7 sp3.....si preguntas donde conseguirla, decirte que hay programas P2P(tipo emule, kazaa, etc....) donde la podras encontrar con el nombre : PROTEUS 6.7 sp3 y asi descargartela....Los ejemplos estan realizados con la version que te indique antes. Suerte!!! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: LordLafebre en 28 de Septiembre de 2005, 10:56:00

Hola:

No se mucho de como son los demos pero corrijanme si estoy mal: hay una version LITE y otras versiones demo...? por ejemplo de esas que duran cierto tiempo pero que permiten su total funcionamiento....?

La version demo que vi fuen en la PC de un amigo y es como tu comentas solo deja simular los ejemplos que viene en la demo... para los diseños que haces tu no aparece la barra para simular...!

Título: RE: Ejemplitos en C para 16F648A
Publicado por: monopic en 28 de Septiembre de 2005, 22:08:00

Gracias Vzener por al menos decirme que se podria hacer no me importa cual sea el resultado final pero me gustaria por lo menos pintar una especie de coche o algo asi o alguna figura en movimiento ,,, pero dime por donde empezaria,,,quisiera hacerlo en el menor tiempo posible.. gracias por todo...responde porfa ... saludos Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 29 de Septiembre de 2005, 05:36:00

Ke tal!!! monopic para empezar deberas definir nuevos caracteres y guardarlos en la memoria de a lcd para un uso mas comodo, tendras definir rayas verticales y horizontales(aunque para la vertical quizas te valga la I mayuscula) pero para dibujar un coche sera tipo cuadrado jeje vamos una caja de cerillos!a no ser que se te de mejor el dibujo que ami...algo asi:

Codigo:

            ------                   1ºFILA
      --- |       |----
     |________________|             2ºFILA

Tendras que hacer los caracteres idoneos para la realizacion del coche....despues su movmiento es facil, simplemente desplaza una posicion todos los caracteres definidos, ahi un ejemplito en este ost de desplazamiento de palabras! Suerte!!!

Olotill GRACIAS!!!jeje por seguir mis ejemplitos!me alegro que estes ya por las lcd"s eso significa que ya has pasado y aprendido a encender/apagar led"s jeje con respecto a tu pregunta del %c es decirle a la funcion printf como voy a mostrar el dato, es decir:

Codigo:

              %c --> El dato a mostrar es tipo caracter (letras, ASCII,...)
              %d --> El dato a mostrar es tipo entero (numeros enteros)
              %f  --> El dato a mostrar es tipo float (numeros decimales)
              %x --> El dato a mostrar es tipo hexadecimal
Si se le pone una l delante:
              %ld --> El dato a mostrar es tipo double

ok???Si tienes alguna duda preguntamela! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 29 de Septiembre de 2005, 13:02:00

Buenas!!!!el ejemplo de hoy se trata de manejar el periferico interno ccp(modulos de captura: comparacion y modulacion de anchuras de pulsos), el cual puede actuar de las siguientes maneras: Como captura, como comparacion o como modulacion de anchura de pulsos(PWM). En este ejemplo lo vamos a configurar como comparacion. Es decir por la patita RB3/ccp1 conectaremos una señal de pulsos la cual generara una interrupcion cada flanco de subida(un 1 logico por dicho pin) pero si pulsamos el boton conectado a la patita RB0/int generara una interrupcion externa(ya programada e el ejemplo anterior...)la cual cambiara el modo de comparacion, pasando este a capturar y generar una interrupcion por el pin RB3/ccp1 cada flanco descendente es decir de bajada(un 0 logico por dicho pin)...bueno y la interrupcion lo que hace es simplemente aumentar indice de contador para mostrar numeros del 0 al 9 en bcd....lo importante es saber programar los perifericos! aqui el programa:

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"05
//                   29/Septiembre/05
//
//   Programa:   Uso del CCP1 como comparador ascendente/descendente
//   Version:   0.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.227
//   Entorno IDE: MPLAB IDE v7.20      Simulador:    Proteus 6.7sp3
//
//   Notas: Contador 0 al 9 usando interrupcion ccp1 por el pin B3/ccp1. Si no pulsamos
//       el boton, la cuenta del contador sera cada flanco ascendente que entre por
//       la patita RB3/ccp1, en cambio si pulsamos el boton, la cuenta del contador sera
//       cada flanco descendente que reciba el pin RB3/ccp1. Tener en cuenta que hay que
//       poner la directiva NOLVP para que el pin B4 sea de salida. Aparte se a programado
//       mediante la instruccion INTRC el oscilador interno de 4MHz asi tendremos las
//       patitas RA7 Y RA6 libres.
//
//   Conexiones:      A0 -> A
//               A1 -> B
//               A2 -> C
//               A3 -> D
//               B0 -> Interrupcion externa
//               B3 -> Interrupcion ccp1
//   BCD:
//            d c b a NUM
//            0 0 0 0 0
//            0 0 0 1 1
//            0 0 1 0 2
//            0 0 1 1 3
//            0 1 0 0 4
//            0 1 0 1 5
//            0 1 1 0 6
//            0 1 1 1 7
//            1 0 0 0 8
//            1 0 0 1 9
//////////////////////////////////////////////////////////////////////////////////

#include <16f648a.h>            //pic a utilizar
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP      //ordenes para el programador
#fuses INTRC   //oscilador interno
#use delay (clock=4000000)         //Fosc=4Mhz
#use standard_io(b)
#use fixed_io(a_outputs=PIN_A0,PIN_A1,PIN_A2,PIN_A3)

///VARIABLES GLOBALES
char i=0;   //contador para tabla BCD
char tabBCD[10]={0b0000,0b0001,0b0010,0b0011,0b0100,0b0101,0b0110,0b0111,0b1000,0b1001};//BCD 0-9
boolean var=0;   //variable para captura en alto(var=0) o en bajo(var=1)

///LLAMADA FUNCION INTERRUPCION
#INT_CCP1
void ccp1()
{
   if(i>9)               //¿se ha mostrado digito 9?
      i=0;            //SI -> restaura valor indice(para mostrar digito 0)
   output_a(tabBCD[ i ]);    //muestra por porta digito 7 segmentos
   i++;               //incremento contador indice tabBCD
}

#INT_EXT
void IntRB0()
{
   var=!var;                     //complementa valor de modo
   if(!var)                     //¿var!=0?
      setup_ccp1(CCP_CAPTURE_RE); //SI -> ccp1 modo captura configurado flanco ascendente
   else
      setup_ccp1(CCP_CAPTURE_FE); //NO -> ccp1 modo captura configurado flanco descendente

}
///PROGRAMA
void main(void)
{
   setup_ccp1(CCP_CAPTURE_RE); //ccp1 modo captura configurado flanco ascendent
   enable_interrupts(int_ext);      //activar interrupcion externa
   ext_int_edge(H_TO_L);         //configuracion:interrupcion cuando señal esta en baja
enable_interrupts(INT_CCP1); //activar interrupcion en ccp1
   enable_interrupts(GLOBAL);      //todas las interrupciones desactivadas

   for( ; ; ){}   //bucle infinito esperando interrupcion
}

Fijarse bien en la simulacion en PROTEUS en la patita RB3/ccp1 cuando hay un cuadrado rojo o azul, el rojo indica entrada en alta y el azul en baja asi pulsando el boton sabreis como esta configurado el ccp1 en comparacion en flanco ascendente o descendente. Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 29 de Septiembre de 2005, 13:04:00

Desde este enlace os podeis descargar lo necesario para el programa anterior: Uso y manejo del ccp1 configurado como comparacion en flanco ascendente/descendente geenrando una interrupcion

Suerte!!! :wink:

Título: RE: Ejemplitos en C para 16F648A
Publicado por: monopic en 29 de Septiembre de 2005, 22:50:00

hola vzener estoy cursando 6 semestre de tec electronica tengo 19 años y de los pic se muchas cosas pero de las lcs graficas ni papa,, nunca he utilizado una lcd grafica he visto programas que convierten imagenes en una serie de datos para las glcd,, lo que quisiera es mostrar una especie de imagen muy sencilla en una lcd 2x16. el proyecto que tengo que realizar es controlar el nivel de liquido de un tanque y visualizar en una lcd diferentes valores pero por ejemplo me gustaria dibujar una especie de tanque y de forma que tambien se vaya llenando parecido a como se llena el dibujo de las baterias de celular dependiendo de cuanto les queda de carga.. pero en si mirar la lcd 2x16 como una graficadora de forma que yo pueda mostrar cualquier imagen sin importar que se corte por las diviciones que existen entre caracter y caracter...espero que me entiendas que es lo que quiero realizar y ver las posibilidades de hacerlo,, y cuando me refero al coche me imagino una especie de f1 moviendose de izquierda a derecha .. muchisimas gracias por dedicar de tu tiempo a mis inquietudes,, no se podriamos intercambiar mucha inf. nos estan enseñando en la universidad como hacer filtros digitales y control pid con pic... gracias....... Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 30 de Septiembre de 2005, 11:05:00

Ke tal monopic!!!haber como te dije anteriormente deberas crear los caracteres tu mismo y guardarlo en la zona de memoria de la lcd llamada CGRAM donde en el modelo HD44780(LM016L) puedes guardar hasta un maximo de 8, aqui te pongo un enlace donde hay un programa de como hacer esto en ensamblador y simulado en PROTEUS para la carga de una bateria.....la contraseña para abrirlo es D.P.E. mirate el codigo en asm y veras que estan declarados todos los caracteres nuevos para ver la bateria cargandose....aqui el enlace:
http://personales.ya.com/cepalacios/Proy_bateria_carga.htm

Suerte!!! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 30 de Septiembre de 2005, 12:22:00

Buenas!!! al final me he puesto manos a la obra y he realizado la animacion de carga de una bateria....jeje, para ello se diseña los caracteres de la bateria(al 0%, al 20%, al 40%, al 60%, al 80% y al 100%), decir que solamente he utilizado una posicion de memoria de la GCRAM(aunque cada animacion ocupa 8 posiciones), he ido machacando valores.......aqui el codigo:

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"05
//                   30/Septiembre/05
//
//   Programa:   Bateria
//   Version:   0.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.227
//   Entorno IDE: MPLAB IDE v7.21      Simulador:    Proteus 6.7sp3
//
//   Notas: Se muestra por pantalla de lcd(LM016L) la animacion de carga de
//       una bateria, para ello se han diseñado nuevos caracteres y almacenados
//       en la memoria GCRAM de la lcd, solo se ha usado una posicion de memoria
//       de dicha GCRAM. Tener en cuenta que hay que poner la directiva NOLVP para
//       que el pin B4 sea de salida.
//
//   Conexiones:      B0 -> E
//               B1 -> RS
//               B2 -> RW
//               B4 -> D4
//               B5 -> D5
//               B6 -> D6
//               B7 -> D7
//////////////////////////////////////////////////////////////////////////////////

#include <16f648a.h>            //pic a utilizar
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP      //ordenes para el programador
#use delay (clock=4000000)         //Fosc=4Mhz
#define use_portb_lcd TRUE
#include <lcd.c>               //libreria manejo de la lcd

///DECLARACION DE FUNCIONES
void recarga(void);      //funcion que crea el nuevo caracter

///DECLARACION DE VARIABLES GLOBALES
char cont=0;      //contador que apunta al nuevo caracter diseñado
   int8    bat0[]={0b00001110,0b00001010,0b00010001,0b00010001,0b00010001,0b000010001,0b00010001,0b00011111},
bat20[]={0b00001110,0b00001010,0b00010001,0b00010001,0b00010001,0b00010001,0b00011111,0b00011111},
bat40[]={0b00001110,0b00001010,0b00010001,0b00010001,0b00010001,0b00011111,0b00011111,0b00011111},
bat60[]={0b00001110,0b00001010,0b00010001,0b00010001,0b00011111,0b00011111,0b00011111,0b00011111},
bat80[]={0b00001110,0b00001010,0b00010001,0b00011111,0b00011111,0b00011111,0b00011111,0b00011111},
bat100[]={0b00001110,0b00001010,0b00011111,0b00011111,0b00011111,0b00011111,0b00011111,0b00011111};
///PROGRAMA
void main(void)
{
   lcd_init();       //inicializa lcd

   recarga();         //crea 1 animacion

   lcd_gotoxy(5,1);   //presentacion...
   lcd_putc("Cargando
VsZeNeR"05" );   //...inicial

   for( ; ; ){   //bucle...
      lcd_gotoxy(2,1);      //donde se va a mostrar la animacion de la bateria
      lcd_send_byte(1,0);    //muestra animacion
      delay_ms(250);
      cont++;               //apunta a siguiente animacion
      recarga();            //crea animacion
         }   //...infinito
}

///FUNCION ENCARGADA DE CREAR ANIMACION
void recarga(void){
   char i;      //indice para for

   lcd_send_byte(0,0x40); // se escribe en la GCRAM posicion 0x40

   switch(cont){   //selecciona animacion
      case 0: for(i=0;i<8;i++)   //bateria al 0%
               lcd_send_byte(1,bat0[ i ]);
            break;
      case 1: for(i=0;i<8;i++)   //bateria al 20%
               lcd_send_byte(1,bat20[ i ]);
            break;
      case 2: for(i=0;i<8;i++)   //bateria al 40%
               lcd_send_byte(1,bat40[ i ]);
            break;
      case 3: for(i=0;i<8;i++)   //bateria al 60%
               lcd_send_byte(1,bat60[ i ]);
            break;
      case 4: for(i=0;i<8;i++)   //bateria al 80%
               lcd_send_byte(1,bat80[ i ]);
            break;
      case 5: for(i=0;i<8;i++)   //bateria al 100%
               lcd_send_byte(1,bat100[ i ]);
               cont=0;         //restaura indice de crear animacion
         }
}

Bueno ya sabemos como dibujar en una lcd no grafica 2x16!!!

PD: monopic el coche de formula 1 te lo dejo ati jeje por cierto eso de los controladores PID esta wai!!! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 30 de Septiembre de 2005, 12:25:00

Desde este enlace os podeis descargar los archivitos necesarios para el programa: Bateria

Suerte!!! :wink:

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 01 de Octubre de 2005, 11:02:00

Ke tal!!!bien siguiendo con lcd y escribir e su CGRAM aqui pongo la animacion del muñeco come-cocos controlado por PC via v.terminal,No es el juego! simplemente pulsamos la tecla 4 para desplazar el muñeco come-cocos hacia la izquierda y la tecla 6 para desplazarlo hacia la derecha de la 1º fila de lcd:

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"05
//                   30/Septiembre/05
//
//   Programa:   Animacion dibujo ComeCocos controlado por RS232
//   Version:   0.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.227
//   Entorno IDE: MPLAB IDE v7.21      Simulador:    Proteus 6.7sp3
//
//   Notas: Se muestra por pantalla de lcd(LM016L) en la primera linea la
//       animacion del dibujo ComeCocos controlado por el v.terminal, si se pulsa
//       numero 4 por PC la animacion se desplaza hacia la izquierda, si se pulsa
//       numero 6 por PC la animacion se desplaza hacia la derecha. Las figuras
//       son simetricas por lo tanto no se han declarado enteras. Tener en cuenta que
//       hay que poner la directiva NOLVP para que el pin B4 sea de salida.
//
//   Conexiones:      B0 -> E
//               B1 -> RS
//               B2 -> RW
//               B4 -> D4
//               B5 -> D5
//               B6 -> D6
//               B7 -> D7
//               A0 -> T1IN MAX232
//               A1 -> R1OUT MAX232
//////////////////////////////////////////////////////////////////////////////////
#include <16f648a.h>            //pic a utilizar
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP,NOBROWNOUT      //ordenes para el programador
#use delay (clock=4000000)         //Fosc=4Mhz
#use rs232(baud=9600, xmit=PIN_A0, rcv=PIN_A1)   //manejo del RS232
#define use_portb_lcd TRUE         //definir portb lcd
#include<lcd.c>                  //libreria manejo lcd

///DECLARACION DE FUNCIONES
void recarga(void);      //funcion que crea el nuevo caracter

///DECLARACION DE VARIABLES GLOBALES
char cont=0,lim=1;      //contador que apunta al nuevo caracter diseñado
   int8    cocod1[]={0b00001111,0b00011110,0b00011100,0b00011000},
cocod2[]={0b00000000,0b01111111,0b11111111,0b11111100},
cocoi1[]={0b00011110,0b00001111,0b00000111,0b00000011},
cocoi2[]={0b00000000,0b01111111,0b11111111,0b00000011};

///PROGRAMA
void main(void)
{
   lcd_init();         //inicializa lcd

   puts("Animacion Come Cocos" );   //animacion...
   puts("====================" );
   puts(" Teclas:" );
   puts(" ¨¨¨¨¨¨¨¨¨¨¨¨" );
   puts(" <-- --> " );
   puts(" 4 6 " );
   puts("VsZeNeR"05" );            //...por v.terminal
   printf(lcd_putc,"ComeCocos
VsZeNeR"05" );   //mensaje por lcd


   for( ; ; ){   //bucle...
      recarga();      //funcion para el movimiento del comecocos
      if(lim>16)      //limites...
         lim=16;
      if(lim<1)
         lim=1;      //...de lcd
      lcd_putc("f
VsZeNeR"05" );
      lcd_gotoxy(lim,1);      //movimiento de la animacion
      lcd_send_byte(1,0);    //muestra animacion
         }   //...infinito
}

///FUNCION ENCARGADA DE CREAR ANIMACION
void recarga(void){
   signed   char i;      //indice para for

   lcd_send_byte(0,0x40); // se escribe en la GCRAM posicion 0x40

   switch(getc() ){   //selecciona animacion
      case "4":    if(!cont){   //movimiento hacia izquierda
                  for(i=0;i<4;i++)   //boca abierta
                     lcd_send_byte(1,cocoi1[ i ]);
                  for(i=3;i>-1;i--)
                     lcd_send_byte(1,cocoi1[ i ]);
                  cont++;
                       }
                 else{               //boca cerrada
                  for(i=0;i<4;i++)
                     lcd_send_byte(1,cocoi2[ i ]);
                  for(i=3;i>-1;i--)
                     lcd_send_byte(1,cocoi2[ i ]);
                     cont=0;
                     }
               lim--;   //apunta siguiente posicion a mostrar animacion en lcd
               break;
      case "6":    if(!cont){   //movimiento hacia derecha
                  for(i=0;i<4;i++)   //boca abierta
                     lcd_send_byte(1,cocod1[ i ]);
                  for(i=3;i>-1;i--)
                     lcd_send_byte(1,cocod1[ i ]);
                  cont++;
                     }
               else{               //boca cerrada
                  for(i=0;i<4;i++)
                     lcd_send_byte(1,cocod2[ i ]);
                  for(i=3;i>-1;i--)
                     lcd_send_byte(1,cocod2[ i ]);
                     cont=0;
                     }
               lim++;   //apunta siguiente posicion a mostrar animacion en lcd
         }
}

Decir que la figura del come-cocos no se ha declarado entera ya que es simetrica la parte de arriba con la de abajo, entonces nos basta con declarar la mitad d ela figura....bueno ya tenemos una animacion moviendose por lcd controlada por RS232....ya seeee que el dibujo no esta muy bien dibujadooooo!!!jeje pero nunca se me ha dado bien el dibujo y menos en matrices 7x5 jeje!!! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 01 de Octubre de 2005, 11:05:00

Desde este enlace os podeis descargar lo necesario para el programa anterior: Animacion come-cocos(NO juego!)

Suerte!!! :wink:

Título: RE: Ejemplitos en C para 16F648A
Publicado por: monopic en 02 de Octubre de 2005, 00:13:00

hola amigo vs.zener estuve mirando la bateria cargandose y la entendi a la perfeccion. hice esto miralo en proteus como quedo, y una nueva pregunta la cgram solo tiene 8 pocisiones como podria hacer para hacer una animacion para cada una de las 32 posiciones de la lcd todavia tengo la idea metida en la cabeza poder manejar cada cuadricula de forma de mostrar una imagen en toda la lcd no se si sirva multiplezar las memorias o algo asi, un dia vi que en una cabina telefonica una lcd de 2x16 con el nombre de SISCO pero utilizaban toda la lcd se veia super y desde ahi se me ocurrio .. ya sabes... gracias por responderme y ademas esto le servira a todos en el foro nuevamente gracias Giño

:

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"05
//                   30/Septiembre/05
//
//   Programa:   Bateria
//   Version:   0.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.227
//   Entorno IDE: MPLAB IDE v7.21      Simulador:    Proteus 6.7sp3
//
//   Notas: Se muestra por pantalla de lcd(LM016L) la animacion de carga de
//       una bateria, para ello se han diseñado nuevos caracteres y almacenados
//       en la memoria GCRAM de la lcd, solo se ha usado una posicion de memoria
//       de dicha GCRAM. Tener en cuenta que hay que poner la directiva NOLVP para
//       que el pin B4 sea de salida.
//
//   Conexiones:      B0 -> E
//               B1 -> RS
//               B2 -> RW
//               B4 -> D4
//               B5 -> D5
//               B6 -> D6
//               B7 -> D7
//////////////////////////////////////////////////////////////////////////////////

#include <16f648a.h>            //pic a utilizar
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP      //ordenes para el programador
#use delay (clock=4000000)         //Fosc=4Mhz
#define use_portb_lcd TRUE
#include <lcd.c>               //libreria manejo de la lcd

///DECLARACION DE FUNCIONES
void recarga(void);      //funcion que crea el nuevo caracter
void cara(void);//carita creada por monopic

///DECLARACION DE VARIABLES GLOBALES
char cont=0;      //contador que apunta al nuevo caracter diseñado
   int8    bat0[]={0b00001110,0b00001010,0b00010001,0b00010001,0b00010001,0b000010001,0b00010001,0b00011111},
bat20[]={0b00001110,0b00001010,0b00010001,0b00010001,0b00010001,0b00010001,0b00011111,0b00011111},
bat40[]={0b00001110,0b00001010,0b00010001,0b00010001,0b00010001,0b00011111,0b00011111,0b00011111},
bat60[]={0b00001110,0b00001010,0b00010001,0b00010001,0b00011111,0b00011111,0b00011111,0b00011111},
bat80[]={0b00001110,0b00001010,0b00010001,0b00011111,0b00011111,0b00011111,0b00011111,0b00011111},
bat100[]={0b00001110,0b00001010,0b00011111,0b00011111,0b00011111,0b00011111,0b00011111,0b00011111};

int8 feliz[]={0b11011,0b00000,0b11011,0b11011,0b00000,0b10001,0b01110};
int8 triste[]={0b11011,0b00000,0b11011,0b11011,0b00000,0b01110,0b10001};
//mios monopic

///PROGRAMA
void main(void)
{
   lcd_init();       //inicializa lcd

   recarga();         //crea 1 animacion
   lcd_gotoxy(5,1);   //presentacion...
   lcd_putc("Cargando
VsZeNeR"05" Giño

;   //...inicial

   for(; Giño

{   //bucle...
      lcd_gotoxy(2,1);      //donde se va a mostrar la animacion de la bateria
      lcd_send_byte(1,0);    //muestra animacion
      recarga();            //crea animacion
      delay_ms(500);
      lcd_gotoxy(3,1);
      lcd_send_byte(1,1); // muestra animacion por monopic
      cara();
      cont++;               //apunta a siguiente animacion
         }   //...infinito
}

///FUNCION ENCARGADA DE CREAR ANIMACION
void recarga(void){
   char i;      //indice para for

   lcd_send_byte(0,0x40); // se escribe en la GCRAM posicion 0x40

   switch(cont){   //selecciona animacion
      case 0: for(i=0;i<8;i++)   //bateria al 0%
               lcd_send_byte(1,bat0);
            break;
      case 1: for(i=0;i<8;i++)   //bateria al 20%
               lcd_send_byte(1,bat20);
            break;
      case 2: for(i=0;i<8;i++)   //bateria al 40%
               lcd_send_byte(1,bat40);
            break;
      case 3: for(i=0;i<8;i++)   //bateria al 60%
               lcd_send_byte(1,bat60);
            break;
      case 4: for(i=0;i<8;i++)   //bateria al 80%
               lcd_send_byte(1,bat80);
            break;
      case 5: for(i=0;i<8;i++)   //bateria al 100%
               lcd_send_byte(1,bat100);
               cont=0;         //restaura indice de crear animacion
         }
}

void cara(void){
char i;
lcd_send_byte(0,0x48);

   switch(cont){   //selecciona animacion
      case 0: for(i=0;i<8;i++)   //bateria al 0%
            lcd_send_byte(1,triste);
            break;
      case 3: for(i=0;i<8;i++)   //bateria al 0%
            lcd_send_byte(1,feliz);
            break;
            cont=cont; }
}

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 02 de Octubre de 2005, 16:48:00

Haber hacer una animacion por cada una de las 32 posiciones de la lcd creo que la unica forma es como se ha realizado la de la bateria, es decir cada vez que vayas apintar un dibujo la cargas en memoria y despues la escribes en la lcd..... Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: olotill en 02 de Octubre de 2005, 21:06:00

HOLA PANA VSZENER...

PUES GRACIAS POR CONTESTAR A MIS DUDAS SOBRE EL LCD, Y MUCHAS GRACIAS POR SEGUIR APORTANDO A NUESTRA AUTOEDUCACION Muchas risas

TE CUENTO QUE SIGO UNO A UNO TUS EJEMPLOS Y LA VERDAD ES QUE SON BASTANTE DIDACTICOS, UNA RAPIDA FORMA DE APRENDER A PROGRAMAR EN C Sonrisa Gigante

BUENO PUES POR AHORA TENGO OTRA CONSULTA, PORQUE A VECES UTILIZAS ESTE COMANDO:

PRINTF(LCD_PUTC,"......",........);

Y EN OTRAS SOLO SE UTILIZA ESTE:

LCD_PUTC("..........." Giño

;

SEGUN YO CREO EN LA PRIMERA ES PARA MANEJAR VARIABLES, Y LA SEGUNDA SOLO MENSAJES EN LA LCD, ESTOY EN LO CORRECTO????

BUENO PUES SEGUIRE ADELANTE HASTA PONERME AL DIA EN LOS EJEMPLAZOS... YA NO ME FALTAN MUCHOS..... YA MISMO ME PONGO AL DIA..... INCREIBLE PERO EN MENOS DE UNA SEMANA YA HE APRENDIDO ALGO DE C, LO QUE ANTES NO SABIA NADA.... Sonrisa Gigante

NUEVAMENTE GRACIAS POR TU ESFUERZO, Y PUES SIGAMOS ADELANTE, ASI ENTRE AMIGOS ES MAS FACIL CRECER....

SALUDOS Y FELICITACIONES POR TU TRABAJO.....

UN ABRAZO DESDE ECUADOR ..... Rebotado

Título: RE: Ejemplitos en C para 16F648A
Publicado por: MGLSOFT en 03 de Octubre de 2005, 07:50:00

Escrito originalmente por monopic
hola amigo vs.zener estuve mirando la bateria cargandose y la entendi a la perfeccion. hice esto miralo en proteus como quedo, y una nueva pregunta la cgram solo tiene 8 pocisiones como podria hacer para hacer una animacion para cada una de las 32 posiciones de la lcd todavia tengo la idea metida en la cabeza poder manejar cada cuadricula de forma de mostrar una imagen en toda la lcd no se si sirva multiplezar las memorias o algo asi, un dia vi que en una cabina telefonica una lcd de 2x16 con el nombre de SISCO pero utilizaban toda la lcd se veia super y desde ahi se me ocurrio .. ya sabes... gracias por responderme y ademas esto le servira a todos en el foro nuevamente gracias :

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"05
//                   30/Septiembre/05
//
//   Programa:   Bateria
//   Version:   0.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.227
//   Entorno IDE: MPLAB IDE v7.21      Simulador:    Proteus 6.7sp3
//
//   Notas: Se muestra por pantalla de lcd(LM016L) la animacion de carga de
//       una bateria, para ello se han diseñado nuevos caracteres y almacenados
//       en la memoria GCRAM de la lcd, solo se ha usado una posicion de memoria
//       de dicha GCRAM. Tener en cuenta que hay que poner la directiva NOLVP para
//       que el pin B4 sea de salida.
//
//   Conexiones:      B0 -> E
//               B1 -> RS
//               B2 -> RW
//               B4 -> D4
//               B5 -> D5
//               B6 -> D6
//               B7 -> D7
//////////////////////////////////////////////////////////////////////////////////

#include <16f648a.h>            //pic a utilizar
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP      //ordenes para el programador
#use delay (clock=4000000)         //Fosc=4Mhz
#define use_portb_lcd TRUE
#include <lcd.c>               //libreria manejo de la lcd

///DECLARACION DE FUNCIONES
void recarga(void);      //funcion que crea el nuevo caracter
void cara(void);//carita creada por monopic

///DECLARACION DE VARIABLES GLOBALES
char cont=0;      //contador que apunta al nuevo caracter diseñado
   int8    bat0[]={0b00001110,0b00001010,0b00010001,0b00010001,0b00010001,0b000010001,0b00010001,0b00011111},
bat20[]={0b00001110,0b00001010,0b00010001,0b00010001,0b00010001,0b00010001,0b00011111,0b00011111},
bat40[]={0b00001110,0b00001010,0b00010001,0b00010001,0b00010001,0b00011111,0b00011111,0b00011111},
bat60[]={0b00001110,0b00001010,0b00010001,0b00010001,0b00011111,0b00011111,0b00011111,0b00011111},
bat80[]={0b00001110,0b00001010,0b00010001,0b00011111,0b00011111,0b00011111,0b00011111,0b00011111},
bat100[]={0b00001110,0b00001010,0b00011111,0b00011111,0b00011111,0b00011111,0b00011111,0b00011111};

int8 feliz[]={0b11011,0b00000,0b11011,0b11011,0b00000,0b10001,0b01110};
int8 triste[]={0b11011,0b00000,0b11011,0b11011,0b00000,0b01110,0b10001};
//mios monopic

///PROGRAMA
void main(void)
{
   lcd_init();       //inicializa lcd

   recarga();         //crea 1 animacion
   lcd_gotoxy(5,1);   //presentacion...
   lcd_putc("Cargando
VsZeNeR"05";   //...inicial

   for(;{   //bucle...
      lcd_gotoxy(2,1);      //donde se va a mostrar la animacion de la bateria
      lcd_send_byte(1,0);    //muestra animacion
      recarga();            //crea animacion
      delay_ms(500);
      lcd_gotoxy(3,1);
      lcd_send_byte(1,1); // muestra animacion por monopic
      cara();
      cont++;               //apunta a siguiente animacion
         }   //...infinito
}

///FUNCION ENCARGADA DE CREAR ANIMACION
void recarga(void){
   char i;      //indice para for

   lcd_send_byte(0,0x40); // se escribe en la GCRAM posicion 0x40

   switch(cont){   //selecciona animacion
      case 0: for(i=0;i<8;i++)   //bateria al 0%
               lcd_send_byte(1,bat0);
            break;
      case 1: for(i=0;i<8;i++)   //bateria al 20%
               lcd_send_byte(1,bat20);
            break;
      case 2: for(i=0;i<8;i++)   //bateria al 40%
               lcd_send_byte(1,bat40);
            break;
      case 3: for(i=0;i<8;i++)   //bateria al 60%
               lcd_send_byte(1,bat60);
            break;
      case 4: for(i=0;i<8;i++)   //bateria al 80%
               lcd_send_byte(1,bat80);
            break;
      case 5: for(i=0;i<8;i++)   //bateria al 100%
               lcd_send_byte(1,bat100);
               cont=0;         //restaura indice de crear animacion
         }
}

void cara(void){
char i;
lcd_send_byte(0,0x48);

   switch(cont){   //selecciona animacion
      case 0: for(i=0;i<8;i++)   //bateria al 0%
            lcd_send_byte(1,triste);
            break;
      case 3: for(i=0;i<8;i++)   //bateria al 0%
            lcd_send_byte(1,feliz);
            break;
            cont=cont; }
}

Bueno en esta direccion , en el tercer mensaje encontraras una rutina que elaboramos entre todos para hacer una presentacion numerica en un lcd 2x16 y utilizando ambas lineas:
http://miarroba.com/foros/ver.php?foroid=46840&temaid=1654587&marcar=ejemplos+programas

Espero te sea util!!!

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 03 de Octubre de 2005, 12:31:00

ke tal olotill!!!jeje pues te has contestado tu mismo!!!veo ke aprendes rapido!jeje exacto como bien indicas tu, el printf(lcd_putc......) es para manejar variables, datos que queremos mostrar por pantalla que varian a lo largo del programa....o que querramos mostrar contenidos de variables etc.....la funcion lcd_putc es para mostrar mensajes simplemente, es mas comodo asi.....suerteee con los ejemplitos y pa"lanteee jeje y no vayas tan rapido que sino voy a tener que trabajar yo mas!!!!jeje y ultimamente no tengo mucho tiempo!!!jeje es broma me alegro enormemente que estes aprendiendo c gracias en parte a mis ejemplos y que ya por lo menos le hayas perdido el miedo e incluso espero que te guste y todo el lenguaje c!!!jeje Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: monopic en 03 de Octubre de 2005, 23:05:00

hola vzener yo entiendo que tocaria pintar primero en cada ubicacion de la cgram y luego posicionarla en cualquier cuadro de la lcd pero mi duda es como haria si la cgram solo tiene 8 posiciones y la lcd tiene 32 cuadros .. como haria?? gracias nuevamente...

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 04 de Octubre de 2005, 06:33:00

Vamos haber....simplemente con una posicion de memoria te basta......pero tienes 8.....hacerlo pues haber si quieres dibujar 16 animaciones definidas por ti en la 1º fila y otras 16 en la 2ºfila de la lcd solamente tendras que decir donde poner la siguiente animacion, si te fijas en el ejemplito del come-cocos, la animacion se mueve por pantalla mediante la instruccion lcd_gotoxy(x,y); donde "x" se refiere a filas de la lcd(2 en este caso) e "y" se refiere a columnas(16 e este caso) asi pdras dibujar animaciones en todas las posiciones de memoria...ahora bien si lo que quieres es cambiar en las 32 posiciones a la vez de animacion no podras ya que estas limitado a 8 animaciones en la GCRAM de la lcd. Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: monopic en 04 de Octubre de 2005, 22:25:00

hola vzener podria hacer lo siguiente,,, crear un caracter cualquiera y guardarlo en una posicion de la cgram y visualizarlo y luego sobreescribir esa posicion de la cgram y visualizarla tambien pero en otra posicion de la lcd.. no se perp debe haber laguna forma de poder manejar las 32 posiciones de la lcd... ha que opinas .. gracias...otra duda,, el proteus corre a la perfeccion pero lo programe en un 16f84 y no corre de igual forma ....

Título: RE: Ejemplitos en C para 16F648A
Publicado por: cchhaa en 05 de Octubre de 2005, 03:42:00

hola vszener, solo queria agradecer tu postura de compartir tus conocimientos con los demas, estoy todabia por las primeras paginas de este post, encendiendo diodos y tal, pero ojeando las demas paginas veo una cantidad de informacion impresionante, con codigos, trucos y ayudas que sin duda haran que yo y muchos mas aprendamos mas rapido y con mas base. Sigue asi compañero!!!!

un saludo y gracias
cchhaa

Título: RE: Ejemplitos en C para 16F648A
Publicado por: monopic en 05 de Octubre de 2005, 22:06:00

hola vszener mira lo que he creado son tres animaciones la primera una cara feliz-triste, la segunda esta la bateria que inicialmente hiciste y en la tercera el famoso caminante el cual lo hice basandome en tu ejemplo.,,

//////////////////////////////////////////////////////////////////////////////////
// 3 animaciones en una lcd de 2x16
//   Conexiones:      B0 -> E
//               B1 -> RS
//               B2 -> RW
//               B4 -> D4
//               B5 -> D5
//               B6 -> D6
//               B7 -> D7
//////////////////////////////////////////////////////////////////////////////////

#include <16f877a.h>            //pic a utilizar
#fuses XT   //ordenes para el programador
#use delay (clock=4000000)         //Fosc=4Mhz
#define use_portb_lcd TRUE
#include <lcd420.c>               //libreria manejo de la lcd

///DECLARACION DE FUNCIONES
void recarga(void);      //funcion que crea el nuevo caracter
void cara(void);//carita creada por monopic
void caminante(void);
///DECLARACION DE VARIABLES GLOBALES
char cont=0;      //contador que apunta al nuevo caracter diseñado
   int8    bat0[]={0b00001110,0b00001010,0b00010001,0b00010001,0b00010001,0b000010001,0b00010001,0b00011111},
bat20[]={0b00001110,0b00001010,0b00010001,0b00010001,0b00010001,0b00010001,0b00011111,0b00011111},
bat40[]={0b00001110,0b00001010,0b00010001,0b00010001,0b00010001,0b00011111,0b00011111,0b00011111},
bat60[]={0b00001110,0b00001010,0b00010001,0b00010001,0b00011111,0b00011111,0b00011111,0b00011111},
bat80[]={0b00001110,0b00001010,0b00010001,0b00011111,0b00011111,0b00011111,0b00011111,0b00011111},
bat100[]={0b00001110,0b00001010,0b00011111,0b00011111,0b00011111,0b00011111,0b00011111,0b00011111};

int8 feliz[]={0b11011,0b00000,0b11011,0b11011,0b00000,0b10001,0b01110,0b00000};
int8 triste[]={0b11011,0b00000,0b11011,0b11011,0b00000,0b01110,0b10001,0b00000};

int8 cam0[]={0b01110,0b01110,0b00100,0b00100,0b00100,0b00100,0b01100,0b00000},
cam1[]={0b01110,0b01110,0b00100,0b00100,0b01100,0b00100,0b01100,0b00000},
    cam2[]={0b01110,0b01110,0b00100,0b00100,0b01010,0b11010,0b00110,0b00000},
    cam3[]={0b01110,0b01110,0b00100,0b00100,0b00110,0b01001,0b11001,0b00000},
    cam4[]={0b01110,0b01110,0b00100,0b00100,0b00111,0b01001,0b11000,0b00000},
    cam5[]={0b01110,0b01110,0b00100,0b00100,0b01100,0b00110,0b01100,0b00000};
//mios monopic

///PROGRAMA
void main(void)
{
   lcd_init();       //inicializa lcd

   recarga();         //crea 1 animacion
   lcd_gotoxy(6,1);   //presentacion...
   lcd_putc("Monopic " Giño

;   //...inicial

   for(; Giño

{   //bucle...
      lcd_gotoxy(2,1);      //donde se va a mostrar la animacion de la bateria
      lcd_send_byte(1,0);    //muestra animacion
      recarga();            //crea animacion
      delay_ms(70);
      caminante();
      lcd_gotoxy(3,1);
      lcd_send_byte(1,1); // muestra animacion por monopic
      cara();
      lcd_gotoxy(4,1);
      lcd_send_byte(1,2);
      caminante();
      delay_ms(70);
      cont++;               //apunta a siguiente animacion
         }   //...infinito
}

///FUNCION ENCARGADA DE CREAR ANIMACION
void recarga(void){
   char i;      //indice para for

   lcd_send_byte(0,0x48); // se escribe en la GCRAM posicion 0x40

   switch(cont){   //selecciona animacion
      case 0: for(i=0;i<8;i++)   //bateria al 0%
               lcd_send_byte(1,bat0);
            break;
      case 1: for(i=0;i<8;i++)   //bateria al 20%
               lcd_send_byte(1,bat20);
            break;
      case 2: for(i=0;i<8;i++)   //bateria al 40%
               lcd_send_byte(1,bat40);
            break;
      case 3: for(i=0;i<8;i++)   //bateria al 60%
               lcd_send_byte(1,bat60);
            break;
      case 4: for(i=0;i<8;i++)   //bateria al 80%
               lcd_send_byte(1,bat80);
            break;
      case 5: for(i=0;i<8;i++)   //bateria al 100%
               lcd_send_byte(1,bat100);
               cont=0;         //restaura indice de crear animacion
         }
}

void cara(void){
char i;
lcd_send_byte(0,0x40);

   switch(cont){   //selecciona animacion
      case 0: for(i=0;i<8;i++)   //bateria al 0%
            lcd_send_byte(1,triste);
            break;
      case 3: for(i=0;i<8;i++)   //bateria al 0%
            lcd_send_byte(1,feliz);
            break;
            cont=cont; }
}

void caminante(void){
   char i;      //indice para for

   lcd_send_byte(0,0x50); // se escribe en la GCRAM posicion 0x56

   switch(cont){   //selecciona animacion
      case 0: for(i=0;i<8;i++)   //bateria al 0%
               lcd_send_byte(1,cam0);
            break;
      case 1: for(i=0;i<8;i++)   //bateria al 20%
               lcd_send_byte(1,cam1);
            break;
      case 2: for(i=0;i<8;i++)   //bateria al 40%
               lcd_send_byte(1,cam2);
            break;
      case 3: for(i=0;i<8;i++)   //bateria al 60%
               lcd_send_byte(1,cam3);
            break;
      case 4: for(i=0;i<8;i++)   //bateria al 80%
               lcd_send_byte(1,cam4);
            break;
      case 5: for(i=0;i<8;i++)   //bateria al 100%
               lcd_send_byte(1,cam5);
               cont=0;         //restaura indice de crear animacion
         }
}

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 06 de Octubre de 2005, 04:47:00

Jeje ke tal a todos!!! lo siento estoy algo perdido ya que estoy de viaje, ahora de regreso de madrid y este fin de semana me voy a cordoba...jeje asi que por eso no puedo subir mas ejemplitos ainsss jeje haber por partes....

monopic, con respecto de usar los 32 caracteres de la lcd decirte que s epuede hacer como te indique, es decir tu realizas animaciones la guardas en una posicion de memoria y despues la dibujas donde quieras en la lcd mediante la funcion por ejemplo lcd_gotoxy(x,y); si te refieres a declarar 32 animaciones y almacenarlas en la cgram de la lcd decirte que no s epuede ya que solo admite un maximo de almacenamiento de 8(aunque en otro libro lei que eran 9 es cuestion d emirar el data sheet), con respecto a que lo has cargado en un 16F84 y dices que no corre igual...ummmm que sale???fijate que el 16F84 solo admite un maximo de 1k....y con respecto a las animaciones que has realizado solo me queda decirte que: FANTASTICO!!!!jeje aunque todavia no he podido verlas ya que estoy de viaje, lo que puedes hacer es como yo, pones el codigo y en el almacen subes tanto el codigo como la simulacion en PROTEUS y despues la enlazas aqui para que la gente pueda bajarsela okis??? pero me gusta ver que alguien utiliza mis programas como base para realizar los suyos...sigue asi!!!!

cchhaa GRACIAS!!!!jeje los animos son buenos y mas ahora!!que estoy super extresado con tanto viajecito, las clases,.....jeje veo que vas por los led"s jeje buen comienzo pronto manejaras 7seg,lcd"s,teclados,....jeje suerte y no desesperes!!!!

Ke tal olotill!!!jeje quieres llegar pronto a la cima ennn!!!jeje haber pregunta bastante buena ya que eso significa que eres observador ummmmm jeje haber la variable declarada dow es simplemente por seguir las reglas de la libreria ds1302.c del compilador CCS, si la miras veras que las funciones declaradas para usar dicho dispositivo devuelven un valor en la variable dow, creo recordar que dicha variable te daba el año proximo.....por eso no la uso porque no me interesa dar el siguiente año, pero vamos que solamente se usa ya que esta declaradas en funciones que usamos como estas:
rtc_set_datetime(day,mth,year,dow,hour,min)
Si no la declaro deberia poner en la 4ºvariable usar la funcion un valor cualquiera indeterminado, asi que me ahorro eso y uso la declaracion d ela libreria: dow, te recomiendo que te mires dicha libreria del compilador! y ahora a seguir hacia delante!!!jeje que pronto llegaras a manejar RS232!!!jeje

Bueno y solo decir que estoy bastante feliz y satisfecho de ver que sirve este post de ayuda a la gente para la programacion, aunque son ejemplitos bastante tontos(algunos.....) mi intencion no era realizar ejemplos complejos, simplemente enseñar o mostrar como se programa lo basico para que cada uno despues a sus intereses lo usase como mejor le conveniese y veo que funciona!jeje repito, estoy algo estresado por tanto viaje pero en cuanto me instale otra vez y vuelva a la rutina empezare a colgar mas ejemplos, todavia queda mostrar la programacion del WDT, CCP1 en mas modalidades y mucho mas!!!!jeje GRACIAS A TODOS y a seguir programando!!!! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: monopic en 06 de Octubre de 2005, 13:20:00

no se como subir los archivos,, caundo voy a dar una nueva respuesta dice que puedo subir 3 archivos de 256k c/u pero dice que no se puede enviar cuando lo cargo alguien q sepa otra forma q me diga gracias

Título: RE: Ejemplitos en C para 16F648A
Publicado por: monopic en 06 de Octubre de 2005, 22:55:00

ya se como subirlos aqui estan tres animaciones en una lcd 2x16 se aprecia unca carqa que pasa de feliz a triste y lo contrario,, una carga de bateria hecha por nuestro amigo vnzener,, y el famoso caminante que diseñe en mi programa espero q les guste....respondan a ver k tal voy en mi intento de convertir una lcd 2x16 en grafica.

alguien sabe como funciona la lcd grafica escribe de izquierda a derecha o algo asi porfa quien sepa no dude en ecribirlo.

aqui esta el link de descarga http://miarroba.com/foros/ver.php?foroid=348538&temaid=3690144

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 19 de Octubre de 2005, 06:20:00

Buenass!!!jeje estoy perdido por aqui pero no me olvido!!!jeje ya hace mas de dos meses del post y ya van bastantes ejemlos!, bien estaba aburrido en el trayecto de un viaje y me puse a trastear con las librerias del compilador CCS y adapte la ds1302.c para el manejo del ds1620 es decir de una RTC->Termometro jeje decir que es muyyy BETA pero funciona ,eso si provada solamente en PROTEUS, aqui os dejo el enlace al data sheet del dispositivo:
http://www.maxim-ic.com/quick_view2.cfm/qv_pk/2735/ln/en
Y desde este link os podeis descargar la libreria ds1620.c version 0.0 BETA:
http://miarroba.com/foros/ver.php?foroid=348538&temaid=3740041

Haber si saco tiempo y la pongo perfect! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 19 de Octubre de 2005, 06:31:00

ke tal!!! bien hoy voy a usar la liberia ds1620.c BETA que realice, asi que el ejemplo de hoy es como hacer un medidor de temperatura usando este dispositivo, aqui el programa:

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"05
//                   19/Octubre/05
//
//   Programa:   Termometro digital DS1620
//   Version:   0.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.235
//   Entorno IDE: MPLAB IDE v7.21      Simulador:    Proteus 6.7sp3
//
//   Notas: Se muestra por pantalla de lcd(LM016L) la temperatura del ds1620
//   Conexiones:      A0 -> DQ DS1620
//               A1 -> CLK DS1620
//               A2 -> RST DS1620
//               B0 -> E
//               B1 -> RS
//               B2 -> RW
//               B4 -> D4
//               B5 -> D5
//               B6 -> D6
//               B7 -> D7
//////////////////////////////////////////////////////////////////////////////////

#include <16f648a.h>            //pic a utilizar
#use delay(CLOCK=4000000)         //Fosc=4Mhz
#fuses HS,NOPUT,NOPROTECT,NOBROWNOUT,NOLVP,NOWDT   //comandos para el programador
#fuses INTRC   //oscilador interno
#use standard_io(a)
#use standard_io(b)
#define use_portb_lcd TRUE         //utilizar el port b para lcd
#define DS1620_DQ      PIN_A0      //declaracion de pins...
#define DS1620_CLK      PIN_A1
#define DS1620_RST      PIN_A2      //...para el ds1620
#include <ds1620.c>               //libreria del termometro ds1620
#include <lcd.c>                //libreria de lcd

///PROGRAMA
void main(void){
   char i;
   int8 grado[]={0b00000110,0b00001001,0b00000110};

   lcd_init();       //inicializa lcd

   lcd_putc(" Termometro
   VsZeNeR"05" );   //presentacion...
   delay_ms(800);
   lcd_putc("f" );                        //...inicial

   lcd_putc(" VsZeNeR"05
Temperatura:" );   //pantalla temp

   lcd_send_byte(0,0x40);    // se escribe en la GCRAM posicion 0x40
   for(i=0;i<3;i++)      //dibujo del simbolo grado º
      lcd_send_byte(1,grado[ i ]);
   lcd_gotoxy(16,2);      //donde se va a mostrar º
   lcd_send_byte(1,0);    //muestra animacion

   ds1620_init();      //inicializa ds1620

    for(; ; ){         //bucle...
       lcd_gotoxy(14,2);
      printf(lcd_putc,"%d",read_ds1620(0xAA));   //muestra temperatura por pantalla
      delay_ms(500);
      lcd_putc("" );
      }             //...infinito
}

Aqui la primera prueba con la libreria ds1620.c!

LIBRERIA OBSOLETA

Suerte!!! :wink:

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 19 de Octubre de 2005, 06:32:00

Desde este enlace os podeis descargar el programa Temeperatura con la libreria beta ds1620.c:

LIBRERIA OBSOLETA

Suerte!!! :wink:

Título: RE: Ejemplitos en C para 16F648A
Publicado por: mario_pastor en 02 de Noviembre de 2005, 09:39:00

Saludos vszener y a todos en este sub-foro, quiero agradecerte por este aporte tan valioso para nosotros que estamos iniciando en este mundo de la programación en C.... además quiero resaltar el orden y metodología que empleas que muy pocos lo tienen, mis felicitaciones y nuevamente nuchas gracias... ya estaré molestandote con algunas preguntas Sonrisa Gigante

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 03 de Noviembre de 2005, 03:04:00

Buenasss!!!jeje se que tengo esto algo olvidado....pero es que estoy ocupado....jeje ainsss holaaa mario_pastor!!!!jeje GRACIAS por las felicitaciones por este post, la verdad que leer de vez en cuando felicitaciones alaga bastante y te dan animos para seguir jeje y encantado de que me molestes con preguntas!jeje

Bueno decir que Microchip ha lanzado su nueva version der MPlab v7.22 aqui el enlace para la descarga
http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=1406&dDocName=en019469&part=SW007002
asi que los nuevos ejercicios estaran integrados en el nuevo IDE, tambien decir que los nuevos programas estaran compilados con una version superior del CCS vs3.235, para la bajada del CCS no se puede dar enlaces directos ya que es ilegal(por lo tanto corre el riesgo de que cierren el foro)asi que buscarlos por programas tipo P2P. Bueno hasta otra!!! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 03 de Noviembre de 2005, 03:12:00

Holaaaaa!!!!jeje bien, el programa de hoy consiste en manejar el periferico CCP1 configurado como PWM, decir que el PWM consiste en obtener a frecuencias constantes(por lo tanto periodo constante) una anchura de pulso variable(la cual nosotros programamos), en este caso, la anchura de pulsos para las frecuencias constantes es siempre la misma, la mitad del periodo, y las frecuencias las obtenemos mediante el preescaler del TMR2....aqui el ejemplito:

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"05
//                   2/Noviembre/05
//
//   Programa:   Uso del CCP1 como PWM
//   Version:   0.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.235
//   Entorno IDE: MPLAB IDE v7.22      Simulador:    Proteus 6.7sp3
//
//   Notas: Usamos el modulo CCP1 como PWM, para ello configuramos el TMR2 de sus tres
//       formas distintas mediante el preescales(1,4,16) que nos dara distintas frecuencias.
//       El ciclo viene determinado por (1/clock)*4*t2div*(periodo+1), donde en este caso
//       clock=4MHz y periodo=127.
//       Frecuencias:
//             ·T2_DIV_BY_1 -> 128us -> 7,81KHz
//             ·T2_DIV_BY_4 -> 512us -> 1,95KHz
//             ·T2_DIV_BY_16 -> 2,05ms -> 487,8Hz
//       En este programa tendremos un nivel alto a la mitad de la frecuencia obtenida mediante
//       la relacion valor*(1/clock)*t2div donde valor=%nivel alto del pulso
//       Anchura del pulso(Duty):
//            ·128us -> 64us -> 64us/(1*(1/4000000)) = 256
//            ·512us -> 256us -> 256us/(4*(1/4000000)) = 256
//            ·2,05ms -> 1,02ms -> 1,02ms/(16*(1/4000000)) = 256
//
//       Conexiones:      B0 -> E
//                     B1 -> RS
//                     B2 -> RW
//                     B4 -> D4
//                     B5 -> D5
//                     B6 -> D6
//                     B7 -> D7
//                     B3 -> Canal 1 osciloscopio
//                     A0 -> Boton
//////////////////////////////////////////////////////////////////////////////////

#include <16f648a.h>            //pic a utilizar
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP      //ordenes para el programador
#fuses INTRC   //oscilador interno
#use delay (clock=4000000)         //Fosc=4Mhz
#use standard_io(b)
#define use_portb_lcd TRUE         //definir portb lcd
#include<lcd.c>                  //libreria manejo lcd

///DECLARACION DE FUNCIONES
void cambia_frec(char);      //funcion encargada de cambiar la frecuencia

///PROGRAMA
void main(void)
{
   char opcion=0;         //variable encargada de mostrar menu de frec

   setup_ccp1(CCP_PWM); //ccp1 modo PWM

   lcd_init();            //inicializa lcd

   cambia_frec(opcion);   //muestra primera frec

   for( ; ; ){      //bucle...
      if(!input(PIN_A0)){            //¿se ha pulsado el boton?
         do{                     //SI -> eliminar...
         }while(!input(PIN_A0));      //...rebotes del boton
         opcion++;               //apunta a siguiente frec
         if(opcion>2)            //¿ya se han mostrado todas las frec?
            opcion=0;            //SI -> resetea opcion
         cambia_frec(opcion);      //cambia frecuencia
         }
      }         //...infinito
}

///FUNCION ENCARGADA DE CAMBIAR LA FRECUENCIA POR CCP1
void cambia_frec(char menu)
{
   lcd_putc("f" );
   switch(menu){   //menu para eleccion de frecuencias
      case 0:   setup_timer_2(T2_DIV_BY_1, 127, 1);      //128us -> 7,81kHz
            set_pwm1_duty(256);                  //64us/(1*(1/4000000)) = 256
            lcd_putc(" VsZeNeR"05
Frec=7,81KHz" );
            break;
      case 1:   setup_timer_2(T2_DIV_BY_4, 127, 1);      //512us -> 1,95kHz
            set_pwm1_duty(256);                  //256us/(4*(1/4000000)) = 256
            lcd_putc(" VsZeNeR"05
Frec=1,95KHz" );
            break;
      case 2:   setup_timer_2(T2_DIV_BY_16, 127, 1);    //2,05ms -> 487,8Hz
            set_pwm1_duty(256);                   //1,02ms/(16*(1/4000000)) = 256
            lcd_putc(" VsZeNeR"05
Frec=487,8Hz" );
      }
}

Decir que la frecuencia que obtenemos son de 7,81kHz,1,95kHz y 487,8Hz y se cambia pulsando en boton que esta en el pin A0. Observar en la simulacion PROTEUS en el osciloscopio las divisiones del Timerbase para ver y comprobar que la anchura de pulso es la calculada y por o tanto la deseada. Aqui dejo un enlace a un post donde se habla del tema del PWM y se explica en que consiste
Como funciona el PWM (http://www.todopic.com.ar/foros/index.php?topic=4917.0)

Suerte!!! :wink:

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 03 de Noviembre de 2005, 03:16:00

Desde este enlace os podeis descargar el programa anterior: CCP1 modo PWM

Suerte!!! :wink:

Título: RE: Ejemplitos en C para 16F648A
Publicado por: andresitovv en 03 de Noviembre de 2005, 06:12:00

Puedes poner algún ejemplo en el q estén involucrados varios archivos? Siempre lo haceis todo en uno, y para una progrmación extensa y ordenada eso no es bueno. Vamos, que quiero saber como se utilizan varios archivos en CCS. Gracias.

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 03 de Noviembre de 2005, 12:25:00

Ke tal!!!! bien en el que esten involucrados varios archivos creo que en el ejemplo 10 hice una libreria la cual reune el ejemplo de juego de luces y el coche fantastico....miratelo y me comentas!Suerte!!! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: andresitovv en 04 de Noviembre de 2005, 08:53:00

Muchas gracias, la q verdad es q sí que sirve. Y la verdad es que lo había hecho yo ya, pero te lo agradezco igualmente. Mi problema es cuando quiero usar una variable definida en main como variable global en una función del archivo .h. Dirás que lo pase como parámetro, pero mi problema es q esa variable cambia en una rutina de interrupción que está en el archivo principal (.c) y la función q está en el .h debe ser capaz de usarla. Si pongo la rutina de interrupción en el .h funcionará? Y si quiero tener varios archivos .h (es un programa bastante largo y debo tenrlo ordenado para presentarlo) basta con que lo ponga la rutina de interrupción en uno, o tiene q estar en el .c? Espero haberme explicado más o menos. Te pongo el código (q es más largo todavía de lo q aparece aqui), aunq lo único q sirve para mi pregunta del main.c es la rutina de interrupción de Timer.

/* ARCHIVO MAIN.C*/

#include <18F452.h>
#include <string.h>
#include <stdlib.h>
#include <on_off.h>

#fuses HS,NOCPD,NOCPB,NOWDT,NOPUT,NOLVP,NOBROWNOUT,NOWRT,NOSTVREN,NOEBTR,NOEBTRB,NOWRTB,NOWRTC,NOWRTD
#use delay(clock=8000000)
#use rs232(baud=9600, xmit=PIN_C6, rcv=PIN_C7)
#use fast_io(A)
#use fast_io(B)
#use fast_io(C)
#use fast_io(D)
#use fast_io(E)

//int seno[64][9]={{1,0,0,0,0,0,0,0,0},{1,0,0,0,1,1,0,0,1},{1,0,0,1,1,0,0,1,0},{1,0,1,0,0,1,0,1,1},{1,0,1,1,0,0,0,1,1},{1,0,1,1,1,1,0,1,0},{1,1,0,0,1,0,0,0,0},{1,1,0,1,0,0,1,0,0},{1,1,0,1,1,0,1,1,1},{1,1,1,0,0,1,0,0,0},{1,1,1,0,1,0,1,1,1},{1,1,1,1,0,0,1,0,0},{1,1,1,1,0,1,1,1,0},{1,1,1,1,1,0,1,1,0},{1,1,1,1,1,1,1,0,0},{1,1,1,1,1,1,1,1,1},{1,1,1,1,1,1,1,1,1},{1,1,1,1,1,1,1,0,1},{1,1,1,1,1,1,0,0,1},{1,1,1,1,1,0,0,1,0},{1,1,1,1,0,1,0,0,0},{1,1,1,0,1,1,1,0,0},{1,1,1,0,0,1,1,1,0},{1,1,0,1,1,1,1,1,0},{1,1,0,1,0,1,1,0,0},{1,1,0,0,1,1,0,0,1},{1,1,0,0,0,0,0,1,1},{1,0,1,1,0,1,1,0,1},{1,0,1,0,1,0,1,0,1},{1,0,0,1,1,1,1,0,1},{1,0,0,1,0,0,1,0,0},{1,0,0,0,0,1,0,1,0},{0,1,1,1,1,0,0,0,1},{0,1,1,0,1,0,1,1,1},{0,1,0,1,1,1,1,1,0},{0,1,0,1,0,0,1,1,0},{0,1,0,0,0,1,1,1,0},{0,0,1,1,1,1,0,0,0},{0,0,1,1,0,0,0,1,1},{0,0,1,0,0,1,1,1,1},{0,0,0,1,1,1,1,1,0},{0,0,0,1,0,1,1,1,0},{0,0,0,1,0,0,0,0,0},{0,0,0,0,1,0,1,0,1},{0,0,0,0,0,1,1,0,0},{0,0,0,0,0,0,1,0,1},{0,0,0,0,0,0,0,0,1},{0,0,0,0,0,0,0,0,0},{0,0,0,0,0,0,0,0,0},{0,0,0,0,0,0,1,0,0},{0,0,0,0,0,1,0,1,0},{0,0,0,0,1,0,0,1,0},{0,0,0,0,1,1,1,0,1},{0,0,0,1,0,1,0,1,0},{0,0,0,1,1,1,0,1,0},{0,0,1,0,0,1,0,1,1},{0,0,1,0,1,1,1,1,0},{0,0,1,1,1,0,0,1,1},{0,1,0,0,0,1,0,0,1},{0,1,0,1,0,0,0,0,0},{0,1,0,1,1,1,0,0,0},{0,1,1,0,1,0,0,0,1},{0,1,1,1,0,1,0,1,0},{1,0,0,0,0,0,1,0,0}};
long int sin[64]={256,281,305,330,353,376,397,418,436,453,468,481,492,500,506,510,511,510,506,500,492,481,468,453,436,418,397,376,353,330,305,28,255,230,206,181,158,135,114,93,75,58,43,30,19,11,5,1,0,1,5,11,19,30,43,58,75,93,114,135,158,181,206,230};
long int tri[64]={0,16,32,48,64,80,96,112,128,144,160,176,192,208,224,240,256,271,287,303,319,335,351,367,383,399,415,431,447,463,479,495,511,495,479,463,447,431,415,399,383,367,351,335,319,303,287,271,256,240,224,208,192,176,160,144,128,112,96,80,64,48,32,16};
int tipo_s=0,opcion=1,canal=1, tiempo=0x80,n=1;
int trojo=0;
int tverde=0;
int y;
int reloj=0,cont12=0,cont64=0;

#INT_RDA
void rsis(void)
{
char string[20];

gets(string);
opcion=atol(string); //Leemos la opcion introducida

switch(opcion)
{
case 1:
printf("

1 -> Seno
2 -> Triangular
3 -> Cuadrada
0 -> Salida nula" Giño

;
printf("

Tipo senal numero: " Giño

;
gets(string);
tipo_s=atol(string);
output_d(tipo_s|0b10110000);
if(tipo_s>3){
printf("

Opcion incorrecta. Tipo de señal fijada: Salida nula." Giño

;
tipo_s=0;
}
break;

case 2:
printf("

Introduzca número entre 128 y 255

Frecuencia: " Giño

;
gets(string);
tiempo=atol(string);
if(tiempo<128||tiempo>255){
printf("

Opcion incorrecta. Tiempo fijado a 128." Giño

;
tiempo=128;
}
break;

case 3:
printf("

Elija Canal (1, 2, 3 o 4): " Giño

;
gets(string);
canal=atol(string);
output_d(canal|0b10100000);
if(canal>4){
printf("

Opcion incorrecta. Canal fijado a 1." Giño

;
canal=1;
}
break;

default:
printf("
Opción incorrecta. Introduzca 1 o 2" Giño

;
}

printf("

Que desea cambiar?" Giño

;
printf("

1 -> Tipo de senal
2 -> Frecuencia
3 -> Canal de salida" Giño

;
printf("

Opcion numero: " Giño

;
}

#int_timer2 //Funcion a la que se llama periodicamente
clock_isr() { // the RTCC (timer0) overflows (255->0).

if (reloj == 0){
reloj = 1;
output_high(PIN_A3);}
else{
reloj = 0;
output_low(PIN_A3);

if(cont12<12)
cont12++;
else{
output_high(PIN_A2); //Pulso de LOADIN
output_low(PIN_A2);

cont12=0;

if(cont64==64)
cont64=0;
else
cont64+=n;
}
}
}

void retardo(int n) { // retardo de n x 100ms ; 0 <= n => 255
for (; n!=0; n--)
delay_ms(100);
}

void seno()
{
enciende(tiempo,canal);

while (input(PIN_E2)==1)
{
if(cont12<9)
{
if(bit_test(sin[cont64],8-cont12))
output_high(PIN_A4); //Debe coger el dato
else
output_low(PIN_A4);
}
else
output_low(PIN_A4); //Debe coger 4 ceros. Canal 1 y para indicar que son datos
}
}

void triang()
{

enciende(tiempo,canal);

while (input(PIN_E2)==1)
{
if(cont12<9)
{
if(bit_test(tri[cont64],8-cont12))
output_high(PIN_A4); //Debe coger el dato
else
output_low(PIN_A4);
}
else{
output_low(PIN_A4); //Debe coger 4 ceros. Canal 1 y para indicar que son datos
}
}
}

void cuad()
{
int cuad=0;
int cambio=0;

enciende(tiempo,canal);

cuad=cont12;

while (input(PIN_E2)==1)
{
if(reloj==1&&cuad!=cont12)
{
if(cambio==0){
output_high(PIN_A4);
cambio=1;
}
else{
output_low(PIN_A4);
cambio=0;
}
cuad=cont12;
}
}
}

void main()
{
enable_interrupts(INT_RDA);
enable_interrupts(GLOBAL);

set_tris_a(0x00);
set_tris_b(0xFF);
set_tris_c(0b10111111);
set_tris_d(0x00);
set_tris_e(0b101);

output_a(0x20);
output_low(PIN_E1);

while(1)
{
y=0,cont12=0,cont64=0;

while (input(PIN_E2)==1)
{
output_low(PIN_A1);
output_high(PIN_A0);

switch(tipo_s)
{
case 1:
output_high(PIN_A0);
output_d(1);
seno(); break;
case 2:
output_high(PIN_A1);
output_d(2);
triang(); break;
case 3:
output_d(3);
cuad(); break;
case 0:
output_d(0);
output_low(PIN_A4); break;
}
}

while (input(PIN_C0)==1)
{
apaga();

output_low(PIN_A0);
output_high(PIN_A1);

if (input(PIN_C2)==0)
tipo_s=1;

if (input(PIN_C4)==0)
tipo_s=2;

if(input(PIN_C3)==0)
tipo_s=3;

if(input(PIN_C5)==0){
tipo_s=0;
}

output_d(tipo_s);
}

while(input(PIN_C1)==1)
{
apaga();

output_low(PIN_A0);
output_high(PIN_A1);

if(input(PIN_C3)==0){
if(tiempo<254)
tiempo++;
n=1;
}

if(input(PIN_C5)==0){
if(tiempo>0x40)
tiempo--;
else
n++;
}

if (input(PIN_C2)==0)
if(tiempo<245)
tiempo+=10;

if (input(PIN_C4)==0)
if(tiempo>0x80)
tiempo-=10;

output_d(canal|0b10100000); //Indicamos el canal en el display
retardo(4);

output_d(tipo_s|0b10110000);

retardo(6); //Indicamos el tipo de señal en el display

if(y==0){
printf("

Que desea cambiar?" Giño

;
printf("

1 -> Tipo de senal
2 -> Frecuencia
3 -> Canal de salida" Giño

;
printf("

Opcion numero: " Giño

;
}
y=1;

}
}
}

/*ARCHIVO ON_OFF.H*/

void enciende(tiempo,canal)
{
int fin=0;

enable_interrupts(INT_TIMER2);
setup_timer_2(T2_DIV_BY_1,tiempo,1);
set_timer2(0);
cont12=0;

ouput_low(PIN_A4);

switch(canal)
{
case 1:

while(fin==0)
{
if(cont12<2) //Se deja el primer paso del contador por seguridad
output_high(PIN_A4); //1º bit a 1
else
if(cont12>1&&cont12<5)
ouput_low(PIN_A4); //3 bits a 0
else
if(cont12<7)
output_high(PIN_A4); //2 bits a 1
else
{
output_high(PIN_A2); //Pulso de LOADIN
output_low(PIN_A2);
fin=1;
cont12=0;
}
}
break;

case 2:

while(fin==0)
{
if(cont12<2) //Se deja el primer paso del contador por seguridad
output_low(PIN_A4); //1º bit a 0
else
if(cont12==2)
ouput_high(PIN_A4); //2º bit a 1
else
if(cont12>2&&cont12<5)
output_low(PIN_A4); //2 bits a 0
else
if(cont12<7)
ouput_high(PIN_A4); //2 bits a 1
else
{
output_high(PIN_A2); //Pulso de LOADIN
output_low(PIN_A2);
fin=1;
cont12=0;
}
}
break;

case 3:

while(fin==0)
{
if(cont12<3) //Se deja el primer paso del contador por seguridad
output_low(PIN_A4); //2 bits a 0
else
if(cont12=3)
ouput_high(PIN_A4); //3º bit a 1
else
if(cont12==4)
output_low(PIN_A4); //1 bit a 0
else
if(cont12<7)
ouput_high(PIN_A4); //2 bits a 1
else
{
output_high(PIN_A2); //Pulso de LOADIN
output_low(PIN_A2);
fin=1;
cont12=0;
}
}
break;

case 4:

while(fin==0)
{
if(cont12<4) //Se deja el primer paso del contador por seguridad
output_low(PIN_A4); //3 bits a 0
else
if(cont12==4)
ouput_low(PIN_A4); //4º bit a 0
else
if(cont12<7)
output_high(PIN_A4); //2 bits a 1
else
{
output_high(PIN_A2); //Pulso de LOADIN
output_low(PIN_A2);
fin=1;
cont12=0;
}
}
break;
}
}

void apaga()
{
disable_interrupts(INT_TIMER2);
cont12=0,cont64=0;
}

Título: RE: Ejemplitos en C para 16F648A
Publicado por: andresitovv en 04 de Noviembre de 2005, 08:55:00

Se me olvidaba decir que la variable q me da el problema es cont12. Gracias!!

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 05 de Noviembre de 2005, 07:00:00

Buenas!!!haber no tengo tiempo para probarlo ya que estoy de un lado para el otro haber si cuando me siente con tiempo lo compruebo....decirte que puedes poner archivos .h tantos como quieras a priori, es mas, si haces un programa largo lo ideal es que estructures el codigo mediante librerias(mediante .h) por lo tanto, si es bastante largo y debes utilizar mas de una variable global, define un archivo .h que solamente tenga las variables globales, despues si usas mas de una interrupcion, crea un archivo .h que solo tenga las interrupciones y asi igual con todo, vamos que al final solo te quede el codigo del main y muchos includes, asi tendras un codigo perfectamente estructurado...haber si este lunes o martes pongo un ejemplo de prueba.....Suerte!!! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 05 de Noviembre de 2005, 07:04:00

Bueno estaba apunto de cerrar el post y el puntero del raton se quedo en esta instruccion de la funcion void enciende(tiempo,canal):

Codigo:

case 3: 

while(fin==0) 
{ 
if(cont12<3) //Se deja el primer paso del contador por seguridad 
output_low(PIN_A4); //2 bits a 0 
else 
if(cont12=3) 
ouput_high(PIN_A4); //3º bit a 1 
else 
......

Cuidado...la comprobacion debe ir con doble igual: if(cont12==3) okis???
Suerte!!! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: andresitovv en 06 de Noviembre de 2005, 08:47:00

Muchas gracias por tu tiempo. Sí, eso me di cuenta el otro día, soy un pokito despistao programando. Me di cuenta porque cuando cambiaba de canales y pasaba por el tercero la cosa no iba bien. Mi único problema era q una variable global definida en main.c no podía utilizarla luego en un archivo.h., pero me he dado cuenta que para solucionarlo solo tengo q incluir #include "main.c" en el archivo.h, creo, voy a probar. Mi problema ahora es q cuando compilo se me abre el archivo 18f452.h y me dice: "can not change device type this far into the code". He probado muchas cosas y no sé como quitarlo!! Gracias!!!

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 06 de Noviembre de 2005, 14:35:00

Buenas!!!haber si te miras la help del compilador CCS veras que dicho error es porque pones la definicion del dispositivo despues de generar el codigo, vamos despues de compilarlo, entonces para solucionarlo, debes poner el include del PIC en el primer archivo del proyecto asi ya estara definido para todo el programa. Antes de incluir el main.c en el include prueba a crear una libreria donde solamente declares las funciones globales a utilizar y despues incluyelas en el programa principal asi sera menos lioso y mas estructurado. Suerte!!! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 07 de Noviembre de 2005, 01:34:00

Buenas!!!bien el ejemplito de hoy consiste en manejar igualmente que el programa anterior el modulo CCP1 en modo PWM, pero en vez de ser constante como el anterior a 50% la anchura de pulso, se ha programado para que sea variable a 50% y al 75%, tambien este programa pretende aparte de manejar dicho modulo, la utilizacion y creacion de archivos .h, los cuales haran que el programa principal main este mas estructurado en tema codigo:

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"05
//                   6/Noviembre/05
//
//   Programa:   Uso del CCP1 como PWM al 50% y 75%
//   Version:   1.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.236
//   Entorno IDE: MPLAB IDE v7.22      Simulador:    Proteus 6.7sp3
//
//   Notas: Usamos el modulo CCP1 como PWM, para ello configuramos el TMR2 de sus tres
//       formas distintas mediante el preescales(1,4,16) que nos dara distintas frecuencias.
//       El ciclo viene determinado por (1/clock)*4*t2div*(periodo+1), donde en este caso
//       clock=4MHz y periodo=127.
//       Frecuencias:
//             ·T2_DIV_BY_1 -> 128us -> 7,81KHz
//             ·T2_DIV_BY_4 -> 512us -> 1,95KHz
//             ·T2_DIV_BY_16 -> 2,05ms -> 487,8Hz
//       La anchura de pulso en nivel alto depende de la relacion valor*(1/clock)*t2div donde
//       valor=%nivel alto del pulso.
//       Anchura del pulso(Duty):
//         *Para 50%:
//            ·128us -> 64us -> 64us/(1*(1/4000000)) = 256
//            ·512us -> 256us -> 256us/(4*(1/4000000)) = 256
//            ·2,05ms -> 1,02ms -> 1,02ms/(16*(1/4000000)) = 256
//         *Para 75%:
//            ·128us -> 96us -> 96us/(1*(1/4000000)) = 384
//            ·512us -> 384us -> 384us/(4*(1/4000000)) = 384
//            ·2,05ms -> 1,54ms -> 1,54ms/(16*(1/4000000)) = 384
//       Este programa tambien ha pretendido abarcar como crear archivos .h para
//       que dicho codigo sea mas estructurado.
//       Conexiones:      B0 -> E
//                     B1 -> RS
//                     B2 -> RW
//                     B4 -> D4
//                     B5 -> D5
//                     B6 -> D6
//                     B7 -> D7
//                     B3 -> Canal 1 osciloscopio
//                     A0 -> Boton
//////////////////////////////////////////////////////////////////////////////////

#include <16f648a.h>            //pic a utilizar
#include<vs_fuses&demas.h>         //libreria manejo fuses
#define use_portb_lcd TRUE         //definir portb lcd
#include<lcd.c>                  //libreria manejo lcd
#include<vs_variables_globales.h>      //libreria manejo de funciones
#include<vs_funciones.h>            //libreria manejo de variables

///PROGRAMA
void main(void)
{
   setup_ccp1(CCP_PWM); //ccp1 modo PWM

   lcd_init();            //inicializa lcd

   cambia_frec( );      //muestra primera frec
   cambia_duty( );      //muestra primer ancho de pulso

   for( ; ; ){      //bucle...
      if(!input(PIN_A0)){            //¿se ha pulsado el boton?
         do{                     //SI -> eliminar...
         }while(!input(PIN_A0));      //...rebotes del boton
         opcion++;               //apunta a siguiente frec
         if(opcion>2)            //¿ya se han mostrado todas las frec?
            opcion=0;            //SI -> resetea opcion
         cambia_frec( );      //cambia frecuencia
         }

      if(!input(PIN_A1)){            //¿se ha pulsado el boton?
         do{                     //SI -> eliminar...
         }while(!input(PIN_A1));      //...rebotes del boton
         duty++;               //apunta a siguiente frec
         if(duty>1)            //¿ya se han mostrado todas las anchuras de pulso?
            duty=0;            //SI -> resetea duty
         cambia_duty();      //cambia anchura pulso
         }
      }         //...infinito
}

Suerte!!! :wink:

Título: RE: Ejemplitos en C para 16F648A
Publicado por: andresitovv en 07 de Noviembre de 2005, 02:43:00

Gracias, pero como te dije habia ya investigado y nada. Aunque en el primer archivo ponga #include <18F452.h> luego al compilar se me abre el 18F452.h y me da el error ese. Si pongo lo de #device 18F452 en el primer archivo sino lo quito del 18F452.h me dice lo mismo. Total, que lo quité lo de #device del .h y se vuelve abrir diciendo que necesita una directiva device antes. He probado mil formas (incluyendo archivos, haciendo includes, poniendo muchos #device...), pero no tengo manera, siempre hay un error. Prueba verás... simplemente intenta utilizar una variable global en distintos archivos y si te funciona me pasas el código!! Por supuesto probé lo de hacerlo todo ordenadito creando las variables goblales y directivas en un .h. Gracias!!

Título: RE: Ejemplitos en C para 16F648A
Publicado por: andresitovv en 07 de Noviembre de 2005, 02:44:00

Puede ser porque tenga mucho código en un solo archivo? Se me olvidaba decir que utilizo la versión 3.187 del CCS. Gracias!!

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 07 de Noviembre de 2005, 05:21:00

Haber....lo de utilizar una variable global en muchos archivos pues en el ultimo ejemplo(el 46 creo) hay declaradas dos variables globales que se utilizan tanto en el programa principal main y despues en la libreria vs_funciones.h, haber si el problema va ser el orden en el main, es decir, el primer include que hagas debe ser las variables globales, despues vendrian las funciones(que pueden o no utilizar dichas variables) y asi seguido....a mi el programa numero 46 que lo he realizado mediante librerias no me ha dado problema, miratelo! y ya me cuentas, con respecto a la version, yo uso ahora la 3.236 pero vamos que desde la 3.227 que es la primera version que yo use no he tenido problemas en temas de crear y utilizar librerias....Suerte!!! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: andresitovv en 08 de Noviembre de 2005, 02:27:00

Pues al final lo he resuelto!! Los ejemplitos no me han servido mucho, pero gracias por los ánimos y los suerte!! Es que cuando hay 4 o 5 archivos.h y todos se necesitan entre ellos no es fácil compilar con el tema de los #include"s. Le tuve que dar muchas vueltas!! Gracias y ciao. Si a alguien le interesa que lo ponga todo...aunq es un poco largo.

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 08 de Noviembre de 2005, 08:35:00

Supongo que tu error estaba en el orden de declaracion de los includes....bueno de todas formas me alegro de que lo solucionaras!!! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 08 de Noviembre de 2005, 09:00:00

Buneasss!!!Bien el ejemplito de hoy trata de como insertar codigo ASM en nuestro programa en C. Normalmente dicho codigo en ASM se hace para temporizaciones muy finas, en este caso lo usaremos para gobernar el programa. Dicho programa realiza la iluminacion sucesiva de 4 led"s mediante un decodificador, en ASM se ha programado como manejar la variable cont para dar la instruccion a que led encender, el programa tambien realiza a la vez, la cuenta ascendente de un numero bcd 0a9 mediante un bcd-7seg, esta vez el codigo ASM se encarga de todo tanto de la variable como de mostrarlo por pantalla....bueno no me enrrollo mas!!!jeje aqui el programa:

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"05
//                   8/Noviembre/05
//
//   Programa:   Led"s & display 7seg andodo comun
//   Version:   0.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.236
//   Entorno IDE: MPLAB IDE v7.22      Simulador:    Proteus 6.7sp3
//
//   Notas: Este programa muestra como incorporar codigo ASM en nuestro programa en C.
//       Los modulos en asm manejan lso perifericos(uno es una barra de led"s, se
//       iluminan hasta 4 led"s de forma consecutiva y vuelta a empezar, y el otro
//       maneja un contador ascendente bcd de 0a9 y vuelta a empezar). Se usa los
//       perifericos decodificador 4555 y bcd-7seg 74247.
//       Conexiones:      A0 -> A 4555 DEC
//                     A1 -> B 4555 DEC
//                     B4 -> A 74247
//                     B5 -> B 74247
//                     B6 -> C 74247
//                     B7 -> D 74247
//////////////////////////////////////////////////////////////////////////////////

#include <16f648a.h>               //pic a utilizar
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP      //ordenes para el programador
#fuses INTRC                     //oscilador interno
#use delay (clock=4000000)            //Fosc=4Mhz
#use fast_io(a)
#use fast_io(b)
#byte PORTB=0x06                  //definicion del PORTB
#byte STATUS=0x03                  //definicion del STATUS

///PROGRAMA
void main(void)
{
   char cont=0;         //definicion de...
   signed char bcd=-1;      //...variables

   set_tris_a (0x00);      //porta salida
   set_tris_b (0x00);      //portb salida

   for( ; ; ){   //bucle...
      output_a(cont);      //enciende led correspondiente

      #asm            //modulo asm para manejar bcd->7seg
      movlw   1         ;w <- 1
      addwf   bcd,1      ;bcd <- w + bcd
      movf   bcd,0      ;w <- bcd
      sublw   10         ;10- w
      btfsc   STATUS,2   ;¿se ha llegado a 9?
      goto   igual      ;SI->ve a igual
      swapf   bcd,0      ;NO: w <- parte alta bcd
      goto   muestra      ;ve a muestra
igual:
      movlw   0         ;w <- 0
      movwf   bcd         ;bcd <- w
muestra:
      movwf   PORTB      ;PORTB <- w
      #endasm            //fin modulo asm para manejar bcd->7seg

      delay_ms(450);

      #asm            //modulo asm para manejar led"s
      movlw   1         ;w <- 1
      addwf   cont,1      ;cont <- w + cont
      #endasm          //fin modulo asm para manejar led"s

      if(cont>3)         //¿se ha mostrado el ultimo led?
         cont=0;         //SI-> reset cont
      }      //...infinito
}

Los perifericos que utilizamos, sus data sheet son:
Para el decodificador 4555:
http://pdf.alldatasheet.com/datasheet-pdf/view/26919/TI/CD4555BE.html
Para el bcd/7seg 74247:
http://pdf.alldatasheet.com/datasheet-pdf/view/27400/TI/SN74247N.html
Hasta pronto!!! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 08 de Noviembre de 2005, 09:03:00

Desde este enlace os podeis descargar lo necesario para el programa anterior: C & ASM

PD: Recordar que muchas veces si queremos hacer temporizaciones finas o simplemente ahorrar algo de kb"s de codigo en el .HEX es interesante y necesario incorporar dichas sentencias de codigo en ASM

Suerte!!! :wink:

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 15 de Noviembre de 2005, 08:05:00

Buenas!!!!bien, el programa de hoy se basa en las interrupciones producidas al cambio de estado por uno de los pines del portb dedicados a dicha tarea, los pines que generan interrupcion son <4:7>. El programa en si realiza la secuencia de luces del coche fantastico con 4 led"s hasta que uno de los pines <4:7> cambia de estado del port b, entonces genera una interrupcion y realiza una secuencia de iluminacion de los led"s distinta, aparte cada vez que estemos en una interrupcion se iluminara el led conectado al pin b0....bueno aqui el codigo!:

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"05
//                   15/Noviembre/05
//
//   Programa:   Interrupcion debido a cambio de estado del portb <4:7>
//   Version:   0.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.236
//   Entorno IDE: MPLAB IDE v7.22      Simulador:    Proteus 6.7sp3
//
//   Notas: Este programa muestra como funciona la interrupcion de cambio de estado de
//       algunos de los pines <4:7> del portb. Mientras no se pulse ningun boton,
//       ilumina 4 led"s de forma consecutiva y viceversa, cuando se produce un
//       cambio de estado en algunos de los pines del port b <4:7> genera interrupcion.
//       Se ha programado de tal forma que sepa diferenciar que pin genera la interrupcion.
//       Interrupcion:
//                     B4 -> Se produce la secuencia de iluminacion 1 vez
//                     B5 -> Se produce la secuencia de iluminacion 2 veces
//                     B6 -> Se produce la secuencia de iluminacion 3 veces
//                     B7 -> Se produce la secuencia de iluminacion 4 veces
//       Conexiones:      A0 -> led
//                     A1 -> led
//                     A2 -> led
//                     A3 -> led
//                     B0 -> led
//                     B4 -> boton
//                     B5 -> boton
//                     B6 -> boton
//                     B7 -> boton
//////////////////////////////////////////////////////////////////////////////////

#include <16f648a.h>               //pic a utilizar
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP      //ordenes para el programador
#fuses INTRC                     //oscilador interno
#use delay (clock=4000000)            //Fosc=4Mhz
#use standard_io(a)
#use fast_io(b)
#byte port_b=0x06                  //declaracion del puerto b

///DECLARACION DE FUNCIONES GLOBALES
void led(void);      //funcion que ejecuta la iluminacion del porta dada la interrupcion

///DECLARACION DE VARIABLES GLOBALES
int last_b;         //variable de almacenar el estado del portb

///LLAMADA FUNCION INTERRUPCION
#INT_RB
void IntPortB4_7( )
{
   char cont=0;            //contador para la iluminacion de la interrupcion
    byte changes;             //variable que almacena que pin a realizado la interrupcion

    output_high(PIN_B0);      //indicador interrupcion on

    changes = last_b ^ port_b;   //changes<-pin que genera la interrupcion

    last_b = port_b;         //last_b=como estaba el portb antes de interrupcion

    if (bit_test(changes,4 )&& !bit_test(last_b,4))      //¿PIN_B4 genera interrupcion?
      led( );                                 //SI -> ejecuta 1 vez funcion led()
if (bit_test(changes,5)&& !bit_test (last_b,5)){   //¿PIN_B5 genera interrupcion?
      do{                                    //SI -> ejecuta 2 veces funcion led()
         led( );
         cont++;
         }while(cont<2);
      }
if (bit_test(changes,6)&& !bit_test (last_b,6)){   //¿PIN_B6 genera interrupcion?
      do{                                    //SI -> ejecuta 3 veces funcion led()
         led( );
         cont++;
         }while(cont<3);
      }
if (bit_test(changes,7)&& !bit_test (last_b,7)){   //¿PIN_B7 genera interrupcion?
      do{                                    //SI -> ejecuta 4 veces funcion led()
         led( );
         cont++;
         }while(cont<4);
      }

   cont=0;            //reset variable cont
   output_low(PIN_B0);   //indicador interrupcion off
}

///PROGRAMA
void main(void)
{
   char led_on=0b0001;            //led a iluminar

   set_tris_b (0b11111110);      //portb entrada menos pin B0 es salida

   enable_interrupts(int_rb);      //activar interrupcion rb4:7
   enable_interrupts(GLOBAL);      //activar interrupciones

   do{                        //bucle...

      do{      //iluminacion hacia izquierda
         output_a(led_on);
         rotate_left(&led_on,1);
         delay_ms(300);
         }while(bit_test(led_on,3)==0);

      do{      //iluminacion hacia derecha
         output_a(led_on);
         rotate_right(&led_on,1);
         delay_ms(300);
         }while(bit_test(led_on,0)==0);
      last_b = input_b( );
      }while(TRUE);            //...infinito
}
///FUNCION QUE EJECUTA LA SECUENCIA DE ILUMINACION DEBIDO A INTERRUPCION POR EL PORTB4:7
void led(void)
{
   signed char i;               //variable indice
   int leds[2]={0b1001,0b0110};    //led"s

   for(i=0;i<2;i++){            //led"s on fuera-dentro
         output_a(leds[ i ]);      //ilumino led"s correspondientes
         delay_ms(150);
         }
      for(i=1;i>-1;i--){         //led"s on dentro-fuera
         output_a(leds[ i ]);      //ilumino led"s correspondientes
         delay_ms(150);
         }
}

Decir, que en este ejemplo se ha programado de tal manera que podamos saber que pin genero la interrupcion, segun sea el pin la secuencia de luces de interrupcion se repetira mas o menos veces hasta terminar y volver al programa principal. La parte del codigo para averiguar el pin que genero la interrupcion esta en la ayuda del compilador(CCS) asi no se pierde tiempo en crear otro....bueno hasta la proxima!!! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 15 de Noviembre de 2005, 08:07:00

Desde este enlace os podeis descargar lo necesario del ejemplo anterior: Interrupciones de los pines del portb <4:7>

Ya keda menos para navidad!!! :wink:

Título: RE: Ejemplitos en C para 16F648A
Publicado por: ElRival en 18 de Noviembre de 2005, 12:38:00

Hola a todos !! Tengo una duda, en el ejemplo de "hola mundo" con la pantalla LCD, si tenemos el pic16f877, se haría todo igual ? Y los pines que nos sobran del LCD,que hacemos con ellos ? me refiero a que en el programa pone las conexiones que hay que hacer, pero a mi me sobran pines, los pondría a masa o a Vcc ???

Gracias !!

Título: RE: Ejemplitos en C para 16F648A
Publicado por: migsantiago en 19 de Noviembre de 2005, 07:49:00

Los 4 pines que sobran de la LCD siempre los conecto a tierra. Divertido

La librería lcd.c usa comunicación de 4bit con la LCD.

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 20 de Noviembre de 2005, 14:33:00

Ke tal!!!seria todo igual pero en vez de poner el include del pic #include<16f648a> se pondria el pic a utilizar.

Suerte!!! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: lovando en 21 de Noviembre de 2005, 18:25:00

Hola a todos

Una pregunta, especialmente para el MASTER del 648, vszener..

He estado diseñando un datalogger, usando el PCWH 3.236...(el ultimo es el 3.237)...y me ha dado varios problemas con los numeros float

ejemplo:

printf("Channel 0: %01.2f", valor):

el resultado es una infinidad de ceros antes que el valor deseado

"000000000000000000000000000000000000000000001,2"

Sin embargo, con la version 3.227 y anteriores, el mismo codigo responde de maravillas

"1.2".

No se si alguine ha tenido este mismo problema:

De antemano muchas gracias

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 22 de Noviembre de 2005, 10:48:00

Ke tal piclutor!!!jeje gracias por lo de MASTER....haber primero hay que tener claro para que sirven poner delante del tipo de datos esos numeros, el formato ante un printf por lo general en C es el siguiente:

Codigo:

% [flag] [anchura] . [precision] [h/l] tipo

donde:

Codigo:

flag: Signo que se añade para digamos, ajustar el dato a representar
        ·Sin flag -> Se ajusta a la derecha
        ·Con flag -> Se ajusta a la izquierda
        ·+ o - -> Escribe el signo

anchura: Numero entero que indica el ancho minimo del campo utilizado para
               representar el valor. Si este valor es menor que el campo se completa
               éste con espacios en blanco por la izquierda y si es mayor se ignora
               el tamaño del campo.

precision: Indica el numero de digitos que se utilizaran para representar la parte
                fraccionaria.

Con las definiciones por delante, si tu quieres representar el numero valor=1,2 deberas configurar el printf de esta manera:

Codigo:

printf("Channel 0: %2.1f", valor);

En la anchura pones 2 ya que el numero entero de caracteres a representar son dos(1,2 son dos numeros, el 1 y el 2) y en la precision pones 1 ya tu numero solo contiene una cifra decimal.
En la anchura pon siempre como minimo 2, tu en tu pregunta y tu programa has puesto como anchura 1, ¿eso que significa a nivel de representacion del dato? pues segun las definiciones anteriores, tu dato por pantalla mostrado solo podra tener un numero, en teoria te deberia salir el 1 simplemente(ya que valor=1,2) pero parece ser que el compilador no deja y muestra en totalidad el numero float.
Decir que es logico ya que la configuracion 1.2 no se puede realizar tal cual ya que tu mismo en la anchura=1 estas obligando a que no haya decimales por lo tanto la precision=2 sobra, deberia, como las otras versiones del CCS que tu has provado, mostrar el numero tal cual, ya que la definicion dice que si la anchura no corresponde con la del dato se ignora el campo configurado(en la version 2.236 parece que para anchuras de 1 no lo ignora....)..asi que en resumen!jeje, decir que tienes mal definida la anchura, debes poner minimo 2! prueba con la configuracion que te he puesto y ya me cuentas!en PROTEUS funciona bien!

Suerte!!! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: MGLSOFT en 22 de Noviembre de 2005, 17:10:00

Creo que Piclutor tiene razon, Vszener.
Segun CCS las versiones tienen los siguientes cambios:

3.232 printf %f now puts a leading 0 for numbers less than 1
3.232 A number of new example files have been added
3.232 A limit on the number of #rom directives has been removed
3.233 A problem with #ZERO_RAM on parts with 4K of RAM is fixed
3.233 The %f, %w and %g formats have been adjusted to be more consistant
3.233 %w now accepts signed numbers
3.234 Still more %f adjustments. It should now solve everyones problems.
3.234 More return results added to RESTART_CAUSE() for many chips
3.235 A PIC18 optimization problem has been fixed
3.235 An ADC problem with 16C774 like chips is fixed
3.235 An undeserved syntax error involving forward structure declarations is fixed
3.235 A problem with high priority interrupts on some chips is fixed
3.235 Problems with setup_wdt() and setup_oscillator on some new chips is fixed
3.235 The compiler now tolerates a .PJT file that is marked read-only
3.235 Extra, non-applicable information in errors and warnings has been removed
3.235 PCW now highlights INT8 properly
3.236 restart_cause() problems on some PIC16 parts is fixed
3.236 Some list file and coff file generation changes made to support the upcomming linker
3.236 A PCB optimization problem with write_bank() is fixed
3.237 The EXTERN qualifier is now implemented, if your code uses EXTERN see the readme.txt
3.237 Left justification has been added to %f, use %x.yf where x<=y to get left justification3.238 Fixed a problem where some users were getting an undeserved file mis-match error
3.239 Resolved some problems with the power PWM initialization
3.239 Some menu items grayed out in the PCW IDE are fixed

Título: RE: Ejemplitos en C para 16F648A
Publicado por: lovando en 22 de Noviembre de 2005, 18:21:00

Escrito originalmente por vszener
Ke tal piclutor!!!jeje gracias por lo de MASTER....haber primero hay que tener claro para que sirven poner delante del tipo de datos esos numeros, el formato ante un printf por lo general en C es el siguiente:
Codigo:

% [flag] [anchura] . [precision] [h/l] tipo
donde:
Codigo:

flag: Signo que se añade para digamos, ajustar el dato a representar
        ·Sin flag -> Se ajusta a la derecha
        ·Con flag -> Se ajusta a la izquierda
        ·+ o - -> Escribe el signo

anchura: Numero entero que indica el ancho minimo del campo utilizado para
               representar el valor. Si este valor es menor que el campo se completa
               éste con espacios en blanco por la izquierda y si es mayor se ignora
               el tamaño del campo.

precision: Indica el numero de digitos que se utilizaran para representar la parte
                fraccionaria.
Con las definiciones por delante, si tu quieres representar el numero valor=1,2 deberas configurar el printf de esta manera:
Codigo:

printf("Channel 0: %2.1f", valor);
En la anchura pones 2 ya que el numero entero de caracteres a representar son dos(1,2 son dos numeros, el 1 y el 2) y en la precision pones 1 ya tu numero solo contiene una cifra decimal.
En la anchura pon siempre como minimo 2, tu en tu pregunta y tu programa has puesto como anchura 1, ¿eso que significa a nivel de representacion del dato? pues segun las definiciones anteriores, tu dato por pantalla mostrado solo podra tener un numero, en teoria te deberia salir el 1 simplemente(ya que valor=1,2) pero parece ser que el compilador no deja y muestra en totalidad el numero float.
Decir que es logico ya que la configuracion 1.2 no se puede realizar tal cual ya que tu mismo en la anchura=1 estas obligando a que no haya decimales por lo tanto la precision=2 sobra, deberia, como las otras versiones del CCS que tu has provado, mostrar el numero tal cual, ya que la definicion dice que si la anchura no corresponde con la del dato se ignora el campo configurado(en la version 2.236 parece que para anchuras de 1 no lo ignora....)..asi que en resumen!jeje, decir que tienes mal definida la anchura, debes poner minimo 2! prueba con la configuracion que te he puesto y ya me cuentas!en PROTEUS funciona bien!

Suerte!!!

Gracias por la respuesta.

La verdad que he probado varias opciones, incluso aumente la precision a 4.
Respecto de el ancho, 01 esta bien, puesto que si el valor es menor que 1 (0,3 por ejemplo), la representacion usará el 0, eliminando la parte entera....

No me parece eso de que el 2 de precision no sirva, puesto que tiene que ver con los decimales, no con los enteros, que estan antes de la coma....

Ahora, el "valor deseado" 1,2 solo es un ejemplo...el resultado del calculo puede dar cualquier valor entero de 1 digito, y decimales de los que se deseen...

Bueno..gracias de todas maneras....seguire usando la 3.227...

Chavela...

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 24 de Noviembre de 2005, 05:11:00

Haber la precision .2 vale siempre y cuando la anchura este bien definida(la anchura comprende todo el numero a representar) por eso si pones una anchura menor lo que supuestamente deberia hacer es ignorar tanto la anchura como la precision y representar el dato tal cual(esta version del compilador como bien señalo el amigo MGLSOFT tiene ese error, hace cosas extrañas) y lo dije en el anterior post que esta version no lo ignora:

Codigo:

...ya que la definicion dice que si la anchura no corresponde con la del dato se ignora el campo configurado(en la version 2.236 parece que para anchuras de 1 no lo ignora....)..

Bueno....de todas formas haber si en la proxima version del CCS arreglan el problema... Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: garlic_74 en 24 de Noviembre de 2005, 06:27:00

Soy novato con proteus y no hay forma de vincularle el CCS Enfurruñado

no puedo hacer rular el codigo k posteais

un saludo Muchas risas

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 25 de Noviembre de 2005, 05:08:00

Y aqui el enlace a la pagina directa donde te lo explican [MANUAL] Integrar CCS en PROTEUS (http://www.todopic.com.ar/foros/index.php?topic=12184.0)

Suerte!!! :wink:

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 27 de Noviembre de 2005, 11:01:00

Ke tal!!!bien, quizas el error de ese ejemplo sea las direcciones de memoria de la epprom, es decir, cada vez que escribimos no tenemos en cuenta la anchura de la palabra del dato a escribir y por eso se sobre-escriba, haber si me veo el data sheet de la memoria eeprom y lo corrigo y ya te digo! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: garlic_74 en 27 de Noviembre de 2005, 15:48:00

bueno eso k dices yo tambien me lo preguntaba, pero lo bueno es k se lee de lujo, no entiendo como puede ir si en teoria estamos reescribiendo en las posiciones de memoria.

Tampoco entiendo porque al sacar la eeprom en frio y leerla con un programador, no hay forma de ver lo k se ha escrito. Siempre leo cosas que escribi directamente con el programador (t-20).

un saludo

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 18 de Diciembre de 2005, 12:45:00

Ummmm se que es tarde para contestar, pero ayer lo probe y a mi si me funciona.... Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 19 de Diciembre de 2005, 09:30:00

Ke tal!!!bien decir, que Microchip ha sacado una nueva version de su IDE MPlab, es la version 7.30, la podeis descargar desde este enlace:
http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=1406&dDocName=en019469&part=SW007002

PD: Indice mejorado, se ha añadido herramientas de trabajo.

Suerte y Feliz Navidad!!! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 23 de Diciembre de 2005, 06:17:00

Buenas!!!!bien, viendo el trabajo que estan haciendo mis compañeros de enseñar a utilizar basic y proteus para pic"s y para atmel(que la verdad esta muy bien aqui el link: EJEMPLITOS DE BASCOM AVR... ATMEGA8.. (http://www.todopic.com.ar/foros/index.php?topic=8108.0) ) he visto que tienen programas de manejos de matrices de led"s asi que me ha dado pequeña envidia(envidia buena claro esta jeje) y me he dicho: "¿porque en c no hay esos programas"? bueno pues aqui uno muy simple, tratamos una matriz 5x7 y enseñamos por ella el abecedario:

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"05
//                   19/Diciembre/05
//
//   Programa:   Abecedario en matrices de led"s 5x7
//   Version:   0.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.236
//   Entorno IDE: MPLAB IDE v7.30      Simulador:    Proteus 6.7sp3
//
//   Notas: Este programa muestra por el abecedario en una matriz de led"s 5x7.
//       En las columnas se usa un decodificador 4028 para hacer su barrido
//       Conexiones:      A0 -> A 4028 DEC
//                     A1 -> B 4028 DEC
//                     A2 -> C 4028 DEC
//                     A3 -> D 4028 DEC
//                     B0 -> Fila 1 matriz 5x7
//                     B1 -> Fila 2 matriz 5x7
//                     B2 -> Fila 3 matriz 5x7
//                     B3 -> Fila 4 matriz 5x7
//                     B4 -> Fila 5 matriz 5x7
//                     B5 -> Fila 6 matriz 5x7
//                     B6 -> Fila 7 matriz 5x7
//////////////////////////////////////////////////////////////////////////////////

#include <16f648a.h>               //pic a utilizar
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP      //ordenes para el programador
#fuses INTRC                     //oscilador interno
#use delay (clock=4000000)            //Fosc=4Mhz
#use fast_io(a)
#use fast_io(b)

///DEFINICION VARIABLES GLOBALES
int letra[5],opcion=0;

///LLAMADA FUNCION INTERRUPCION
#INT_TIMER1
void interrupcion()
{
   switch(opcion){   //selecciona letra
      case 0:   letra[0]=0b00000001;   //A
            letra[1]=0b01110110;
            letra[2]=0b01110110;
            letra[3]=0b01110110;
            letra[4]=0b00000001;
            opcion++;
            break;
      case 1:   letra[0]=0b01001001;   //B
            letra[1]=0b00110110;
            letra[2]=0b00110110;
            letra[3]=0b00110110;
            letra[4]=0b00000000;
            opcion++;
            break;
      case 2:   letra[0]=0b00111110;   //C
            letra[1]=0b00111110;
            letra[2]=0b00111110;
            letra[3]=0b00111110;
            letra[4]=0b01000001;
            opcion++;
            break;
      case 3:   letra[0]=0b01000001;   //D
            letra[1]=0b00111110;
            letra[2]=0b00111110;
            letra[3]=0b00111110;
            letra[4]=0b00000000;
            opcion++;
            break;
      case 4:   letra[0]=0b00111110;   //E
            letra[1]=0b00110110;
            letra[2]=0b00110110;
            letra[3]=0b00110110;
            letra[4]=0b00000000;
            opcion++;
            break;
      case 5:   letra[0]=0b01111110;   //F
            letra[1]=0b01110110;
            letra[2]=0b01110110;
            letra[3]=0b01110110;
            letra[4]=0b00000000;
            opcion++;
            break;
      case 6:   letra[0]=0b01001110;   //G
            letra[1]=0b00110110;
            letra[2]=0b00110110;
            letra[3]=0b00111110;
            letra[4]=0b01000001;
            opcion++;
            break;
      case 7:   letra[0]=0b00000000;   //H
            letra[1]=0b01110111;
            letra[2]=0b01110111;
            letra[3]=0b01110111;
            letra[4]=0b00000000;
            opcion++;
            break;
      case 8:   letra[0]=0b00111110;   //I
            letra[1]=0b00111110;
            letra[2]=0b00000000;
            letra[3]=0b00111110;
            letra[4]=0b00111110;
            opcion++;
            break;
      case 9:   letra[0]=0b01111111;   //J
            letra[1]=0b00000000;
            letra[2]=0b00111110;
            letra[3]=0b00101110;
            letra[4]=0b01001111;
            opcion++;
            break;
      case 10:   letra[0]=0b00111110;   //K
               letra[1]=0b01011101;
               letra[2]=0b01101011;
               letra[3]=0b01110111;
               letra[4]=0b00000000;
               opcion++;
               break;
      case 11:   letra[0]=0b00111111;   //L
               letra[1]=0b00111111;
               letra[2]=0b00111111;
               letra[3]=0b00111111;
               letra[4]=0b00000000;
               opcion++;
               break;
      case 12:   letra[0]=0b00000000;   //M
               letra[1]=0b01111101;
               letra[2]=0b01111011;
               letra[3]=0b01111101;
               letra[4]=0b00000000;
               opcion++;
               break;
      case 13:   letra[0]=0b00000011;   //N
               letra[1]=0b01011111;
               letra[2]=0b01101111;
               letra[3]=0b01110111;
               letra[4]=0b00000011;
               opcion++;
               break;
      case 14:   letra[0]=0b00000011;   //Ñ
               letra[1]=0b01011101;
               letra[2]=0b01101101;
               letra[3]=0b01110101;
               letra[4]=0b00000011;
               opcion++;
               break;
      case 15:   letra[0]=0b01000001;   //O
               letra[1]=0b00111110;
               letra[2]=0b00111110;
               letra[3]=0b00111110;
               letra[4]=0b01000001;
               opcion++;
               break;
      case 16:   letra[0]=0b01111001;   //P
               letra[1]=0b01110110;
               letra[2]=0b01110110;
               letra[3]=0b01110110;
               letra[4]=0b00000000;
               opcion++;
               break;
      case 17:   letra[0]=0b00000001;   //Q
               letra[1]=0b00011110;
               letra[2]=0b00101110;
               letra[3]=0b00111110;
               letra[4]=0b01000001;
               opcion++;
               break;
      case 18:   letra[0]=0b01111001;   //R
               letra[1]=0b00110110;
               letra[2]=0b01010110;
               letra[3]=0b01100110;
               letra[4]=0b00000000;
               opcion++;
               break;
      case 19:   letra[0]=0b01001110;   //S
               letra[1]=0b00110110;
               letra[2]=0b00110110;
               letra[3]=0b00110110;
               letra[4]=0b00111001;
               opcion++;
               break;
      case 20:   letra[0]=0b01111110;   //T
               letra[1]=0b01111110;
               letra[2]=0b00000000;
               letra[3]=0b01111110;
               letra[4]=0b01111110;
               opcion++;
               break;
      case 21:   letra[0]=0b01000000;   //U
               letra[1]=0b00111111;
               letra[2]=0b00111111;
               letra[3]=0b00111111;
               letra[4]=0b01000000;
               opcion++;
               break;
      case 22:   letra[0]=0b01100000;   //V
               letra[1]=0b01011111;
               letra[2]=0b00111111;
               letra[3]=0b01011111;
               letra[4]=0b01100000;
               opcion++;
               break;
      case 23:   letra[0]=0b01000000;   //W
               letra[1]=0b00111111;
               letra[2]=0b01000111;
               letra[3]=0b00111111;
               letra[4]=0b01000000;
               opcion++;
               break;
      case 24:   letra[0]=0b00111011;   //X
               letra[1]=0b01010111;
               letra[2]=0b01101111;
               letra[3]=0b01010111;
               letra[4]=0b00111011;
               opcion++;
               break;
      case 25:   letra[0]=0b01111110;   //Y
               letra[1]=0b01111101;
               letra[2]=0b00000011;
               letra[3]=0b01111101;
               letra[4]=0b01111110;
               opcion++;
               break;
      case 26:   letra[0]=0b00111100;   //Z
               letra[1]=0b00111010;
               letra[2]=0b00110110;
               letra[3]=0b00101110;
               letra[4]=0b00011110;
               opcion=0;
      }
   set_timer1(3036);            //TMR1 se desborda cada 0,5s
}

void main(void)
{
   int i;   //variable contador

   enable_interrupts(INT_TIMER1);            //interrupcion TIMER1 activada
   setup_timer_1(T1_INTERNAL|T1_DIV_BY_8);      //configuracion TMR1
   set_timer1(65535);                     //carga TMR1 para un desbordamiento inmediato
   enable_interrupts(GLOBAL);               //activadas interrupciones

   set_tris_b (0x00);      //portb salida
   set_tris_a (0x00);      //porta salida

   do{            //bucle...
      for(i=0;i<5;i++){
         output_a( i );         //columnas
          output_b(letra[ i ]);      //filas
            delay_ms(10);         //pausa para poder verse
            }
      }while(TRUE);   //...infinito
}

Bien, pues decir antes que nada, que las letras no estan realizadas en formato standard ehh!!!!jeje

PD: Felices fiestas a todos los integrantes del foro que aunque en la lejania, este medio parece algo magico ya que nos une un poquito mas.....FELIZ NAVIDAD!!! :wink:

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 23 de Diciembre de 2005, 06:21:00

Holaaa!!! bien de aqui os podeis descargar lo necesario para el ejemplo anterior: abecedario en una matriz de led"s 7x5

FELIZ NAVIDAD!!! :wink:

Título: RE: Ejemplitos en C para 16F648A
Publicado por: RaDoN en 23 de Diciembre de 2005, 07:20:00

vszener no paras tio jeje Giño

¡¡que buen trabajo!! Sonrisa Gigante

Título: RE: Ejemplitos en C para 16F648A
Publicado por: monopic en 29 de Diciembre de 2005, 12:32:00

hola amigo v zener, te recuerdas lo de la lcd 2x16 que quiero ver una grafica pues vi un ejemplo, en el foro en el que se visualiaba en la lcd los numeros pero utilizando para cada numero 2 lineas verticales y podian utilizar todas las posiciones de la lcd entonces supongo que tambien se puede,,, lo que quiero hacer es primero hacer una animacion en una cuadricula y luego de que acabe en la misma cuadricula hacer otra animacion diferente por ejemplo mostrar la bateria y luego de que este llena mostrar otra cosa,, me entiendes ,, me das una manito,,, gracias .. feliz año

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 30 de Diciembre de 2005, 09:13:00

ke tal!!! jeje gracias radon! esto de los pic"s y programarlos ya creo que se lleva e la sangre jeje

Monopic ke tal!!!haber utilizar las filas para hacer una unica animacion la verdad que no es dificil, ya sabemos usar una cuadricula simplemente tenmos que coordinar en que cuadricula escribir....intentalo y yo me pongo manos a la obra en cuanto termine las fiestas!que no tengo disponible mi ordenador y estoy en el de mi hermano que para nada tiene ningun prgrama electronico ni nada con el que trabajar.....tiene intenert de milagro...jeje

Bueno FELIZ AÑO"06 A TODOS!!!! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: mario_pastor en 11 de Enero de 2006, 20:10:00

Escrito originalmente por vszener
Buenasss jeje!!!bien, aqui otro ejmeplito mas con el periferico 7seg...ya sabemos contar desde 0 a 9, desde 9 a 0 e incluso de 0 a 9 y viceversa!!!!!vamos a seguir contando jeje esta vez aqui un ejemplito de un contador desde 00 a 99 y vuelta a empezar...aqui el programita:

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"05
//                   18/Agosto/05
//
//   Programa:   Contador del 00 al 99
//   Version:   0.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.227
//   Entorno IDE: MPLAB IDE v7.20      Simulador:    Proteus 6.7sp3
//
//   Notas: Contador del 00 al 99 cada 1s y vuelta a empezar. Tener en cuenta
//       que hay que poner la directiva NOLVP para que el pin B4 sea de salida.
//       Se utiliza variables locales:
//            * i -> indice tabla 7seg para mostrar digito por 1º 7seg
//            * j -> indice tabla 7seg para mostrar digito por 2º 7seg
//            * flag -> variable que cuenta 1s
//            * var -> ajuste fino para que desborde cada segundo
//       Utilizamos la funcion de interrupcion para actualizar indices de la
//       tabla de 7seg para mostrar el digito correspondiente en el respectivo
//       7seg, para ello el TMR0 se desborda cada 1s, para ello debe ser cargado
//       con 61(equivale a un desbordamiento cada 50ms mas o menos), para obtener
//       un desbordamiento de 1s utilizamos una variable(flag) que no entra en
//       la actualizacion de indices hasta transcurrido 1s.
//   Conexiones:
//         · RA0 -> Display 1º 7seg
//         · RA1 -> Display 2º 7seg
//         · RB0 -> a 7seg
//         · RB1 -> b 7seg
//         · RB2 -> c 7seg
//         · RB3 -> d 7seg
//         · RB4 -> e 7seg
//         · RB5 -> f 7seg
//         · RB6 -> g 7seg
//////////////////////////////////////////////////////////////////////////////////

#include <16f648a.h>            //pic a utilizar
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP      //ordenes para el programador
#use delay (clock=4000000)         //Fosc=4Mhz
#use standard_io(B)
#use fixed_io(a_outputs=PIN_A0,PIN_A1)   //A0,A1 como salidas en porta

char i=0,j=0,flag=0,var=20;   //variables globales

///LLAMADA FUNCION INTERRUPCION
#INT_TIMER0
void interrupcion()
{
   if(flag>var){      //¿ya es 1 segundo?
      var--;         //SI -> decremento var...
      if(var<18)
         var=20;      //...ajuste fino de 1s
      flag=0;         //reset flag para contar 1s
      if(i>8){      //¿se ha mostrado por 1º 7seg digito 9?
         i=0;      //SI -> i=0 (muestra digito 0) (*)
         j++;      //incremento indice j
         if(j>9){   //¿se ha mostrado por 2º 7seg digito 9?
            j=0;}   //SI -> j=0 (muestra digito 0)
            }
      else{         //(*) NO -> incrementa i
         i++;}
      }
   set_timer0(61);      //reset TMR0
   flag++;            //incremento variable flag
}

///PROGRAMA
void main(void)
{
   int tab7seg[10]={0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x67};   //7seg hex 0-9

   set_tris_b(0x00);                     //portb como salida
   enable_interrupts(INT_TIMER0);            //interrupcion TIMER0 activada
   setup_counters(RTCC_INTERNAL,RTCC_DIV_256);   //configuracion interrupcion TMR0
   set_timer0(61);                        //carga TMR0
   enable_interrupts(GLOBAL);               //activadas interrupciones

   do{                        //bucle...
      output_high(PIN_A1);      //2º 7seg off
      output_low(PIN_A0);         //1º 7seg on
      delay_ms(15);
      output_b(tab7seg[ i ]);      //muestra por portb digito 7 segmentos
      output_low(PIN_A1);         //2º 7seg on
      output_high(PIN_A0);      //1º 7seg off
      delay_ms(15);
      output_b(tab7seg[ j ]);      //muestra por portb digito 7 segmentos
      }while(TRUE);            //...infinito
}

Decir que este ejemplito es bastante curioso aparte por manejar display"s de 7 segmentos multiplexados, por utilizar el TIMER0...es decir la cuenta de 1 segundo se hace atraves del desbordamiento del TMR0.....asi ya sabeis como programar interrupciones.....

Profesor vszener Giño

tengo dudas respecto a este ejemplo, básicamente en la interrupción por TMR0 donde mencionas el ajuste fino... se que la interrupción se genera cada 50ms y que con el contador FLAG te aseguras de controlar que sea 1s. Mi pregunta es en que te basas para lo del ajuste fino Helado

Gracias por tu tiempo.

Título: RE: Ejemplitos en C para 16F648A
Publicado por: 271071 en 12 de Enero de 2006, 06:51:00

pues yo tengo las mismas dudas

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 12 de Enero de 2006, 12:28:00

Buenas!!!haber lo del ajuste fino....el ajuste fino es debido ya que el desbordamiento a efectos practicos(es decir en la vida real) no es perfecta, si programamos el timer para que se desborde y "cuente algo" en este caso segundo veremos, por lo menos en mi caso es asi, que la cuenta no es exacta y esto es debido a la llamada a la interrupcion. Hay herramientas donde podemos manejar el tiempo que tarda en ejecutarse las instrucciones(el MPlab tiene un reloj que cuenta cuanto tiempo tarda en ejecutarse lo que hayamos configurado) yo en estos programas, como todo esta simulado en PROTEUS, he realizado el ajuste fino al reloj de simulacion de PROTEUS(ya que es el entorno donde simulamos el programa), es decir, cargo el programa al pic y le doy a simular, abajo aparece el tiempo que lleva el programa ejecutandose/simulandose, de ese tiempo me he servido para hacer el ajuste fino, cualquier programa que tenga la variable o las instrucciones de "ajuste fino" estan basados en el reloj de PROTEUS de simulacion, si lo simulas veras que el programa sigue al reloj de PROTEUS por lo tanto ya tenemos la temporizacion requerida!

Para ver las diferencias del ajuste fino y sin el, simplemente eliminar dichas sentencias de codigo del "ajuste fino" y vereis que el contador no es perfecto(si hicieramos un reloj sin ajuste fino s descalibraria bastante), en cambio si simulamos con las sentencias de codigo de ajuste fino veremos que la cuenta practicamente es perfecta(si hicieramos un reloj asi veriamos que su calibracion no seria demasiado significativa)

Bueno, despues del rollo espero haber sido claro, vamos en resumen las temporizaciones no son perfectas, igual modo que en ensamblador hay instrucciones como la "nop" que no realiza nada(simplemente "perder tiempo"/ajustar temporizaciones), en estos programas de ajuste fino he ido teniendo en cuenta la tolerancia del timer ajustandolo para que su cuenta sea la mas precisa posible a la cuenta requerida.

Suerte!!! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: pelusac en 17 de Enero de 2006, 11:55:00

Que tal vszener ,solo escribo para animarte a realizar mas ejemplitos y que los cuelgue en el foro donde paso casi todo mi tiempo libre;
Me gustaria agradecerte el post que has abierto de ejemplos ya que para mi la programacion de micros era imposible hasta realizar todos los ejmplos que has puesto,creo que ya le veo color a esto. RollEyes

Asi que gracias porque tu ayuda ha sido inestimable y muy altruista ya que creo que hay muchos como yo que comen y duermen en tu post;
Bueno pues dicho esto maestro vszener haber si te animas y sigues poniendo ejemplitos que entre tu,nocturno ,redpic.....podeis hacer de esto una maravilla
Saludos de un sevillano ......viva la cerveza!!!!!!! Rebotado

Título: RE: Ejemplitos en C para 16F648A
Publicado por: monopic en 18 de Enero de 2006, 17:28:00

hola vzener a ver si me echas una manito a lo de la lcd te acuerdas la idea es hacer una animacion en una cuadricula y luego otra diferente.... gracias

Título: RE: Ejemplitos en C para 16F648A
Publicado por: YDAVID en 19 de Enero de 2006, 16:36:00

Gracias por todo esto.
¡ah¡ ¿cuales bares?

Título: RE: Ejemplitos en C para 16F648A
Publicado por: Algec en 20 de Enero de 2006, 06:44:00

Primero aunque no hace falta decirlo siquiera, enhorabuena por tu trabajo.
Me ha facilitado las cosas en multiples ocasiones.
ME atreveria a pedirte un favor, en el que creo qeu coincidimos muchos de los del foro.
Yo tenia bajado todos los ejemplos hasta que mi discu duro se averio y los perdi, eran como una libreria de referencias, que usaba para programar.
LA idea de publicarlos con enlace uno a uno me parece magnifica, pero, no habria forma de tenerlos para bajarlos todos agrupados en uno?
Se podria actualizar ese fichero facilmente añadiendo el nuevo ejemplo.
Lo que me ocurre es que bajo algo, y luego me falta algun enlace y tengo que estar ordenando ejemplos por carpetas etc, y ese trabajo que ya estaba hecho se perdio asi que estoy liado
Si fuese posible se que muchos te estaremos agradecidos

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 20 de Enero de 2006, 11:06:00

Buenas!!!!!haber, por partes:
Pelusac GRACIAS!!!!y me alegra muchisimo que ya empieces a programar, y que estos ejemplos te valgan para ello pues me alegra mucho mas!lo de seguir poniendo ejemplitos, pues si!lo malo, es que "creo" que este pic ya se nos esta quedando pequeño, pero todavia falta ver como se programan las interrupciones RS-232(aunque el amigo RedPic las tiene programadas en su post) haber si pongo un ejemplito aqui, y creo que poco mas.....me refiero a los perifericos del 16F648A, mi idea es ampliar el post y meternos de lleno con una familia superior, la familia 18(ya que la familia 24 estan ya!jeje)e ir colocando ejemplos para esta familia compilados en CCS y en el C18 de Microchip, asi realizariamos a la par un estudio tanto de comodidad como de ahorro de codigo de un compilador a otro...esa es mi idea....

monopic ke tal!!!estoy en lo tuyo, pero haber si me muestras que tienes realizado tu, o me cuelgas tu idea, yo en cuanto tenga algo de tiempo me meto manos a la obra!Pero intentalo tu haber que sale....

YDAVID GRACIAS!!!los bares???jeje cualquiera es buen recibido!jeje

Algec GRACIAS!!!con respecto agrupar todos los ejemplos y poder descargarselos todos es una idea bastante buena pero....hay dos problemas, uno es que el almacen no me deja editar mis mensajes(dice que no tengo el nivel suficiente) esto provocaria que a cada ejemplo ir escribiendo un post distinto y creo que eso no contribuiria al orden del almacen....el otro problema es que tampoco puedo subirlos todos al almacen por su "peso", creo que son 12Mb o algo asi...lo que se me ocurre es hacerlos por partes, es decir, post de tandas de ejemplos, en un post del almacen por ejemplo, tener para su descarga 5 ejemplos o los que quepe!

Y bueno, me alegra muchoentrar en este post y ver como la gente les vale de algo estos programitas que aunque parezcan tontos(y lo son!jeje) sirve para aprender a programar los distintos perifericos internos como algunos externos del pic! GRACIAS A TODOS!!!! y a seguir programando!

Suerte!!! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 20 de Enero de 2006, 11:14:00

Holaaa!!!bueno, aqui dejo un programa que se sale de la tematica de aprendizaje a programar perifericos internos del pic, pero vamos creo que es ilustrativo a la programacion del mismo y hardware, hace tiempo que pense en regalarle un reloj digital a mi niña, y bueno pue sme puse manos a la obra, el conteo y la realizacion del reloj lo realiza todo el pic, aqui el programa:

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"05
//                   29/Noviembre/05
//
//   Programa:   Reloj digital 7seg
//   Version:   0.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.236
//   Entorno IDE: MPLAB IDE v7.22      Simulador:    Proteus 6.7sp3
//
//   Notas: Reloj digital en 7seg. Se utiliza un DEC 4555 para realizar el barrido
//       de los 7seg, se usa tambien, un BCD-7Seg 4543 para la visualizacion
//       de los numeros en el 7seg. El reloj esta compuesto de 4 botones.
//       Botones:   Hora/Minutos->RB1: Cuando estemos en modo Configuracion,
//                               pasar de hora a minutos para incrementar.
//               + ->RB2: Para incrementar en una unidad el digito actual.
//               Configuracion/Ok->RB3: Si se pulsa pasamos al modo
//                               configuracion para poder actualizar
//                               la hora actual, una vez actualizada,
//                               si se pulsa pasamos al modo de reloj
//       Conexiones:      A0 -> A 4555 DEC
//                     A1 -> B 4555 DEC
//                     A2 -> 2 led"s en serie(secundero)
//                     A5 -> Boton reset(externo)
//                     B1 -> Boton Hora/Minuto
//                     B2 -> Boton +
//                     B3 -> Boton Configuracion/Ok
//                     B4 -> A 4543
//                     B5 -> B 4543
//                     B6 -> C 4543
//                     B7 -> D 4543
//////////////////////////////////////////////////////////////////////////////////

#include <16f648a.h>               //pic a utilizar
#fuses XT,NOCPD,NOWDT,NOPUT,NOLVP,NOBROWNOUT      //ordenes para el programador
#fuses INTRC                     //oscilador interno
#use delay (clock=4000000)            //Fosc=4Mhz
#use fixed_io(a_outputs=PIN_A0,PIN_A1,PIN_A2)
#use fixed_io(b_outputs=PIN_B4,PIN_B5,PIN_B6,PIN_B7)
#bit RA2=05.2                     //secundero

///DEFINICION DE FUNCIONES
void configurar(void);

///VARIABLES GLOBALES
char min1=0,min2=0,hor1=0,hor2=0;
char flag=0,var=119;                  //variables de ajuste de 1 minuto
char tab[10]={0x00,0b00010000,0b00100000,0b00110000,
      0b01000000,0b01010000,0b01100000,0b01110000,0b10000000,0b10010000};   //bcd parte alta 0-9

///LLAMADA FUNCION INTERRUPCION
#INT_TIMER1
void interrupcion()
{
   if(flag>var){               //¿Ya es 1 minuto?
      var--;                  //SI -> decremento var...
      if(var<118)
         var=120;            //...ajuste fino de 1min
      flag=0;                  //reset flag para contar 1min
      min1++;
      if(min1>9){               //¿Se ha mostrado xx:x9?
         min1=0;               //SI -> reset min1 xx:x0
         min2++;
         if(min2>5){            //¿Se ha mostrado xx:59?
            min2=0;            //SI -> reset min2 xx:00
            hor1++;
            if(hor2==2){      //¿Estamos en modo noche 2x:xx?
               if(hor1>3)      //SI -> ¿Se ha mostrado 23:59?
                  goto noche;}//SI -> ve a noche
            if(hor1>9){         //No estamos en modo noche-> ¿se ha mostrado 19:59?
noche:            hor1=0;         //SI -> reset hor1 x0:00 || noche: reset hor1 x0:00
               hor2++;
               if(hor2>2)      //¿Se ha mostrado 23:59?
                  hor2=0;      //SI -> reset hor2 00:00
               }
            }
         }
      }
   RA2=!RA2;                  //parpadeo secundero cada 0,5s
   set_timer1(3036);            //reset TMR1
   flag++;
}

///PROGRAMA
void main(void)
{
   enable_interrupts(INT_TIMER1);            //interrupcion TIMER1 activada
   setup_timer_1(T1_INTERNAL|T1_DIV_BY_8);      //configuracion TMR1
   set_timer1(3036);                     //carga TMR1 para desvordar cada 0.5s
   enable_interrupts(GLOBAL);               //activadas interrupciones

   do{            //bucle...
      output_low(PIN_A0);         //Primer 7seg...
      output_low(PIN_A1);         //...on
      output_b(tab[min1]);
      delay_ms(10);
      output_low(PIN_A1);         //Segundo 7seg...
      output_high(PIN_A0);      //...on
      output_b(tab[min2]);
      delay_ms(10);
      output_high(PIN_A1);      //Tercer 7seg...
      output_low(PIN_A0);         //...on
      output_b(tab[hor1]);
      delay_ms(10);
      output_high(PIN_A0);      //Cuarto 7seg...
      output_high(PIN_A1);      //...on
      output_b(tab[hor2]);
      delay_ms(10);
      if(!input(PIN_B3)){         //¿Se ha pulsado boton Configuracion?
         while(!input(PIN_B3)){}   //SI -> elimina rebotes pulsador...
         configurar();         //...ve a configurar
         }
   }while(TRUE);   //...infinito
}
///FUNCION QUE CONFIGURA LA HORA ACTUAL
void configurar(void){
   boolean sal=0;
   char menu=0;                  //menu=0: incremento minutos || menu=1: incremento horas
   disable_interrupts(GLOBAL);         //todas las interrupciones desactivadas
   do{
      do{
      output_a(0b00);
      output_b(tab[min1]);
      delay_ms(10);
      output_a(0b01);
      output_b(tab[min2]);
      delay_ms(10);
      output_a(0b10);
      output_b(tab[hor1]);
      delay_ms(10);
      output_a(0b11);
      output_b(tab[hor2]);
      delay_ms(10);
      if(!input(PIN_B1)){            //¿Se ha pulsado boton Horas/Minutos?
         while(!input(PIN_B1)){}
         menu=!menu;               //SI -> Cambia minutos/horas y viceversa
         }
      if(!input(PIN_B2)){            //¿Se ha pulsado boton +?
         while(!input(PIN_B2)){}
         sal=1;                  //SI -> incrementa una unidad el digito(segun variable menu)
         }
      if(!input(PIN_B3)){            //¿Se ha pulsado boton Ok?
         while(!input(PIN_B3)){}
         sal=1;                  //SI -> salir...
         menu=2;                  //...modo Configurar y mostrar hora actualizada
         }
      }while(sal==0);

      sal=0;                     //reset variable sal
      if(menu==0){               //¿Incremento digito de minutos?
         min1++;                  //SI
         if(min1>9){               //¿Se ha mostrado xx:x9?
            min1=0;               //SI -> reset min1 xx:x0
            min2++;
            if(min2>5)            //¿Se ha mostrado xx:59?
               min2=0;            //SI -> reset min2 xx:00
            }
      }
      if(menu==1){               //¿Incremento digito horas?
         hor1++;                  //SI
         if(hor2==2){            //¿Estamos en modo noche 2x:xx?
            if(hor1>3)            //SI -> ¿se ha mostrado 23:xx?
               goto night;         //SI -> ve a night
            }
         if(hor1>9){               //No estamos en modo noche->¿se ha mostrado 19:xx?
night:         hor1=0;               //SI -> reset hor1 10:xx ||modo noche: reset hor1 20:xx
            hor2++;
            if(hor2>2)            //¿Se ha mostrado 23:xx?
               hor2=0;            //SI -> reset hor2 00:xx
               }
      }
      }while(menu<2);
      enable_interrupts(GLOBAL);      //todas las interrupciones desactivadas
      set_timer1(3036);            //carga TMR1
      flag=0;                     //reset variables...
      var=119;                  //...ajuste de 1min
}

Bien decir, que este no fue el programa final que grabe en el pic....pero bueno, creo que este es mas ilustrativo a la programacion, el que finalmente grabe en el pic manejaba la hora en una variable y mediante una funcion obtenia los valores a representar.....

Ya sabemos que hora es tanto con una RTC como con este ejemplo!!!!

Suerte!!! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 20 de Enero de 2006, 11:15:00

Desde esta direccion os podeis descargar los archivos necesarios para el programa anterior: reloj digital

Suerte!!! :wink:

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 27 de Enero de 2006, 06:27:00

Buenas!!!!GRACIAS pelusac!, bueno decir que el indice se ha añadido el apartado REVISION, este apartado esta dedicado a programas anteriores mejorados, asi que para una implementacion real de cualquier programa se recomienda usar la revision si esta disponible.....

Suerte!!! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 27 de Enero de 2006, 06:31:00

Buenas!!!!aqui os dejo lo que os dije!el manejo d ela interrupcion serial!, este ejemplo sirve como revision del programa 29, el cual se encarga de la escritura y lectura de la eeprom interna del pic, en este caso de 256k, aqui el programa:

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"06
//                   23/Enero/06
//
//   Programa:   RS232 Y PIC
//   Version:   1.0 REVISION del programa 45
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.242
//   Entorno IDE: MPLAB IDE v7.30      Simulador:    Proteus 6.7sp3
//
//   Notas: Se interacciona el PC con el PIC mediante RS232 para el tratamiento de la memoria
//       eeprom interna,se muestra por v.terminal un menu:
//               · 0 -> Muestra nuevamente el menu
//               · 1 -> LLena la eeprom a 0xFF
//               · 2 -> Lee la eeprom en modo hex
//               · 3 -> Escribe en la eeprom
//               · 4 -> Lee la eeprom en modo texto(ASCII)
//       Todas las acciones se realizan mediante la interrupcion del puerto serial.
//       Al comienzo del programa, realizar el paso 1. en caso de empezar a escribir
//       en la eeprom!. Decir que las funciones gethex1() y gethex() estan sacadas
//       de la libreria incluida en CCS, input.c, estan puestas en el programa
//       por la pequeña modificacion en la funcion gethex1() que, en este caso, solo
//       permite el paso de digitos comprendidos entre 0-f o 0-F. Tener en cuenta
//       que los datos a introducir deben ser en hexadecimal, por ejmeplo, en el
//       caso de almacenar en la letra "a" minuscula en la posicion 00 de la eeprom
//       interna del pic, habra que realizar los siguientes pasos:
//             1. Pulsamos 3 para escribir en la eeprom interna
//            2. Ponemos la direccion 00 (esta en hexadecimal!)
//            3. Damos el valor en hex de la letra a=0x61
//            4. Leemos la memoria para ver que se almacenado correctamente(pulsando 2)
//       La eeprom interna del 16F648A es de 256k.
//
//   Conexiones:      B2 -> TxD
//               B1 -> RxD
//////////////////////////////////////////////////////////////////////////////////
#include <16f648a.h>                     //pic a utilizar
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP,NOBROWNOUT   //ordenes para el programador
#fuses RC_IO                           //reloj interno
#use delay (clock=4000000)                  //Fosc=4Mhz
#use rs232(baud=9600, xmit=PIN_b2, rcv=PIN_b1)   //manejo del RS232

///DECLARACION DE VARIABLES GLOBALES
boolean menu=1,opcion=1;      //si menu=0 se muestra el menu de inicio...
                        //...si opcion=1 estamos en modo direccion
                        // opcion=0 estamos en modo dato

///DECLARACION DE FUNCIONES
BYTE gethex1( );      //verifica que esta dentro del rango y muestra por pantalla
BYTE gethex( );      //devuelve el numero en hex

///LLAMADA FUNCION INTERRUPCION
#int_rda
void rs232()
{
   BYTE i=0,j=0,address,value;         //definicion...
   char digito;               //...variables

   disable_interrupts(global);      //apago interrupcion

   digito=getc();               //almaceno dato serial(rs232) en digito

   puts("
****************************************************" );

   switch(digito){
      case "0":      menu=!menu;                  //muestra menu
                  break;
      case "1":      printf("LLenando buffer..." ) ;   //llena memoria 0xff
                     for(i=0; i<16;i++){
                   for(j=0; j<16;j++)
                  write_eeprom(i*16+j,0xff);
                   }
             puts(" Buffer completado!" );
             break;
case "2":      puts("Realizando Lectura...
" );   //opcion que realiza la lectura modo hex
            puts("00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F" );
               puts("==============================================" );
               for(i=0;i<16;i++) {
                for(j=0;j<16;j++) {
                printf("%2x ",read_eeprom(i*16 +j) );
                }
                printf("|| %3x0
",i );
               }
               puts("
Lectura finalizada!" );
               break;
   case "3":      printf("
Direccion a cambiar: " );   //opcion que realiza la escritura
               address = gethex( );                  //le damos la direccion
               printf("
Nuevo valor: " );
               opcion=0;                        //modo datos
               value = gethex( );                  //le damos el dato a escribir
               opcion=1;                        //modo direcciones
               printf("
Realizando escritura..." Giño

;
write_eeprom(address,value); //escribe en la eeprom
printf(" Escritura finalizada!
" Giño

;
                   break;
       case "4":      puts("Realizando Lectura...
" );   //opcion que realiza la lectura modo texto
            puts("00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F" );
               puts("==============================================" );
               for(i=0;i<16;i++) {
                for(j=0;j<16;j++) {
                printf("%c ",read_eeprom(i*16 +j));
                }
                printf("|| %3x0
",i );
               }
               puts("
Lectura finalizada!" );
               break;
    default:      puts("Opcion incorrecta, para ver Menu pulse 0 VsZeNeR"06" );
      }
puts("****************************************************
" );
enable_interrupts(global);      //activamos de nuevo la interrupcion serial rs-232
}

///PROGRAMA
void main(void)
{
   setup_oscillator(OSC_4MHZ);      //reloj interno de 4MHz
   enable_interrupts(int_rda);      //activo interrupcion serial rs-232
    enable_interrupts(global);      //habilito la interrupcion

   do{            //bucle...
      puts("Lectura/Escritura de EEPROM interna VsZeNeR"06
" );      //menu...
      puts("==============================================
" );
      puts("Seleccione opcion:
" );
      puts("¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨" );
      puts(" 0->Ver opciones" );
      puts(" 1->LLenar buffer" );
      puts(" 2->Lectura modo HEX" );
      puts(" 3->Escritura EEPROM" );
      puts(" 4->Lectura modo TEXTO" );                           //...principal
      menu=1;                     //muestra menu solamente una vez
      while(menu==1){}            //espera tecla pulsada por teclado(rs-232)
   }while(TRUE);   //...infinito
}
///FUNCION QUE SELECCIONA DIGITO CORRESPONDIENTE
BYTE gethex1() {
char digit;

   do{                  //espera hasta tener un dato correcto
   digit = getc( );
   if(opcion==0)      //si estamos introduciendo un dato no hace falta las restricciones
      break;
}while((digit<"0" || digit>"9") && (digit<"A" || digit>"F") && (digit<"a" || digit>"f") );

putc(digit);            //muestra por pantalla el dato introducido

if(digit<="9")         //se ha introducido un numero
return(digit-"0");
else                  //se ha introducido una letra
return((toupper(digit)-"A")+10);
}
///FUNCION QUE DEVUELVE EL NUMERO HEXADECIMAL
BYTE gethex() {
int lo,hi;

hi = gethex1( );      //parte alta
lo = gethex1( );      //parte baja
if(lo==0xdd)
return(hi);
else
return( hi*16+lo );
}

Bueno, recordar que si quereis implementarlo en la vida real debereis retocar el formato de presentacion del menu, ya que en proteus no reconoce algunos como en y tal....asi que se ha programado para una "aceptable" vision en proteus!

Suerte!!! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 27 de Enero de 2006, 06:36:00

Desde este enlace os podeis descargar los fichers necesarios para el programa:lectura/escritura interna de la eeprom interna del pic mediante interrupcion serial

PD:Decir, que la semana que viene pondre la revision de la escritura/lectura de la eeprom externa 24LC256, es igual que este pero para la eeprom externa

Suerte!!! :wink:

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 31 de Enero de 2006, 04:59:00

Buenass!!!lo prometido es deuda! aqui esta el programa que gestiona la lectura/escritura de una eeprom externa, concretamente la 24LC256:

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"06
//                   23/Enero/06
//
//   Programa:   RS232 Y PIC
//   Version:   1.0 REVISION del programa 48
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.242
//   Entorno IDE: MPLAB IDE v7.30      Simulador:    Proteus 6.7sp3
//
//   Notas: Se interacciona el PC con el PIC mediante RS232 para el tratamiento de la memoria
//       eeprom externa 24LC256,se muestra por v.terminal un menu:
//               · 0 -> Muestra nuevamente el menu
//               · 1 -> LLena la eeprom a 0xFF
//               · 2 -> Lee la eeprom en modo hex
//               · 3 -> Escribe en la eeprom
//               · 4 -> Lee la eeprom en modo texto(ASCII)
//       Todas las acciones se realizan mediante la interrupcion del puerto serial.
//       Al comienzo del programa, realizar el paso 1. en caso de empezar a escribir
//       en la eeprom!. Decir que las funciones gethex1() y gethex() estan sacadas
//       de la libreria incluida en CCS, input.c, estan puestas en el programa
//       por la pequeña modificacion en la funcion gethex1() que, en este caso, solo
//       permite el paso de digitos comprendidos entre 0-f o 0-F. Tener en cuenta
//       que los datos a introducir deben ser en hexadecimal, por ejmeplo, en el
//       caso de almacenar en la letra "a" minuscula en la posicion 0x00 de la eeprom
//       24LC256, habra que realizar los siguientes pasos:
//             1. Pulsamos 3 para escribir en la eeprom interna
//            2. Ponemos la direccion 00 (esta en hexadecimal!)
//            3. Damos el valor en hex de la letra a=61
//            4. Leemos la memoria para ver que se almacenado correctamente(pulsando 2)
//
//   Conexiones:      A0 -> SCK eeprom 24LC256
//               A1 -> SDA eeprom 24LC256
//               B2 -> TxD
//               B1 -> RxD
//////////////////////////////////////////////////////////////////////////////////
#include <16f648a.h>                     //pic a utilizar
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP,NOBROWNOUT   //ordenes para el programador
#fuses RC_IO                           //reloj interno
#use delay (clock=4000000)                  //Fosc=4Mhz
#use rs232(baud=9600, xmit=PIN_b2, rcv=PIN_b1)   //manejo del RS232
#define EEPROM_SDA PIN_A1                  //pines para...
#define EEPROM_SCL PIN_A0                  //...manejo de eeprom 24LC256
#include <24256.c>                        //libreria eeprom 24LC256

///DECLARACION DE VARIABLES GLOBALES
boolean menu=1,opcion=1;      //si menu=0 se muestra el menu de inicio...
                        //...si opcion=1 estamos en modo direccion
                        // opcion=0 estamos en modo dato

///DECLARACION DE FUNCIONES
BYTE gethex1( );      //verifica que esta dentro del rango y muestra por pantalla
BYTE gethex( );      //devuelve el numero en hex
///LLAMADA FUNCION INTERRUPCION
#int_rda
void rs232( )
{
   BYTE i=0,j=0,value;            //definicion...
   EEPROM_ADDRESS address;
   char digito;               //...variables

   disable_interrupts(global);      //apago interrupcion

   digito=getc( );               //almaceno dato serial(rs232) en digito

   puts("
****************************************************" );

   switch(digito){
      case "0":      menu=!menu;                  //muestra menu
                  break;
      case "1":      printf("LLenando buffer..." );   //llena memoria 0xff
                     for(i=0; i<16;i++){
                   for(j=0; j<16;j++)
                  write_ext_eeprom(i*16+j,0xff);
                   }
             puts(" Buffer completado!" );
             break;
case "2":      puts("Realizando Lectura...
" );   //opcion que realiza la lectura modo hex
            puts("00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F" );
               puts("==============================================" );
               for(i=0;i<16;i++) {
                for(j=0;j<16;j++) {
                printf("%2x ",read_ext_eeprom(i*16 +j) );
                }
                printf("|| %3x0
",i );
               }
               puts("
Lectura finalizada!" Giño

;
               break;
   case "3":      printf("
Direccion a cambiar: " );   //opcion que realiza la escritura
               address = gethex( );                  //le damos la direccion
               printf("
Nuevo valor: " );
               opcion=0;                        //modo datos
               value = gethex( );                  //le damos el dato a escribir
               opcion=1;                        //modo direcciones
               printf("
Realizando escritura..." );
               write_ext_eeprom(address,value);         //escribe en la eeprom
               printf(" Escritura finalizada!
" );
                   break;
       case "4":      puts("Realizando Lectura...
" );   //opcion que realiza la lectura modo texto
            puts("00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F" );
               puts("==============================================" );
               for(i=0;i<16;i++) {
                for(j=0;j<16;j++) {
                printf("%c ",read_ext_eeprom(i*16 +j) );
                }
                printf("|| %3x0
",i );
               }
               puts("
Lectura finalizada!" );
               break;
    default:      puts("Opcion incorrecta, para ver Menu pulse 0 VsZeNeR"06" );
      }
puts("****************************************************
" Giño

;
enable_interrupts(global);      //activamos de nuevo la interrupcion serial rs-232
}

void main(void)
{
   setup_oscillator(OSC_4MHZ);      //reloj interno de 4MHz
   enable_interrupts(int_rda);      //activo interrupcion serial rs-232
    enable_interrupts(global);      //habilito la interrupcion

    init_ext_eeprom( );

   do{            //bucle...
      puts("Lectura/Escritura de EEPROM 24LC256 VsZeNeR"06
" );      //menu...
      puts("==============================================
" );
      puts("Seleccione opcion:
" );
      puts("¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨" );
      puts(" 0->Ver opciones" );
      puts(" 1->LLenar buffer" );
      puts(" 2->Lectura modo HEX" );
      puts(" 3->Escritura EEPROM" );
      puts(" 4->Lectura modo TEXTO" );                           //...principal
      menu=1;                     //muestra menu solamente una vez
      while(menu==1){ }            //espera tecla pulsada por teclado(rs-232)
   }while(TRUE);   //...infinito
}
///FUNCION QUE SELECCIONA DIGITO CORRESPONDIENTE
BYTE gethex1( ) {
char digit;

   do{                  //espera hasta tener un dato correcto
   digit = getc();
   if(opcion==0)      //si estamos introduciendo un dato no hace falta las restricciones
      break;
}while((digit<"0" || digit>"9") && (digit<"A" || digit>"F") && (digit<"a" || digit>"f" ));

putc(digit);            //muestra por pantalla el dato introducido

if(digit<="9" )         //se ha introducido un numero
return(digit-"0" );
else                  //se ha introducido una letra
return((toupper(digit)-"A" )+10);
}
///FUNCION QUE DEVUELVE EL NUMERO HEXADECIMAL
BYTE gethex() {
int lo,hi;

hi = gethex1();      //parte alta
lo = gethex1( );      //parte baja
if(lo==0xdd)
return(hi);
else
return( hi*16+lo );
}

Bueno, pues aqui esta!

Suerte!!! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 31 de Enero de 2006, 05:08:00

Desde el siguiente enlace os podeis descargar lo necesario para el programa anterior: Interrupcion RS232. Escritura/lectura eeprom 24LC256

Suerte!!! :wink:

Título: RE: Ejemplitos en C para 16F648A
Publicado por: copertun en 02 de Febrero de 2006, 14:30:00

Wenas, lo primero de todo queria felicitar a vszener por el excelente trabajo q esta haciendo, estoy empezando ahora a mirar los ejemplos y la verdad se entienden muy bien y parece bastante sencillo porgramar en c un pic supongo q el hecho de q yo ya sabia c antes de llegar aqui ayudara a entender las cosas, pero resulta q a la hora de ponerme a escribir los programas pues no sabia donde escribirlos, finalmente ya encontre un manual y he logrado escribir los programas pero he aqui mi problema q la version demo no posee el header file del 16f648a, asi q si alguno de vosotros me lo pudiera mandar aqui a eos_es@yahoo.es o decirme donde lo puedo conseguir se lo agradeceria.

Un saludo.

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 05 de Febrero de 2006, 10:59:00

GRACIAS copertun!!!ya te mande un e-mail!

Decir que en herramientas se ha incorporado la direccion a programas en vb6 utiles para los programas de este post!

Suerte!!! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 05 de Febrero de 2006, 11:05:00

Buenasss!!!bien, el sigiente programa es simplemente manejar el dispositivo SAA1064 de Philips, el cual sirve para manejar display"s de 7segmentos mediante bus I2C, tanto para la libreria del dispositivo para CCS como para PROTEUS lo podeis encontrar en el siguiente post:
Libreria: SAA1064 (CCS) (http://www.todopic.com.ar/foros/index.php?topic=4728.msg37279#msg37279)
El SAA1064 es util para ahorrar pines del pic(ya que solamente usa 2 para manejo del I2C), dicho dispositivo puede actuar tanto en modo dinamico(manejando un total de 4 display"s multiplexados), como en modo estatico(solamente 2 display"s), puede controlar la iluminosidad, parpadeo,...mirar el enlace anterior donde esta el data sheet!, bueno el ejemplo es manejar el SAA1064 en modo dinamico:
////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"06
//                   29/Enero/06
//
//   Programa:   Manejo del dispositivo SAA1064 en modo DINAMICO
//   Version:   0.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.242
//   Entorno IDE: MPLAB IDE v7.30      Simulador:    Proteus 6.7sp3
//
//   Notas: Este programa muestra pos cuatro display"s de 7seg mensajes de texto, para
//       ello usamos el dispositivo SAA1064 de bus I2C.
//
//       Conexiones:      A0 -> SDA saa1064
//                     A1 -> SCL saa1064
//////////////////////////////////////////////////////////////////////////////////

#include <16f648a.h>               //pic a utilizar
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP      //ordenes para el programador
#fuses INTRC                     //oscilador interno
#use delay (clock=4000000)            //Fosc=4Mhz
#define SAA1064_DINAMICO            //trabajar en modo dinamico el saa1064
#define SAA1064_SCL PIN_A1            //definicion de pines...
#define SAA1064_SDA PIN_A0            //...de manejo del saa1064
#include <vs_saa1064.c>               //libreria saa1064

///PROGRAMA
void main(void)
{
   setup_oscillator(OSC_4MHZ);   //configuracion del oscilador interno a 4MHz

   saa1064_init();            //inicializo saa1064

   do{         //bucle...
      ///MANIPULAMOS SAA1064 CON DIVERSAS CONFIGURACIONES
      saa1064_conf(0b00010001);         //3mA & NO parpadeo & Dinamico
      saa1064_putc(0x76,0x3F,0x38,0x77);   //HOLA
      delay_ms(1500);

      saa1064_conf(0b00100011);         //6mA & parpadeo 1&3 & Dinamico
      saa1064_putc(0x71,0x5C,0x50,0x5C);   //Foro
      delay_ms(1500);

      saa1064_conf(0b01000101);         //12mA & parpadeo 2&4 & Dinamico
      saa1064_putc(0x78,0x5C,0x5E,0x5C);   //todo
      delay_ms(1500);

      saa1064_conf(0b00110111);         //9mA & parpadeo TODO & Dinamico
      saa1064_putc(0x73,0x30,0x39,0x86);   //PIC!
      delay_ms(1500);

      saa1064_conf(0b01110001);         //21mA & NO parpadeo & Dinamico
      saa1064_putc(0x5B,0x3F,0x3F,0x7D);   //2006
      delay_ms(1500);

      ///MANIPULAMOS SAA1064 A CONFIGURACION FIJA -> CAMBIAMOS SOLAMENTE DIGITO DESEADO
      saa1064_conf(0b01110001);         //21mA & NO parpadeo & Dinamico ->Configuracion fija!
      saa1064_putc(0x76,0x3F,0x38,0x77);   //HOLA -> texto donde trabajar!
      delay_ms(1500);

      saa1064_subaddress(1,0xFF);         //Pongo en el 1º digito el caracter 8.
      delay_ms(1500);
      saa1064_putc(0x76,0x3F,0x38,0x77);   //reset -> HOLA

      saa1064_subaddress(2,0xFF);         //Pongo en el 2º digito el caracter 8.
      delay_ms(1500);
      saa1064_putc(0x76,0x3F,0x38,0x77);   //reset -> HOLA

      saa1064_subaddress(3,0xFF);         //Pongo en el 3º digito el caracter 8.
      delay_ms(1500);
      saa1064_putc(0x76,0x3F,0x38,0x77);   //reset -> HOLA

      saa1064_subaddress(4,0xFF);         //Pongo en el 4º digito el caracter 8.
      delay_ms(1500);
      saa1064_putc(0x76,0x3F,0x38,0x77);   //reset -> HOLA

   }while(TRUE);   //...infinito
   }

Este programa simplemente es para mostrar como manejar la libreria vs_saa1064.c para el manejo del dispositivo! si teneis alguna duda del programa o la libreria, ya sabeis!

Suerte!!! :wink:

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 05 de Febrero de 2006, 11:09:00

Aqui os podeis descargar los archivos del programa anterior: SAA1064 en modo DINAMICO

Suerte!!! :wink:

Título: RE: Ejemplitos en C para 16F648A
Publicado por: monopic en 08 de Febrero de 2006, 13:56:00

hola v zener te acuerdas de mi bueno pues pense en dejar en espera lo de la lcd 2x16 lo de que la queria volver grafica ,, bueno pues me compre una lcd grafica y me funciona muy bien utilizando la libreria glcd de picc ,, bueno solo queria preguntarte si sabes utilizar el programa que convierte imagenes en vectores de datos para visualizarlos en la lcd,, ese es mi unico problema y como seria la forma de escribirlo en picc para que pinte los pixeles... todo esto seria de gran ayuda para luego explicar a todos en el foro como utilizar la libreria glcd que ademas me simula perfecto en proteus .. gracias de antemano .....

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 09 de Febrero de 2006, 03:55:00

Buenass!!!ke tal monopic!ummmm supongo que habra programas que te den matrices de puntos correspondiente a una imagen...una vez, hace tiempo ya, en MATLAB, hacia eso, le dabas una imagen y te devolvia la matriz, pero de momento no he trabajado con matrices graficas, haber si la semana que viene que tengo "minis vacaciones" le meto mano y te cuento haber que tal, pero creo recordar, que en PROTEUS, hay un ejemplo o varios de matrices graficas, miratelos haber como lo hacen, yo me pondre al lio la semana que viene!

Suerte!!! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 09 de Febrero de 2006, 03:59:00

Holaaa!!!Bueno, trabajando un poco mas con la libreria del SAA1064, el siguiente ejemplo quiere mostrar como trabajar con las funciones de dicha libreria para modo ESTATICO, es decir, simplemente manejaremos dos display"s de 7 segmentos, aqui el programa:

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"06
//                   29/Enero/06
//
//   Programa:   Manejo del dispositivo SAA1064 en modo ESTATICO
//   Version:   0.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.242
//   Entorno IDE: MPLAB IDE v7.30      Simulador:    Proteus 6.7sp3
//
//   Notas: Este programa muestra por dos display"s de 7seg numeros, para
//       ello usamos el dispositivo SAA1064 de bus I2C.
//
//       Conexiones:      A0 -> SDA saa1064
//                     A1 -> SCL saa1064
//////////////////////////////////////////////////////////////////////////////////

#include <16f648a.h>               //pic a utilizar
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP      //ordenes para el programador
#fuses INTRC                     //oscilador interno
#use delay (clock=4000000)            //Fosc=4Mhz
#define SAA1064_SCL PIN_A1            //definicion de pines...
#define SAA1064_SDA PIN_A0            //...de manejo del saa1064
#include <vs_saa1064.c>               //libreria saa1064

///PROGRAMA
void main(void)
{
   setup_oscillator(OSC_4MHZ);      //configuracion del oscilador interno a 4MHz

   saa1064_init( );               //inicializo saa1064

   do{         //bucle...
      ///MANIPULAMOS SAA1064 CON DIVERSAS CONFIGURACIONES
      saa1064_conf(0b00010000);   //3mA & NO parpadeo & Estatico
      saa1064_putc(0x66,0x3F);   //40
      delay_ms(1500);

      saa1064_conf(0b00100010);   //6mA & parpadeo & Estatico
      saa1064_putc(0x4F,0x06);   //31
      delay_ms(1500);

      saa1064_conf(0b01000100);   //12mA & parpadeo & Estatico
      saa1064_putc(0x5B,0x5B);   //22
      delay_ms(1500);

      saa1064_conf(0b00110110);   //9mA & parpadeo & Estatico
      saa1064_putc(0x06,0x4F);   //13
      delay_ms(1500);

      saa1064_conf(0b01110000);   //21mA & NO parpadeo & Estatico
      saa1064_putc(0x3F,0x66);   //04
      delay_ms(1500);

      ///MANIPULAMOS SAA1064 CON CONFIGURACION FIJA -> CAMBIAMOS SOLO UN DIGITO
      saa1064_conf(0b00010000);   //3mA & NO parpadeo & Estatico -> configuracion fija!
      saa1064_putc(0x3F,0x3F);   //00 -> texto donde trabajar!
      delay_ms(1500);

      saa1064_subaddress(1,0xff);   //cambio el 1º digito por 8 ->08
      delay_ms(1500);
      saa1064_putc(0x3F,0x3F);   //restauro -> 00

      saa1064_subaddress(2,0xff);   //cambio el 2º digito por 8 ->80
      delay_ms(1500);

   }while(TRUE);   //...infinito
}

Pues ya esta explicada la libreria del dispositivo SAA1064 con los dos programitas, tanto para modo dinamico como pa modo estatico...

Hasta otra!!! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 09 de Febrero de 2006, 04:01:00

Buenass!!! os podeis descargar el programa anterior: SAA1064 modo ESTATICO

Suerte!!! :wink:

Título: RE: Ejemplitos en C para 16F648A
Publicado por: copertun en 18 de Febrero de 2006, 17:50:00

Wenas, como va eso amigos?, os queria comentar un trabajito en el q toy pensando, consiste en medir la temperatura con el ds1620 basandome en el ejemplo de vszener y despues mediante una salida del pic controlar un calefactor, algo no muy dificil yo creo, epro al ver el ejemplo de vszener me han surgido unas dudas q os paso a comentar.

No pillo bien pq hay q enviar estos bytes para mostrar el simbolo de grado {0b00000110,0b00001001,0b00000110}.

Luego a la hora de leer la temperatura a mi lo q me gustaria seria poderla enviarla a unos displays, asi q lo q habia pensado era leera y escribirla en la eeprom del pic y despues mandarla a los displays, pero no se me ocurre como almacenar de forma temporal el dato de la lectura para poder mandarlo despues a la eeprom.

Weno pos muchas gracias a todos, y dar las gracias a vszener por los excelentes ejemplos, y weno felicitarte tb q me he fijado y hoy 02-19-06 haces un añito q perteneces a esta comunidad jejej, asi q felicidades maestro.

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 19 de Febrero de 2006, 06:41:00

Buenas!!!Haber por partes:
Con respecto a lo del simbolo del grado, pues es faicil, se mandan esos datos a la cgram de la lcd para crear el simbolo del grado (este º Giño

ya que el chip de la lcd no lo tiene incluido, aunque el amigo nocturno en un post escribio esto:

Codigo:

Si es una LCD compatible con Hitachi HD44780 tendrás que enviarle el ASCII 224 (decimal) para que muestre ese símbolo

De las dos formas se puede mostrar el simbolo del grado en la lcd, pero vamos si tu lo vas a mostrar en 7seg no te hace falta eso....

Lo de almacenar de forma temporal la temperatura no se bien a lo que te refieres, si te refieres a leerla y guardarla en la eeprom interna del pic es sencillo, simplemente guardala, el ejemplito 51 dice como guardar y leer en la eeprom interna del pic, ahora bien si antes de guardarla en la eeprom la quieres mantener en algun otro lado, pues simplemente en la variable que hayas declarado estara almacenada su valor.

GRACIAS!!!es verdad que ya tengo un añin aqui!jeje

Suerte!!! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: copertun en 19 de Febrero de 2006, 09:52:00

Gracias por responder vszener y ademas tan rapido, he estado mirando otra vez los ejemplos de leer de la eeprom y parece facil simplemente tendria q ahce run codigo como este no?

int temp, LAST_VOLUME; //variable donde guardo la temperatura

temp = read_ds1620(0xAA) //y ya tengo en la variable temp la temperatura
write_eeprom(LAST_VOLUME,temp);

Y ahora en la variable temp tendria un dato hex que tendra segun el datasheet del ds1620 9 bits, y ahora mi pregunta es como puedo convertir esos 9 bits a decimal y enviarlos a los displays?. Tambien se me ha ocurrido poner en una tabla los diferentes posibles valores q voy a leer y con sucesivos if poner en los displays la temperatura y asi no tener q convertirlos a decimal, es decir si yo leo el valor $19 pues mando a los displays el valro 25, y asi con todas las posibles temperaturas que pueda obtener que tampoco creo q sean muchas.

Y muchas gracias de nuevo vszener.

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 01 de Marzo de 2006, 17:10:00

Buenas!!!!ando algo perdido pero bueno....siempre regreso a casa!jeje haber, amigo copertun, respecto a la eeprom exactamente como dice el ejemplo y el trozo de programa que has posteado lo indica, es correcto, respecto al dato, si como bien dices es en hexadecimal asi que para representarlo en display de 7 seg deberas pasarlo a decimal, la forma de pasarlo pues facil, una funcion que pase de hex a decimal, puedes hacerla mediante tabla, declaras una tabla con todos los valores posibles y ya esta(aunque bueno esta opcion aunque es rapida consume mas memoria...), la otra pues realizar la funcion correspondiente, pasas el dato a binario y de binario a decimal y listo para representarse en el display de 7seg!

Suerte!!! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: 271071 en 04 de Marzo de 2006, 07:21:00

1) mi primera consulta es respecto a: como hago para obtener una temporización de un segundo exacto, ya que en el programa que has dado como ejemplo no es un segundo exacto.
2) tenes ejemplos o has hecho ejemplos de programas que controlen, motores paso a paso, motores de continua, y motores de alterna.
3) tenés ejemplos que hayas hecho conectando conversores al microcontrolador, ya sé que viene con un conversor analógico digital pero en caso de que tuvieras que conectar un conversador externo.

Sugerencia, no se si te sirva o no, dado que tenés tantos conocimientos y tenés tantos ejemplos, tranquilamente y casi muy similar a lo que has hecho en la página web, que podrías poner en campaña de acuerdo a tu tiempo para organizar un libro de programación en lenguaje C para microcontroladores, dado que en castellano no he visto ningún libro de ése tipo y tus ejemplos son bastante didácticos y entendibles, agregando mucho ejemplos más como ligeras variantes sobre lo que ya tenés hecho más algunas que inventes (no creo que te cueste mucho) podrías lanzar un buen libro y harías una muy buena cantidad de dinero. (Sólo es una sugerencia sin ánimos de ofender)

4) He tenido inconvenientes con una instrucción en alguna de tus últimos programas, es como si no me reconociera el programa esa instrucción.
Por ejemplo:

////////////////////////////////////////////////////////////////////////////////////
// VsZeNeR"06
// 23/Enero/06
//
// Programa: RS232 Y PIC
// Version: 1.0 REVISION del programa 45
//
// Dispositivo: PIC 16F648A Compilador: CCS vs3.242
// Entorno IDE: MPLAB IDE v7.30 Simulador: Proteus 6.7sp3
//
// Notas: Se interacciona el PC con el PIC mediante RS232 para el tratamiento de la memoria
// eeprom interna,se muestra por v.terminal un menu:
// • 0 -> Muestra nuevamente el menu
// • 1 -> LLena la eeprom a 0xFF
// • 2 -> Lee la eeprom en modo hex
// • 3 -> Escribe en la eeprom
// • 4 -> Lee la eeprom en modo texto(ASCII)
// Todas las acciones se realizan mediante la interrupcion del puerto serial.
// Al comienzo del programa, realizar el paso 1. en caso de empezar a escribir
// en la eeprom!. Decir que las funciones gethex1() y gethex() estan sacadas
// de la libreria incluida en CCS, input.c, estan puestas en el programa
// por la pequeña modificacion en la funcion gethex1() que, en este caso, solo
// permite el paso de digitos comprendidos entre 0-f o 0-F. Tener en cuenta
// que los datos a introducir deben ser en hexadecimal, por ejmeplo, en el
// caso de almacenar en la letra "a" minuscula en la posicion 00 de la eeprom
// interna del pic, habra que realizar los siguientes pasos:
// 1. Pulsamos 3 para escribir en la eeprom interna
// 2. Ponemos la direccion 00 (esta en hexadecimal!)
// 3. Damos el valor en hex de la letra a=0x61
// 4. Leemos la memoria para ver que se almacenado correctamente(pulsando 2)
// La eeprom interna del 16F648A es de 256k.
//
// Conexiones: B2 -> TxD
// B1 -> RxD
//////////////////////////////////////////////////////////////////////////////////
#include <16f648a.h> //pic a utilizar
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP,NOBROWNOUT //ordenes para el programador
#fuses RC_IO //reloj interno (a esta instrucción es a la que me refiero, es como si el compilador no me las reconociera)

Y también he tenido inconvenientes con esta otra instrucción en este otro programa que vos has desarrollado

////////////////////////////////////////////////////////////////////////////////////
// VsZeNeR"06
// 29/Enero/06
//
// Programa: Manejo del dispositivo SAA1064 en modo DINAMICO
// Version: 0.0
//
// Dispositivo: PIC 16F648A Compilador: CCS vs3.242
// Entorno IDE: MPLAB IDE v7.30 Simulador: Proteus 6.7sp3
//
// Notas: Este programa muestra pos cuatro display"s de 7seg mensajes de texto, para
// ello usamos el dispositivo SAA1064 de bus I2C.
//
// Conexiones: A0 -> SDA saa1064
// A1 -> SCL saa1064
//////////////////////////////////////////////////////////////////////////////////

#include <16f648a.h> //pic a utilizar
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP //ordenes para el programador
#fuses INTRC //oscilador interno (a esta instrucción es a la que me refiero, es como si el compilador no me las reconociera)
#use delay (clock=4000000) //Fosc=4Mhz
#define SAA1064_DINAMICO //trabajar en modo dinamico el saa1064
#define SAA1064_SCL PIN_A1 //definicion de pines...
#define SAA1064_SDA PIN_A0 //...de manejo del saa1064
#include <vs_saa1064.c> //libreria saa1064

Acaso será por la versión de compilador? PICC IDE 3.43
PCB3.203

Será por eso?

Una sugerencia más, vos subís los programas al servidor, y de ahí hay que descargarlos, pero resulta que si por algún motivo alguien tiene alguna otra versión, no se pueden abrir, evidentemente me refiero al Proteus,, lo que te sugeriría si tu puedes y no es molestia a parte de subirlo colocada una imagen de cómo implementaste el circuito, que se yo quizá la captura la puedas hacer con la tecla print scr de tu máquina y la pegues en algún programa de dibujo., a si quizá podría facilitar algunas cosas (repito sólo es una sugerencia sin ánimos de ofender).

Verdaderamente te felicito por el trabajo estás haciendo, es admirable de los conocimientos que por seres de programación y ánimos para seguir adelante.

Mi nombre es Pedro y sobre de la república Argentina

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 04 de Marzo de 2006, 09:32:00

Buenass!!!!haber por partes:
1)Ummm con respecto al segun exacto, dime cual es el programa que no lo genera(dime el numero y lo reviso), en este post de ejemplitos hay varios contadores y temporizadores, los que trabajan con el timer pues no son exactos, debes crearte una funcion o usar variables para redondear el exceso o la temprana interrupcion ocasionando el no segundo exacto, los programas realizados aqui estan basados en usar variables para el ajuste fino y medidos con el reloj de PROTEUS y normalmente es el tercer segundo el que se recupera todo el tiempo perdido o no exacto, habiendo un margen del segundo 1 al 2 de milesimas de segundo arriba o abajo....sino es asi dimelo!de todas formas en dichas variables de ajuste fino las puedes "toquetear" para ajustarlo mejor o peor. Ahora bien, si necesitas temporizaciones muy muy muy exactas, o creas una rutina en asm o mediante un chip externo te vaya generando mediante interrupcion, por ejemplo en RB0, la temporizacion.

2)He trabajado con motores, tener programas tipo los que estan en este post no los tengo, pero vamos ya me has dado otra idea de otro ejemplo a poner!jeje. Si no lo he puesto es porque este post intento exponer mi forma de programar, y lo intento hacer de una forma general, es decir, usando los recursos del pic y algun periferico externo, peor mi idea es que si alguna vez no te acuerdas de programar o como se programaba no se, la interrupcion de los pines portb <4:7> pues entras en este post y hay un ejemplito donde te lo muestra!

3)Aqui puntualizarte que el 16F648A no tiene ningun conversor, un amigo de este foro me pidio que le ayudase con un lm35 y tal, ya lo tengo casi listo la simulacion en PROTEUS y todo, en cuanto lo termine lo cuelgo aqui, y en ese programa se usa un convertidor externo ya que, repito, este dispositivo carece de ello.

Respecto a lo del libro, jeje es buena idea pero ando algo ajetreado para sentarme a escribir un libro!aunque ensallos y tal si que hay....tiempo al tiempo jeje

4)Bien, la instruccion que tienes problemas no deberias, revisa el pic si efectivamente el programa esta siendo compilado con el #include <16f648a.h> //pic a utilizar , si no es asi, pues dirigete a la carpeta donde este instalado en tu PC el picc(es el compilador ccs) y en la carpeta device(creo recordar que es sino en la carpeta dond estan todos los pic"s .h)busca el 16F648A y mira si esta dicho fuses, en caso de no estar es problema de la version de tu compilador(aunque me extraña).

Eso si en el programa que me has puesto (Programa: RS232 Y PIC) hay un fuse:
#fuses RC_IO //reloj interno
que esta mal!!!!jeje me he dado cuenta al postearlo tu!ese fuse no es el oscilador interno, el oscilador interno es este:
#fuses INTRC //oscilador interno
Bueno sera el copy & paste....que se me escapo ese detallito!jeje

Con respecto a las fotos en PROTEUS es buena idea peroooo imaginate que cada pagina de este post pue sno se, puede tener 5 0 6 programas, si tuviera 5 0 6 imagenes tardaria o comoe sta ultimamente el servicio de mi@rroba pues seguramente daria muchos problemas al abrir el post!por eso en los comentarios de cabecera especifico las conexiones, simplemente es por eso, para no dar mas lata al servidor que anda algo gracioso ultimamente jeje....

Y GRACIAS!!!!!por usar estos ejemplos y preguntar y tal!y no te preocupes que no me ofende tus palabras, todo lo contrario!me dan alegriay animos para seguir asi, haciendo ejemplitos de estos que tanto me valen ami para practicar y divertirme como a la gente para mirarlos y "toquetearlos" jeje !

Si tienes alguna duda mas o alguna sugerencia ya sabes!

Suerte!!! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 11 de Marzo de 2006, 07:15:00

Buenas!!!!¿que error te genera la instruccion setup_oscillator(); ? ¿miraste en la carpeta device en la libreria del pic? es muy raro que te de ese error, en este post hay varios ejemplos con dicha instruccion y compilando perfectamente.

Con respecto al segundo perfecto, yo te diria que por hardware, mas o menos perfecto pues en asm o como te mencione anteriormente, mediante una variable o una funcion de redondeo.

Suerte!!! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: levisperez en 13 de Marzo de 2006, 10:49:00

Estoy simulando el ejemplito de juego de luces de vszener, en el cual se ejecuta el juego de luces o el coche fantastico dependiendo del estado del Pin RA0, cree mediante el stimulus controller en el Mplab 7.31 la entrada RA0 como toggle pero como hago para llamar esa ventana (la del stimulus controller) para cambiar el estado de RA0

Slds,

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 16 de Marzo de 2006, 09:32:00

Buenasss!!!la verdad que nunca he usado el MPlab para simular....suelo usar el PROTEUS y despues irme a la proto...no te puedo decir, haber si empiezo a toquetear el MPlab y te digo, si lo descubres tu hazlo saber!

Suerte!!! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: levisperez en 16 de Marzo de 2006, 14:24:00

Ya lo encontré, vszener en la ventana del stimulus controller del lado izquierdo esta el boton de fire, con el cual cambias el estado del PIN

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 23 de Marzo de 2006, 06:57:00

Me alegro que lo encontraras levisperez y gracias por postearlo, asi ya todos sabemos algo mas de como simular en MPlab! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 23 de Marzo de 2006, 07:04:00

Buenass!!!!hacia tiempo que no posteaba ningun ejemplito asi que ya es hora!jeje bien, como bien sabemos, el 16F648A no tiene conversor A/D asi que para trabajar con medidas y tal necesitamos un chip conversor, en este caso vamos a usar uno que tiene bastante aceptacion y hay informacion en algun que otro libro, es el fabricado por Philips el PCF8591, sirve tanto como A/D y D/A, he realizado una "mini libreria" para su manejo, aqui esta:
///////////////////////////////////////////////////////////////////////////////////////////////////
///            VsZeNeR"06                     ///
///          13/Marzo/06                     ///
///          vszener@gmail.com                     ///
///                                    ///
///      Libreria: vs_pcf8591.c    Compilador: CCS                  ///
///      Version: 0.0                           ///
///                                    ///
///      Notas: Controlador para manejo del dispositivo pcf8591          ///
///      de Philips.                        ///
///          Este dispositivo se encarga, mediante I2C, del tratamiento de       ///
///    conversor A/D como D/A.                      ///
///    Modo:                            ///
///    ¨¨¨¨¨¨    ·D/A: 8 bits                    ///
///            ·A/D: 8 bits con 4 entradas analogicas          ///
///                                    ///
///      Funciones:                           ///
///            MODO D/A                     ///
///            --------                     ///
///            pcf8591_dac_init( );    -> Inicializa el dispositivo   ///
///            write_dac_value(int data); -> Escribe el volatje a mostrar   ///
///                      por AOUT(8 bits)         ///
///            stop_dac( );       -> Para el dispositivo. Una vez   ///
///                      realizada esta opcion, para ///
///                      a utilizar AOUT debemos       ///
///                      inicializarlo de nuevo!      ///
///            MODO A/D                     ///
///            --------                     ///
///            pcf8591_adc_init(control); -> Inicializa el dispositivo.   ///
///                      Debemos enviar el byte de   ///
///                      control:            ///
///            Byte de control: 0 X XX 0 X XX               ///
///                   0 A EA 0 I NC             ///
///                                    ///
///            A: Permiso Salida analogica 0 -> AOUT alta impedancia      ///
///                      1 -> AOUT habilitada      ///
///            EA: Programacion entradas analogicas: 00 -> 4 entradas simples   ///
///                         01 -> 3 entradas dif.   ///
///                         10 -> Simples y dif   ///
///                         11 -> 2 entradas dif.    ///
///            I: Incremento 0 -> No hay autoincremento         ///
///             1 -> Autoincremento de la entrada del A/D      ///
///            NC: Numero del canal de la entrada 00 -> Canal 0      ///
///                         01 -> Canal 1      ///
///                         10 -> Canal 2      ///
///                         11 -> Canal 3      ///
///            read_adc_value(int data); -> Lee el volatje a mostrar      ///
///                                    ///
///      La direccion del dispositivo se configura con los pines A2A1A0, donde en este   ///
///      caso se ha elegido GND(000). Se he habilitado siempre la salida AOUT en D/A    ///
///      y deshabilitado siempre en A/D.                     ///
///////////////////////////////////////////////////////////////////////////////////////////////////

#ifndef PCF8591_SCL               //para definir los pines de manejo del pcf8591...
#define PCF8591_SCL PIN_B0
#define PCF8591_SDA PIN_B1
#endif                     //...en caso de no ser definidos en el programa principal

#use i2c(master,sda=PCF8591_SDA, scl=PCF8591_SCL)   //i2c

/////////////MODO: D/A ///////////////////////////////////////////////////////////////////////////

void stop_dac(void){         //funcion para parar el dac
   i2c_stop( );
}

void write_dac_value(int data){      //funcion que escribe en AOUT
   i2c_write(data);
}

void pcf8591_dac_init(){      //funcion para inicializar pcf8591
output_high(PCF8591_SDA);
output_high(PCF8591_SCL);
i2c_start( );
i2c_write(0b10010000);      //direccion en modo escritura
i2c_write(0b01000000);      //palabra de control habilitando AOUT
}

/////////////MODO: A/D ////////////////////////////////////////////////////////////////////////////

int read_adc_value(void){         //funcion para la lectura del pcf8591
   byte data;
   data=i2c_read(1);         //lee y se almacena en la variable data
   return data;            //devuelve la informacion leida
}

void pcf8591_adc_init(int control){      //funcion para inicializar pcf8591
output_high(PCF8591_SDA);
output_high(PCF8591_SCL);
control=(0b00110111 & control);      //palabra de control correcta -> deshabilita AOUT
i2c_start( );
i2c_write(0b10010000);         //direccion en modo escritura
i2c_write(control);            //palabra de control
i2c_stop( );

i2c_start( );             //iniciamos comandos...
i2c_write(0b10010001);         //...de lectura
}

Bien, pues con esta "mini libreria" trabajaremos en un par de ejemplitos!

Hasta otra!!! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 23 de Marzo de 2006, 07:07:00

Desde este enlace os podeis descargar la "mini libreria" para el manejo del pcf8591

Suerte!!! :wink:

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 23 de Marzo de 2006, 07:10:00

Holaaa!!!he aqui un programita que maneja la libreria y el dispositivo pcf8591!, en este caso como D/A, es decir, mediante un pulsador vamos sumando un valor que sera mostrado por el pcf8591 en el pin AOUT, dicho valor es de 8 bits y se vera el encendido paulatino de un led y su tension correspondiente por dicho pin:
////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"06
//                   13/Marzo/06
//
//   Programa:   Manejo del dispositivo PCF8591 en modo D/A
//   Version:   0.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.242
//   Entorno IDE: MPLAB IDE v7.31      Simulador:    Proteus 6.7sp3
//
//   Notas: Este programa muestra el encendido paulatino de un diodo led
//       conectado al pcf8591 configurado para actuar como D/A.
//       La Vref es de 2,5v por lo tanto la resolucion del conversor es 10mV.
//       Al pulsar el boton se produce una interrupcion, en dicha interrupcion
//       se incrementa la variable "dato" en una unidad y se muestra por el pcf8591
//       por el pin AOUT, al ser de tipo entero dicha variable puede llegar hasta
//       255 siendo este el valor maximo que puede alcanzar la señal analogica del
//       pcf8591.
//
//       Conexiones:      B7 -> SDA pcf8591
//                     B6 -> SCL pcf8591
//                     B0 -> Boton
//////////////////////////////////////////////////////////////////////////////////

#include <16f648a.h>               //pic a utilizar
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP      //ordenes para el programador
#fuses INTRC                     //oscilador interno
#use delay (clock=4000000)            //Fosc=4Mhz
#define PCF8591_SCL PIN_B6            //definicion de pines...
#define PCF8591_SDA PIN_B7            //...de manejo del pcf8591
#include <vs_pcf8591.c>               //libreria pcf8591

///DEFINICION VARIABLES GLOBALES
int dato;                     //variable de salida por AOUT

///LLAMADA FUNCION INTERRUPCION
#INT_EXT
void IntRB0()
{
   dato++;                     //incremento variable dato
   write_dac_value(dato);         //salida analogica AOUT
}

///PROGRAMA
void main(void)
{
   setup_oscillator(OSC_4MHZ);      //configuracion del oscilador interno a 4MHz

   enable_interrupts(int_ext);      //activar interrupcion externa
   ext_int_edge(H_TO_L);         //configuracion:interrupcion cuando señal esta en baja
   enable_interrupts(GLOBAL);      //activar interrupciones

   pcf8591_dac_init( );            //inicializamos pcf8591 en modo D/A

   write_dac_value(dato);         //voltaje inicial de salida 0v

   sleep( );                  //modo reposo hasta la interrupcion
}

Suerte!!! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 23 de Marzo de 2006, 07:11:00

Desde este enlace os podesi descargar lo necesrio para el programa anterior: pcf8591 aout

Suerte!!! :wink:

Título: RE: Ejemplitos en C para 16F648A
Publicado por: migsantiago en 24 de Marzo de 2006, 17:25:00

Escrito originalmente por vszener
Buenas!!! al final me he puesto manos a la obra y he realizado la animacion de carga de una bateria....jeje, para ello se diseña los caracteres de la bateria(al 0%, al 20%, al 40%, al 60%, al 80% y al 100%), decir que solamente he utilizado una posicion de memoria de la GCRAM(aunque cada animacion ocupa 8 posiciones), he ido machacando valores.......aqui el codigo:

Hola vszener, estaba estudiando este código que pusiste pero no encuentro la instrucción lcd_send_byte en la ayuda de mi compilador. Tengo la versión 3.190, tu programa dice 3.227, ¿es ese el problema? Avergonzado

Título: RE: Ejemplitos en C para 16F648A
Publicado por: monopic en 25 de Marzo de 2006, 13:23:00

HOLA A TODOS EN ESPECIAL A VZENER Y QUIERO CONTARLE QUE YA ESTOY MANEJANDO UNA LCD GRAFICA POR MEDIO DE LA LIBRERIA GLCD DE PICC Y ESTA LA PUTERIA PERO ANTES DE SUBIR TODO ESO AL FORO QUIERO SABER COMO FUNCIONA EL PROGRAMA QUE CREARON EN EL FORO QUE CONVIERTE UNA IMAGEN EN UN VECTOR DE DATOS PARA LUEGO ENVIARLA A LA PANTALLA O TAMBIEN COMO FUNCIONA UN PROGRAMA SIMILAR QUE SE LLAMA FASTLCD QUE HACE LO MISMO PERO NI IDEA COMO SERIA PARTE DEL CODIGO........................HASTA EL MOMENTO TODO LO QUE HE APRENDIDO DEL GLCD DE PICC ME HA TOCADO APRENDER POR ENSAYO Y ERROR POR QUE EN LA RED NO SE ENCUENTRA NADA DE COMO FUNCIONA ESA LIBRERIA SI ALGUIEN SABE POR FAVOR ESCRIBA.. GRACIAS A TODOS

Título: RE: Ejemplitos en C para 16F648A
Publicado por: monopic en 25 de Marzo de 2006, 13:27:00

Título: RE: Ejemplitos en C para 16F648A
Publicado por: 271071 en 26 de Marzo de 2006, 06:24:00

Aqui el mismo programa del Maestro VS_ZeNeR, pero para 16f84 . Se que no es mucho , pero si a alguien le interesa.....
El circuito no tiene ninguna modificacion mas que la del cambio de pic , los pines se conectan igual(en los mismos puertos)

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"06
//                   13/Marzo/06
//
//   Programa:   Manejo del dispositivo PCF8591 en modo D/A
//   Version:   0.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.245
//   Entorno IDE: MPLAB IDE v7.31      Simulador:    Proteus 6.7sp3
//
//   Notas: Este programa muestra el encendido paulatino de un diodo led
//       conectado al pcf8591 configurado para actuar como D/A.
//       La Vref es de 2,5v por lo tanto la resolucion del conversor es 10mV.
//       Al pulsar el boton se produce una interrupcion, en dicha interrupcion
//       se incrementa la variable "dato" en una unidad y se muestra por el pcf8591
//       por el pin AOUT, al ser de tipo entero dicha variable puede llegar hasta
//       255 siendo este el valor maximo que puede alcanzar la señal analogica del
//       pcf8591.
// Agregado (): Calculo de la resolucion de escalones de conversion 2 exp 8 = 256, entonces
//       V de Referencia / 256 = incremento de cada escalon, en este caso
//       2.56V/256 = 10mv(resolucion del conversor)
//       Aqui se modifica el programa para usar el 16f84 (que solo lo he probado en
//    simulacion) como pueden ver he realizado
//       minimas modificaciones algunas
//       sentencias han sido puestas tipo comentario agregándole dos barras en la
//       parte delantera. Fijense que estoy usando otra version de ccs (eso por si les
//       da algun error)
//         Conexiones:      B7 -> SDA pcf8591
//                     B6 -> SCL pcf8591
//                     B0 -> Boton
//////////////////////////////////////////////////////////////////////////////////

//#include <16f648a.h>               //pic a utilizar
#include <16f84a.h>               //pic a utilizar

#fuses XT,NOWDT,NOPROTECT,PUT      //ordenes para el programador
//#fuses INTRC                     //oscilador interno
#use delay (clock=4000000)            //Fosc=4Mhz
#define PCF8591_SCL PIN_B6            //definicion de pines...
#define PCF8591_SDA PIN_B7            //...de manejo del pcf8591
#include <vs_pcf8591.c>               //libreria pcf8591

///DEFINICION VARIABLES GLOBALES
int dato;                     //variable de salida por AOUT

///LLAMADA FUNCION INTERRUPCION
#INT_EXT
void IntRB0()
{
   dato=dato+5;                     //incremento variable dato
   write_dac_value(dato);         //salida analogica AOUT
}

///PROGRAMA
void main(void)
{
//setup_oscillator(OSC_4MHZ);      //configuracion del oscilador interno a 4MHz

   enable_interrupts(int_ext);      //activar interrupcion externa
   ext_int_edge(H_TO_L);         //configuracion:interrupcion cuando señal esta en baja
   enable_interrupts(GLOBAL);      //activar interrupciones

   pcf8591_dac_init();            //inicializamos pcf8591 en modo D/A

   write_dac_value(dato);         //voltaje inicial de salida 0v

   sleep();                  //modo reposo hasta la interrupcion
}

Título: RE: Ejemplitos en C para 16F648A
Publicado por: 271071 en 26 de Marzo de 2006, 06:31:00

Hola de nuevo: este es otra variante del programa con pfc8591 pero en este caso.
hemos hecho una modificación a tu ejemplo DAC y lo hemos hecho para un ADC , la particularidad que tiene para este(ejercicio ( ADC ) según veo es que vos lo inicializar con una palabra de configuración y luego lo que haces es leerlo, sacando su valor por pantalla, en un ciclo While dentro del cual hay un retardo para que si vos quisieras pudieras ver las transiciones de un estado a otro, para lo cual se ha agregado un contador de muestra (que se ve en el display al ejecutar el programa)

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"06
//                   13/Marzo/06
//
//   Programa:   Manejo del dispositivo PCF8591 en modo A/D
//   Version:   0.0
//
//   Dispositivo: PIC 16F84A         Compilador:    CCS vs3.245
//   Entorno IDE: MPLAB IDE v7.31      Simulador:    Proteus 6.7sp3
//
//   Notas: Este programa muestra como usar el conversor pfc8591 como adc.
//       La Vref es de 2,56v por lo tanto la resolucion del conversor es 10mV.
//       Básicamente lo que aquí hacemos es inicializar el conversor con la palabra
//      de configuración y luego sólo resta leer (obviamente estamos modificando la
//       tención analógica de entrada) sólo nos resta corregir un ligero error que es
//       el que apenas pasa el valor de 128 en que se muestra valor negativo.
//      Se muestra por pantalla de lcd(LM016L)
//
//
//       Conexiones:            RA1 -> SDA pcf8591
//                     RA0 -> SCL pcf8591
//
//                     lcd(LM016L)
//                     B0 -> E
//                     B1 -> RS
//                     B2 -> RW
//                     B4 -> D4
//                     B5 -> D5
//                     B6 -> D6
//                     B7 -> D7
//                     VSS y VEE -> gnd
//                     VDD ->VCC
//
//                     pcf8591
//                     A0,A1,A2.EXT , AGND ->gnd
//                     AN0 divisor resistivo con potenciometro (2.5v Variables)
//                     VREF=2.56 (en est6e caso)(pin14) divisor resistivo con potenciometro
//
//
//////////////////////////////////////////////////////////////////////////////////
//Programa prueba del conversor como adc.
#include <16f84a.h>               //pic a utilizar
#fuses XT,NOWDT,NOPROTECT,PUT      //ordenes para el programador
#use delay (clock=4000000)            //Fosc=4Mhz
#define PCF8591_SCL PIN_A0         //definicion de pines...
#define PCF8591_SDA PIN_A1      //...de manejo del pcf8591
#include <vs_pcf8591.c>               //libreria pcf8591
#define use_portb_lcd TRUE //definir portb lcd
#include<lcd.c> //libreria manejo lcd
///DEFINICION VARIABLES GLOBALES
int x=1;                     //variable de salida por AOUT
unsigned char dato=0;
///LLAMADA FUNCION INTERRUPCION
//#INT_EXT

///PROGRAMA
void main(void)
{

lcd_init();

delay_ms(3000); //retraso para que se vea en pantalla los mensajes

lcd_gotoxy(1,1);

lcd_putc("f Voltimetro" ) ;

lcd_gotoxy(3,2);

lcd_putc(" Digital!!!" ) ;

delay_ms(3000); //retraso para que se vea en pantalla los mensajes

lcd_putc("f" ); //borra pantalla

pcf8591_adc_init(0b00000000); //inicializamos pcf8591 en modo A/D habilitando canal 0 solamente
            //ver la palabra de configuracion en la hoja de datos o en la libreria
            //perfectamente explicada por VS_ZeNeR
while (x<100){

lcd_gotoxy(1,1);

printf(lcd_putc,"X= %d",x ) ;

dato=read_adc_value();         //se guarda valor en variable dato

lcd_gotoxy(9,1);

printf(lcd_putc,"%d mV",dato) ;

delay_ms(1000); //retraso para que se vea en pantalla los mensajes

x++;

lcd_putc("f" ); //borra pantalla

}
}

Título: RE: Ejemplitos en C para 16F648A
Publicado por: 271071 en 26 de Marzo de 2006, 06:40:00

aqui subo el circuito en el proteus el dsn, por si no les funciona tambien les mando una imagen , ya que a veces surgen ciertos inconvenientes . asi ven como son las conecciones......................un detalle esto foro no me permitio subir adjuntos, quiza sea por no tener suficientes privilegios para hacerlo

Título: RE: Ejemplitos en C para 16F648A
Publicado por: 271071 en 26 de Marzo de 2006, 06:48:00

Aqui van algunas dudas y sugerencias , espero no incomodarte Vs_ZeNeR....

1) Me surge una duda con respecto a por qué utilizadas el oscilador interno, que utilidad tiene, dado que en esta parte de la Argentina, por lo menos los comercios no han traído el pic 16F648a, entonces nosotros usamos el más común de todos que es el pic 16F84a, que no tiene oscilador interno y los ejemplos nos funcionan igual.

2) mas o menos cuál es la corriente que soportan las entradas de los pic, y cómo hacemos para evitar de quemar una de ellas, en realidad a lo que me refiero es a que circuito ponemos recurrir o que integrado ponemos para evitar de sobrecargar una entrada, lo que si es evidentemente esque si vas a trabajar con 220 V tendría que usar un optoacoplador, pero para integrados con mucha más baja tensión ¿que podria usar? .

3) con respecto al ejercicio que realizamos con conversión ADC tenemos el inconveniente que la atención que transformamos y mostramos en la parte de muestra cuando pasa de 128 empieza mostrar un valor negativo (por supuesto sólo lo hemos hecho ayer) no lo hemos revisado demasiado pero hemos probado que funciona.

4) Sugerencia: de los ejemplos que ya has hecho, por ejemplo los de memoria, podrías expandir alguno para usar varias memorias (viste que las 24LC 256 se pueden colocar varias colgadas al bus I2C . que las seleccionamos con las tres entradas A0, A1, A2, tendrías algún ejemplo a mano, supongo que la modificación no llevaría demasiado tiempo.

5) Sugerencia: ¿tenés algún ejemplo realizado con sensores?, perdón sé que tenés hecho el ejemplo con el sensor de temperatura DS1620, pero por ejemplo con algún sensor de presión de fluidos, sensores de movimiento, sensores de campo magnético, LDR (light dependent resistor) sensor óptico CNY70 ,OPB 703/4/5, H211 sensor óptico de barrera sensores infrarrojos, GP2D05 ,GP2D15 ,GP2D12, receptor para control remoto SFH 5110, sensor de proximidad IS471f, detector por ultrasonido SRF04,

6) Sugerencia:a has usado el bus de una línea, por ejemplo un circuito con un ds1820 (termómetro digital).

7) para quien le interese, busque en Internet el grabador de pic TE20-SE, sería otro de los tantos grabadores que anda dando vuelta por la web, pero éste soporta grabado de memorias, graba pic de 28 pines y de 18 pines, con la particularidad de que es muy sencillo no necesita fuente de alimentación ya que la recibe directamente de la PC, es un grabador de pocos componentes sencillo de armar y barato

8)Sugerencia: la librería del pfc8591 está bastante bien explicada, por no decir muy bien explicada.
Como anexo a los ejemploss que entregaste, ¿podrías explicar otras librerías ya utilizadas como por ejemplo la librería del Display , la del DS1620, SAA1064, la librería para teclados KBD y otras, también explicada como tenés la librería anteriormente mencionada, sé que no es un ejercicio pero a los efectos del conocimiento me parece que ayudaría bastante.

PD: lamento lo errores ortograficos, es que uso un programa de dictado para hacer los textos y a veces algun errorcito se ........me pasa

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 30 de Marzo de 2006, 12:28:00

Buenas!!!!por partes:
migsantiago, la verdad que en la version mia del CCS tampoco viene en la ayuda la funcion lcd_send_byte, yo la encontre en la propia libreria de lcd.c.

monopic me alegra que ya estes ganandole la batalla a la glcd jeje yo ya tengo una por aqui haber si le meto mano y trasteo con ella tambien!Haber si posteas en un hilo del foro tus avances!

271071 gracias por modificar y adaptar el ejemplito del dac!!!me alegra que estos ejemplitos sirvan!y la verdad que te has adelantado, por motivos de viaje no pude subir el programa del a/d jeje que funciona como voltimetro!jeje veo que lo has expuesto tu y me alegro!

La "mini-libreria" pcf8591 no es exactamente una libreria ya que, bueno no es muy configurable, eso si, "mini" si que es ya que es lo minimo para poder usar dicho componente, para su ampliacion deberia retocarse un par de cositas nada mas, por eso no la puse en un hilo aparte como el caso del dispositivo saa1064.

Para poder descargar tus archivos debes subirlos al almacen y despues poner aqui la direccion de descarga de los mismos, y para la imagenes en proteus pues "casi" igual, sube la imagen en algun "almacenador de imagenes" y despues las enlazas aqui.

Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 30 de Marzo de 2006, 13:06:00

No te preocupes amigo 271071 no me incomodan las sugerencias, todo lo contrario me alegran!!!

1)El oscilador interno sive para librerar los dos pines donde deberiamos conectar el oscilador ordinario(cristal, reloj externo, red RC), con eso ahorramos componentes en nuestros proyectos y obtenemos dos pines mas por el puerto A para poder ser usados por nosotros, es cierto que el 16F84A no tiene oscilador interno, pero varios pic"s de la familia 16F si lo tienen como el caso de nuestro pic, y el 16F88, etc etc. Para que los programas funcionen igual simplemente indicale al programador el oscilador que vas a usar, eso se realiza en la parte #fuses....Añadir que para el 16F648A el oscilador interno es configurable de 4MHz y de 48KHz creo recordar....

2)Lo de la maxima corriente que admite es 25mA, segun pone en el data sheet del dispositivo, para manejar cargas de la red pues deberas usar un optoaclopador como bien dices tu, si vas a trabajar con tensiones de mas baja tension pues un optoaclopador tambien vale, sino puedes realizarte un circuito reductor de voltaje, pero ya seria enredar la maraña, o un zener, o los dispositivos que mantienen finja un voltaje, en este caso nu pude ser superior a 5v o la entrada se quemara.

3)Bueno mirate el programa que voy a postear que es supongo que hace lo mismo que el vuestro(un voltimetro digital) y lo comparais, yo cuando tenga algo de tiempo(me despeje de mis vacaciones jeje) lo revisare y haber que pasa.

4)Ummmm no tengo ningun ejemplo pero estoy en ello con varios dispositivos I2C, una memoria, el expandor del bus i2c y el conversor....cuando lo termine lo posteare, pero vamos, no es dificil como bien dices, los pines A2A1A0 del dispositivo i2c debes conectarlos de distinta forma, por ejemplo tres memorias eeprom, la primera memoria los tres pines a masa A2A1A0 a GND(valor logico 000), la segunda memoria los pines a la alimentacion(111) y la tercera no se donde quieras(A2A1A0 110 por ejemplo), cuando realices la llamada a cada dispositivo deberas enviar en el comando de start la direccion al dispositivo donde queremos acceder y listo.

5)Ejemplos con sensores no tengo, ya que saldria de la tematica de este post, pero si he trabajado con algunos sensores que has citado y bueno, decirte que en el subforo de robotica hay varios programnas y proyectos con la mayoria de los sensores que has citado, es mas, el ultimo sensor que has citado, el amigo RedPic hizo un proyecto, aqui te dejo su enlace:Medidor de distancias mediante Ultrasonidos SFR04

6)Si que he trabajado con dicho bus, y es mas, antes de irme de vacaciones estaba realizando una libreria para la implantacion de dicho bus 1-wire de dallas, haber si le doy el par de retoques y para el mes que viene lo subo con elk ejemplo del ds1822 y el ds18s20

7)El grabador TE-20SE fue mi primer grabador!!!jeje compatible con el JMD es barato y facil de montar, aunque en el subforo de programadores hay un grabador realizado por los amigos de este foro que es estupendo GTP en todas sus versiones.

8)Como dije en el anterior post no es en si una libreria, es como la llamo yo jeje una "mini-libreria" ya que la realice para estos programas que puse con su uso concretamente, aunque se puede retocar y convertirse en una libreria con todas sus letras jeje, las librerias del display y del teclado no son mias, por eso no estan comentadas, la del dispositivo ds1620 la hice en el tren y dije jeje que la tenia que revisar y todavia no lo he hecho, mas que nada porque creo que hay nuevos dispositivos que hacen al ds1620 algo obsoleto y por eso no le he vuelto a meter mano, aunque lo hare, la verdad que simplemente falta ajustar la entrega de datos...y con respecto a la del dispositivo SAA1064, decirte que si esta explicada creo que al milimetro jeje es mas, abri un post distinto para presentarla al foro, aqui te dejo el link SAA1064

No te preocupes por los errores ortograficos jeje mientras se te entienda no hay problema!!!jeje de nuevo darte las gracias por usar estos programillas!!!

Suerte!!! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 30 de Marzo de 2006, 13:09:00

Holaaa!!!aqui el programita que usaremos con la "mini-libreria" pcf8591 pero esta vez configurada como A/D, este programa es el tipico del voltimetro digital!:
////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"06
//                   13/Marzo/06
//                   vszener@gmail.com (http://mailto:vszener@gmail.com)
//
//   Programa:   Manejo del dispositivo PCF8591 en modo A/D
//   Version:   0.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.242
//   Entorno IDE: MPLAB IDE v7.31      Simulador:    Proteus 6.7sp3
//
//   Notas: Este programa muestra el voltaje de entrada por el AIN0 en formato simple
//       de un potenciometro.
//       La Vref es de 2,5v por lo tanto la resolucion del conversor es 10mV.
//       Se configura el dispositivo con 4 entradas analogicas simples y no hay
//       auotincremento. La lectura se realiza mediante el desbordamiento del timer0
//       aproximadamente cada 65.5ms. Al ser la resolucion 2,5v, el voltaje maximo
//       puede medir es de 2,5v. Mediante software se intenta mejorar la aproximacion
//    de la señal obtenida, se multiplica por 0.009803 para mostrar el dato en su
//    forma decimal y mejorar su resolucion, tener en cuenta que el dato leido
//       por el pcf8591 es el voltaje de un potenciometro y su valor oscila entre
//       0-2.5v. Para su representacion en forma decimal debemos efectuar la operacion
//       anteriormente mencionada ya que si no lo hicieramos se mostraria por pantalla
//       un numero entero(para 2,5v se mostraria 255).
//
//       Conexiones:      A1 -> SDA pcf8591
//                     A0 -> SCL pcf8591
//                     B0 -> E LCD
//                     B1 -> RS LCD
//                     B2 -> RW LCD
//                     B4 -> D4 LCD
//                     B5 -> D5 LCD
//                     B6 -> D6 LCD
//                     B7 -> D7 LCD
//////////////////////////////////////////////////////////////////////////////////

#include <16f648a.h>               //pic a utilizar
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP      //ordenes para el programador
#fuses INTRC                     //oscilador interno
#use delay (clock=4000000)            //Fosc=4Mhz
#define use_portb_lcd TRUE
#include <lcd.c>                  //libreria para lcd
#define PCF8591_SCL PIN_A0            //definicion de pines...
#define PCF8591_SDA PIN_A1            //...de manejo del pcf8591
#include <vs_pcf8591.c>               //libreria pcf8591

///LLAMADA FUNCION INTERRUPCION
#INT_TIMER0
void interrupcion( )
{
   int dato;                              //almacena lectura del pcf8591
   float variable;                           //tratamiento de la informacion a representar

   dato=read_adc_value( );                     //lee del pcf8591
   variable=(float)dato*0.009803;                //se procesa la señal para su representacion
   printf(lcd_putc,"fTension: %1.2f V",variable);   //muestra por lcd
   lcd_putc("
   VsZeNeR"06" );

   set_timer0(0 );                           //carga TMR0
}

///PROGRAMA
void main(void)
{
   setup_oscillator(OSC_4MHZ);               //configuracion del oscilador interno a 4MHz

   enable_interrupts(INT_TIMER0);            //interrupcion TIMER0 activada
   setup_counters(RTCC_INTERNAL,RTCC_DIV_256);   //configuracion interrupcion TMR0

   lcd_init( );                           //inicializamos lcd

   set_timer0(0 );                        //carga TMR0 -> temporizacion maxima aprox 65.5ms
   enable_interrupts(GLOBAL);               //activadas interrupciones

   pcf8591_adc_init(0b00000000);            //inicializamos pcf8591 en modo D/A con entradas
                                    //entradas analog. simples
   while(TRUE){ }                        //bucle infinito
}

Bueno ya podemos con nuestro pic usar los convertidores!!!hasta otra!!! :wink:

Título: RE: Ejemplitos en C para 16F648A
Publicado por: pelusac en 31 de Marzo de 2006, 05:42:00

Maestro Vszener perdona mi desconocimiento ,pero haber si puedes dar una pequeña explicación del cálculo de la resolución que no tengo ni idea.
Gracias de antemano. Fumador

Título: RE: Ejemplitos en C para 16F648A
Publicado por: vszener en 31 de Marzo de 2006, 08:29:00

Buenas pelusac!, la resolucion del DAC, transforma el dato digital de entrada al DAC en su tension analogica de salida, segun sea el dispositivo a usar tendra una ecuacion u otra en este caso la del PCF8591 es la siguiente:

Codigo:

                         Vref - Vagnd
     Vaout =  Vagnd + ------------------  [ D0 · 2^0 + D1·2^1 +...+D7 · 2^7]
                              256

Del D0-D7 son los registros de datos del DAC y es el dato digital que nosotros enviaremos al dispositivo pcf8591 mediante la siguiente funcion:

Codigo:

     write_dac_value(dato); //salida analogica AOUT

Previamente definiremos la variable dato como un byte.
En el data sheet del dispositivo pcf8591 , concretamente en la pagina 8, la primera figura esta la formula de la resolucion, pero te voy a poner un ejemplo, ¿que tension de salida analogica por AOUT del dispositivo pcf8591 en modo DAC tendra, si Vref es de 2,56v y el pin AGND esta conectado a masa(0v), siendo el dato de entrada(D0-D7) 0b01001011?
El dato de enbtrada en decimal es 75(dato que queremos pasar a analogico)
Pues nos vamos a la formula que te puse antes de la resolucion:

Codigo:

                      2.56- 0
     Vaout =  0 + ------------------  [ 75] = 750mV = 0.75V
                       256

Si tienes alguna duda preguntamela!

Suerte!!! Giño

Título: RE: Ejemplitos en C para 16F648A
Publicado por: pelusac en 31 de Marzo de 2006, 10:47:00

Ninguna duda .Estupenda explicación, muy didáctica y tela de útil gracias. Fumador

Título: RE: Ejemplitos en C para 16F648A
Publicado por: pelusac en 04 de Abril de 2006, 11:27:00

No sé si este es el sitio adecuado para esto, pero ahí la va pregunta maestro Vszener.
En el caso de tener una fuente de alimentación regulable, pongamos de 0-24V o pon el voltaje que prefieras. Si quisiese mostrar el valor que adquiere la tensión por una lcd con el pcf8591 podría?. Por que si no me he enterado muy mal creo que el el voltaje máximo a interpretar viene definido por el voltaje de referencia.
En el caso de este dispositivo creo que el voltaje máximo de referencia puede ser hasta 8V. Si no es mucho preguntar, me gustaria saber, si es posible utilizar este dispositivo de voltímetro con estas tensiones mas elevadas, es decir, que el ajuste se realice por programa(cosa que tampoco sé y que ayudaría mucho un ejemplillo) o por lo contrario, que este dispositivo no sea el adecuado para este uso. loco

Me ayudaría mucho el comprender esta cuestión ya que me abriría las puertas hacia otras aplicaciones.
Gracias de antemano y espero no moleste este tipo de cuestiones que imagino que para la mayoria de los integrantes del foro son obviedades. Fumador

Título: Re: Ejemplitos en C para 16F648A
Publicado por: vszener en 20 de Abril de 2006, 13:49:57

Buenas!!!!joe ando bastante perdido por este post y ahora es cuando he leido tu mensaje!jeje, si se puede obtener medidas mayores, eso si tendriamos que añadir a la entrada circuitos amplificadores y demas para la correcta lectura, haber si termino con lo que estoy haciendo y vuelvo a postear mas ejemplitos que ya hay ganas!

Suerte!!! :wink:

Título: Re: Ejemplitos en C para 16F648A
Publicado por: vszener en 25 de Abril de 2006, 12:18:37

~~REMODELACION!!!~~

Bueno el indice a cambiado 'algo' ya que estoy en fase de remodelacion total jeje, antes todos los post apuntaban al foro de mi@ y por lo tanto el indice con la spaginas que apuntaba aqui eran erroneas, ya esta solucionado y todo los enlaces de paginas apuntan correctamente y a este foro(no al de mi@), vereis que hay varias opciones desactivadas, es decir, por ejemplo la descarga y en herramientas los programas en vb, estan desactivadas ya que tengo que subir los programas a este foro, en cuanto lo suba, actualizare nuevamente el indice para dejarlo como estaba....y tambien subire todos los programas con sus respectivas simulaciones a este foro y a este post!

Hasta pronto!!! :wink:

Título: Re: Ejemplitos en C para 16F648A
Publicado por: pelusac en 25 de Abril de 2006, 12:45:22

Como siempre realizando un impecable trabajo, gracias por la dedicación desinteresada y sigue así. :-/

Saludos desde triana en plena feria 8)

Título: Re: Ejemplitos en C para 16F648A
Publicado por: zimanka en 30 de Abril de 2006, 12:01:47

mi asunto es el siguiente

necesito desarrollar una comunicacion entre 4 pics, uno maestro y tres computadores si alguien me puede ayudar gracias

Título: Re: Ejemplitos en C para 16F648A
Publicado por: vszener en 30 de Abril de 2006, 12:39:48

Te aconsejo que crees un post nuevo con tu peticion, pero eso si, con mas informacion, el tipo d elenguaje a utilizar, el modo de comunicacion entre los pic's, la forma....

Suerte!!! :wink:

Título: Re: Ejemplitos en C para 16F648A
Publicado por: vszener en 25 de Mayo de 2006, 11:33:32

FIN DE LA REMODELACION!!!!

Decir que por fin he actualizado el post!!!!jeje y ya todos los ejemplitos estan disponibles en este mismo post para su descarga!

En el indice ya no aparece al lado de la pagina donde se encuentra el programa la opcion 'descarga' ya que los programas no estan alojados en otro link, sino que todos los programas estan donde indica la pagina!

Suerte!!! :wink:

Título: Re: Ejemplitos en C para 16F648A
Publicado por: vszener en 25 de Mayo de 2006, 11:41:21

Bueno y que mejor que despues de la actualizacion un ejemplito mas!!!jeje, este ejemplito se basa en la conexion de 4 saa1064 los cuales trabajan mediante el bus i2c, por lo tanto, este ejemplo ilustra como trabajar con el bus i2c con varios dispositivos, aparte este programa es interesante ya que simplemente con dos pines del pic conseguimos gobernar 16 display's de 7 segmentos!!!....aqui el codigo:

Código: C

////////////////////////////////////////////////////////////////////////////////////
//                                                      VsZeNeR'06              
//                                                  22/Mayo/06
//                                              vszener@gmail.com
//
//      Programa:       Manejo de 4 SAA1064 en modo DINAMICO -> 16 Display's 7seg
//      Version:        1.0
//
//      Dispositivo: PIC 16F648A                        Compilador:      CCS vs3.249
//      Entorno IDE: MPLAB IDE v7.31            Simulador:       Proteus 6.7sp3
//
//      Notas: Este programa muestra por 16 display's de 7seg mensajes de texto, para
//                 ello usamos 4 dispositivos SAA1064 de bus I2C.
//
//                 Conexiones:          A0 -> SDA saa1064                     
//                                                      A1 -> SCL saa1064       
//////////////////////////////////////////////////////////////////////////////////
 
#include <16f648a.h>                                    //pic a utilizar                        
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP             //ordenes para el programador 
#fuses INTRC                                                    //oscilador interno
#use delay (clock=4000000)                              //Fosc=4Mhz
#define SAA1064_DINAMICO                                //trabajar en modo dinamico el saa1064
#define SAA1064_SCL PIN_A1                              //definicion de pines...
#define SAA1064_SDA PIN_A0                              //...de manejo del saa1064
#include <vs_saa1064M.c>                                //libreria saa1064M
 
///PROGRAMA
void main(void)
{
        setup_oscillator(OSC_4MHZ);                     //configuracion del oscilador interno a 4MHz
        
        saa1064_init(0x76);                                     //inicializo saa1064 conectado a Vcc
        saa1064_conf(0b01110001);                       //21mA & NO parpadeo & Dinamico
        saa1064_putc(0x76,0x3F,0x38,0x77);      //HOLA
        delay_ms(1000);
        
        saa1064_stop();                                         //paro el saa1064 conectado a Vcc
        
        saa1064_init(0x72);                                     //inicializo saa1064 conectado a 3/8 Vcc
        saa1064_conf(0b00100011);                       //6mA & parpadeo 1&3 & Dinamico
        saa1064_putc(0x71,0x5C,0x50,0x5C);      //Foro
        delay_ms(1000);
        
        saa1064_stop();                                         //paro el saa1064 conectado a 3/8 Vcc   
        
        saa1064_init(0x74);                                     //inicializo saa1064 conectado a 5/8 Vcc
        saa1064_conf(0b01000101);                       //12mA & parpadeo 2&4 & Dinamico
        saa1064_putc(0x78,0x5C,0x5E,0x5C);      //todo
        delay_ms(1000);
        
        saa1064_stop();                                         //paro el saa1064 conectado a 5/8 Vcc
        
        saa1064_init(0x70);                                     //inicializo saa1064 conectado a GND
        saa1064_conf(0b00110111);                       //9mA & parpadeo TODO & Dinamico
        saa1064_putc(0x73,0x30,0x39,0x86);      //PIC!
        delay_ms(1000);
        
        saa1064_stop();                                         //paro el saa1064 conectado a GND
}

Para este ejemplo he modificado la libreria del dispositivo, asi mediante la direccion de cada dispositivo manejaremos el que queramos(hasta un maximo de 4 saa1064), la libreria modificada es la siguiente: vs_saa1064m.c (http://www.todopic.com.ar/foros/index.php?topic=4728.0)

Suerte!!! :wink:

Título: Re: Ejemplitos en C para 16F648A
Publicado por: vszener en 26 de Mayo de 2006, 06:59:26

Pues un ejemplito mas, aunque ya fue realizado uno similar, esta vez usamos la libreria correcta!!!el programa consta de un termometro digital usando el dispositivo ds1620, el cual se comunica con el pic mediante 3 pines(3-wire), aqui el programa:

Código: C

////////////////////////////////////////////////////////////////////////////////////
//                                                      VsZeNeR'06              
//                                                  23/Mayo/06
//                                              vszener@gmail.com
//
//      Programa:       Termometro digital mediante el ds1620
//      Version:        1.0
//
//      Dispositivo: PIC 16F648A                        Compilador:      CCS vs3.249
//      Entorno IDE: MPLAB IDE v7.31            Simulador:       Proteus 6.7sp3
//
//      Notas: Este programa muestra por el hyperterminal la temperatura leida
//                 del dispositivo ds1620.
//
//                 Conexiones:          A0 -> DQ ds1620               
//                                                      A1 -> CLK/CONV# ds1620
//                                                      A2 -> RST# ds1620       
//////////////////////////////////////////////////////////////////////////////////
 
#include <16f648a.h>                                    //pic a utilizar                        
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP             //ordenes para el programador 
#fuses INTRC                                                    //oscilador interno
#use delay (clock=4000000)                              //Fosc=4Mhz
#use rs232(baud=9600,xmit=PIN_B2,rcv=PIN_B1)    //manejo del RS232
#define DS1620_DQ               PIN_A0                  //declaracion...
#define DS1620_CLK              PIN_A1  
#define DS1620_RST              PIN_A2                  //...de pines para el ds1620
#include <vs_ds1620.c>                                  //libreria ds1620
 
///LLAMADA FUNCION INTERRUPCION
#INT_TIMER1
void interrupcion()     //leemos la temp y la enviamos via serial rs232 al hyperterminal
{
        printf("\fVsZeNeR'06 ->  Termometro Digital\n\r\n\rTemperatura: %3.1f ºC",read_ds1620());
}
 
///PROGRAMA
void main(void)
{
        setup_oscillator(OSC_4MHZ);                                     //configuracion del oscilador interno a 4MHz
        enable_interrupts(INT_TIMER1);                          //interrupcion TIMER1 activada
        SETUP_TIMER_1(T1_INTERNAL|T1_DIV_BY_8);         //configuracion interrupcion TMR1
        set_timer1(10);                                                         //carga TMR1
        enable_interrupts(GLOBAL);                                      //activadas interrupciones
        setup_uart(TRUE);                                                       //activamos la uart
        
        for(;;){}               //bucle infinito -> espera interrupcion del TMR1
}

Para la libreria del ds1620 visitad este link [LIBRERIA CCS] DS1620 (http://www.todopic.com.ar/foros/index.php?topic=12204.0)

Decir que el dispositivo ds1620 que trae PROTEUS no asume numero decimal, aunque la libreria si lo asume!!!

Suerte!!! :wink:

Título: Re: Ejemplitos en C para 16F648A
Publicado por: vszener en 26 de Mayo de 2006, 09:57:09

Buenas!!!! en el indice del post he puesto un enlace para la descarga directa de todos los ejemplitos y demas programas mios!!!
El enlace: VsZeNeR-Disco Duro Virtual (http://www.4shared.com/dir/436748/e883adee/sharing.html)

Lo disfruteis!!! :wink:

Título: Re: Ejemplitos en C para 16F648A
Publicado por: quirogaareal en 28 de Mayo de 2006, 10:12:16

Hola:
Este programita está basado en las enseñanzas de él maestro VSzener.
Acá hay un programa con el cual nuestra intención es testear sensores, al principio lo habíamos realizado con El pic 16F84a, pero evidentemente como este micro controlador no tiene la suficiente cantidad de memoria nos pasamos al 16F28, sin embargo no sé por qué razón, supongo que por la cantidad de memoria no me permite colocar variables globales. También me gustaría saber la forma, en realidad se cómo mandar por el puerto serial pero quiso o lo mande o imprima los datos cuando estos cambien y no estarlos enviando constantemente.

En cuanto a las representación que usamos esto fue, debido a que usando la representación de un número flotante nos consumía una gran cantidad de memoria. Si les es de ayuda esto se interpreta en la siguiente manera.

printf(lcd_putc,"V4:%d.%d",dato /100,(dato-(dato/100)*100)); //muestra por

Supongamos

dato = 211 (en realidad serían 2,11 volts), la primera parte imprime sólo la parte entera, dato /100 = 211/100 = imprime la parte entera o sea = 2.

Luego imprime la coma . El siguiente paso es la parte de decimal = dato-(dato/100)*100) que al solo imprimir la parte entera imprimirá el 11.

////////////////////////////////////////////////////////////////////////////////////
//
// 28/Mayo/06
//
// Programa: Manejo del dispositivo PCF8591 en modo A/D
// Version: 0.0
//
// Dispositivo: PIC 16F84A Compilador: CCS vs3.245
// Entorno IDE: MPLAB IDE v7.31 Simulador: Proteus 6.7sp3
//
// Notas: Este programa muestra como usar el conversor pfc8591 como adc.
// La Vref es de 2,56v por lo tanto la resolucion del conversor es 10mV.
// Básicamente lo que aquí hacemos es inicializar el conversor con la palabra
// de configuración y luego sólo resta leer (obviamente estamos modificando la
// tención analógica de entrada) sólo nos resta corregir un ligero error que es
// el que apenas pasa el valor de 128 en que se muestra valor negativo.
// Se muestra por pantalla de lcd(LM016L)
//
//
// Conexiones: RA1 -> SDA pcf8591
// RA0 -> SCL pcf8591
//
// lcd(LM016L)
// B0 -> E
// B1 -> RS
// B2 -> RW
// B4 -> D4
// B5 -> D5
// B6 -> D6
// B7 -> D7
// VSS y VEE -> gnd
// VDD ->VCC
//
// pcf8591
// A0,A1,A2.EXT , AGND ->gnd
// AN0,AN1,AN2,AN3 divisor resistivo con potenciometro (2.5v Variables)
// VREF=2.56 (en est6e caso)(pin14) divisor resistivo con potenciometro
//
//
//////////////////////////////////////////////////////////////////////////////////

/******************************************************/
/********** Programa Medidor de Presion con 16f628 ***/
/******************************************************/

#include <16f628.h> //pic a utilizar
#fuses XT,NOWDT,NOPROTECT,noPUT,nolvp//ordenes para el programador
#use delay (clock=4000000) //Fosc=4Mhz
#define use_portb_lcd TRUE
#include <lcd.c> //libreria para lcd
#define PCF8591_SCL PIN_A0 //definicion de pines...
#define PCF8591_SDA PIN_A1 //...de manejo del pcf8591
#include <vs_pcf8591.c> //libreria pcf8591
#use rs232(baud=9600, xmit=PIN_A2, rcv=PIN_A3) //manejo del RS232
///LLAMADA FUNCION INTERRUPCION

#INT_TIMER0

void interrupcion( )
{
int8 dato; //almacena lectura del pcf8591

dato=read_adc_value( ); //lee del pcf8591
lcd_gotoxy(9,2);
printf(lcd_putc,"V4:%d.%d",dato/100,(dato-(dato/100)*100)); //muestra por lcd, la ultima parte obedece solo
//a una forma de representar con enteros
printf("V4=%3u \t ",dato);//con esta parte se imprime en El puerto serial (RS232)

dato=read_adc_value( ); //lee del pcf8591
lcd_gotoxy(1,1);
printf(lcd_putc,"V1:%d.%d",dato/100,(dato-(dato/100)*100)); //muestra por lcd
//a una forma de representar con enteros
printf("V1=%3u \t ",dato);//con esta parte se imprime en El puerto serial (RS232)

dato=read_adc_value( ); //lee del pcf8591
lcd_gotoxy(9,1);
printf(lcd_putc,"V2:%d.%d",dato/100,(dato-(dato/100)*100)); //muestra por lcd
printf("V2=%3u \t ",dato);//con esta parte se imprime en El puerto serial (RS232)

dato=read_adc_value( ); //lee del pcf8591
lcd_gotoxy(1,2);
printf(lcd_putc,"V3:%d.%d",dato/100,(dato-(dato/100)*100)); //muestra por lcd
printf("V3=%3u \t ",dato);//con esta parte se imprime en El puerto serial (RS232)

set_timer0(0 ); //carga TMR0
}

///PROGRAMA
void main(void)
{

lcd_init( ); //inicializamos lcd

lcd_putc(" Medidor de \n Presion...");
delay_ms(2000);
lcd_putc("\f");

enable_interrupts(INT_TIMER0); //interrupcion TIMER0 activada
setup_counters(RTCC_INTERNAL,RTCC_DIV_256); //configuracion interrupcion TMR0

set_timer0(0 ); //carga TMR0 -> temporizacion maxima aprox 65.5ms
enable_interrupts(GLOBAL); //activadas interrupciones

pcf8591_adc_init(0b00000100); //inicializamos pcf8591

while(TRUE);//bucle infinito

}

Título: Re: Ejemplitos en C para 16F648A
Publicado por: quirogaareal en 28 de Mayo de 2006, 10:13:46

Ciertas dudas que nos quedan aún.

1) El único inconveniente que nos queda enviar los datos por RS232 es que no se o no encuentro en la manera de hacerlo que no sea en una forma constante, si el tratado con ciclos if pero en este caso de acuerdo a mi poca experiencia necesitaría una variable global cosa que me desborda la memoria.

Todo esto está diseñado con un PCF8591, cuyo librería fue diseñada por el mencionado maestro.

2) cómo se hace para grabar en un 24lc256 una tabla de datos a la cual acceder desde el pic.

3) se podría imprimir para ocupar menor cantidad de memoria, o llamar a una impresión de un cartel que esté adentro del 24lc256, como haría eso (cómo hago para grabar ese cartel en una memoria).

4) conocen algún otro conversador serial (I2C), de 12 bits, de 16 bits con una gran cantidad de entradas analógicas?.

5) hay alguna una forma de hacer un buen menú sin consumir demasiada memoria?

Título: Re: Ejemplitos en C para 16F648A
Publicado por: quirogaareal en 28 de Mayo de 2006, 10:14:58

Datos que quizás le sean de ayuda para quien está comenzando y tienen ciertos inconvenientes.

Un dato para quienes lo necesiten, hemos estado intentando grabar el micro controlador 16F628 con una grabadora TE20-SE pero esta presentada el inconveniente de que no nos reconocía el micro controlador mencionado a sí que consultamos en su página web www.jdm.homepage.dk/newpic.htm la cual nos sugirió que mandáramos RB4 a masa (ésta en el circuito está conectada a 5V), entonces cortamos las pistas de la grabadora mandamos el mencionado pin a masa e hicimos un puente de los otros pines que usaban la alimentación positiva y por arte de magia por así decirlo dicha y mencionada grabadora comenzó a grabar y a reconocer este buen micro controlador.

Para quien no tenga el circuito, ahí les adjunto las caras de las pistas, para otros detalles dirigirse a la página ya mencionada

Espero con esto retribuir, parte de todo lo que este foro me da y un agradecimiento especial al maestro Vszener por sus excelentes ejemplos

Título: Re: Ejemplitos en C para 16F648A
Publicado por: buho21 en 31 de Mayo de 2006, 15:47:03

Muy buenas! Saludos a todos!! Quisiera saber si estos códigos de programa para 16F648A sirven igual para el 16F873, pues es que no lo se y como se me ve estoy algo pegado en estos temas. He visto programitas que me podían servir, utilizando el 16F873 asociándolo con:
algo de motores y sensores
algo de memorias I2C
algo de conversion analogica/digital
algo de RS232

Si igual me podéis pasar algo sobre esto os lo agradecería mucho, gracias
verdiblanco19@hotmail.com

Título: Re: Ejemplitos en C para 16F648A
Publicado por: vszener en 02 de Junio de 2006, 11:27:40

Buenas!!!! amigo quirogaareal gracias por tener de referencias estos programas!!!, por partes:

1) No entiendo muy bien tu duda sobre como enviar los datos al hyperterminal via rs232, hay varios programas en este post donde la representacion de los datos es mediante el hyperterminal de windows via rs232, mirate el programa numero 58, donde los datos(obtenidos por el sensor de temperatura ds1620) se envian serialmente rs232.....sin necesidad de variable global....

2) Igual que puedes enviar los datos a una lcd o via serial o como quieras, tambien puedes guardarlo en memoria externa, una forma segura de guardar datos en memorias externas es el programa numero 52, donde se usa la memoria 24LC256

3) Puedes crear datos ya obtenidos desde una memoria externa como la que ya citas, para grabar la memoria puedes hacerlo mediante un grabador como el WinPic800 o el Ic-Prog.

4) Date un paseo por los fabricantes que seguro encuentras Dallas Semiconductor (http://para.maxim-ic.com/cache/en/results/4948.html), de Texas Instruments (http://focus.ti.com/analog/docs/dataconvertershome.tsp?familyId=82&contentType=4&DCMP=TIHomeTracking&HQS=Other+OT+home_p_dc)...

5) Con respecto al menu, me he dado cuenta que la representacion de datos siempre es la misma excepto los valores V1,V2.... simplemente no ponga una representacion para cada medida leida, lee los datos y llama a una funcion para la representacion, asi ahorraras tres printf.

Suerte!!! :wink:

Título: Re: Ejemplitos en C para 16F648A
Publicado por: vszener en 02 de Junio de 2006, 11:30:00

Se me olvidaba! gracias por poner la adaptacion del grabador t20, aunque seria mas conveniente que lo publicases en el subforo de programadores ya que alli se habla expresamente del tema y seguro que para los usuarios del foro le es mas util!

De nuevo darte las GRACIAS por usar los ejemplitos estos y por aportar tus programas!!!!

GRACIAS!!! :wink:

Título: Re: Ejemplitos en C para 16F648A
Publicado por: vszener en 02 de Junio de 2006, 11:32:04

Amigo buho21, decir que los programas valen para el pic que mencionas simplemente eso si, deberas ajustarlos!, si te miras el indice, comprobaras que hay bastantes programas/ejemplo para lo que tu deseas....

Suerte!!! :wink:

Título: Re: Ejemplitos en C para 16F648A
Publicado por: Veguepic en 02 de Junio de 2006, 19:22:54

Hola Vszener:

Viendo tus ejemplitos en C, y teniendo algo de tiempo quisiera pasar tus ejemplitos a asembler, de paso practico y aprendo. Me facilitaria mucho el usar tus simulaciones en Proteus.

Adicionalmente me interesa comparar cuanta es la diferencia de espacio que ocupa un programa en C y uno en asembler.

Saludos

Título: Re: Ejemplitos en C para 16F648A
Publicado por: vszener en 02 de Junio de 2006, 19:44:38

Pues por mi encantado! y de paso lo publicas, asi el foro tendra ejemplos en todos los lenguajes de programacion(asm, basic, c)....y GRACIAS por fijarte en los programitas!!!!

Suerte!!! :wink:

Título: Re: Ejemplitos en C para 16F648A
Publicado por: Veguepic en 02 de Junio de 2006, 20:12:06

Muchas gracias y ya empiezo hoy mismo a publicarlos.

Saludos

Título: Re: Ejemplitos en C para 16F648A
Publicado por: Simulpic en 22 de Junio de 2006, 05:44:35

Soy novato en esto y estoy siguiendo vuestros valiosos ejemplos porque se aprende mucho.

Tengo una duda con esto de las interrupciones. Estoy usando las interrupciones RB4..7 y simulandolo con MPSIM, lo que no entiendo es porqué
si elimino la linea "output_low(PIN_B0); " el programa siempre me entra a la interrupción. Esta instrucción pone a nivel bajo el flag?

Gracias

#include <16f648a.h> //pic a utilizar
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP //ordenes para el programador
#use delay (clock=4000000) //Fosc=4Mhz
#use fast_io(b)

///DECLARACION DE VARIABLES GLOBALES
int a; //

///LLAMADA FUNCION INTERRUPCION
#INT_RB //NOCLEAR

void IntPortB4_7( )
{
a++;

output_low(PIN_B0); //indicador interrupcion off NO ENTIENDO BIEN PORQUE HAY QUE PONER ESTA LINEA
}

///PROGRAMA
void main(void)
{

set_tris_b (0b11111110); //portb definido en binario, todos entrada menos pin B0 es salida
enable_interrupts(int_rb); //activar interrupcion rb4:7 cualquiera de ellos
enable_interrupts(GLOBAL); //activar interrupciones
for( ;; ){}

}

Título: Re: Ejemplitos en C para 16F648A
Publicado por: vszener en 22 de Junio de 2006, 10:08:25

La verdad es que no tendria por que entrar en la interrupcion, haber si en algunos de los pines del potB aparece un '1' logico el cual ejecuta la interrupcion.....de todas formas podrias poner el esquema del circuito, como veo que te basas en el ejemplito de las interrupciones del portb, veras que la instruccion de poner alto y en bajo el pin B0 es simplemente para indicar qie estamos en la interrupcion, asi que no infuye en la misma...

Suerte!!! :wink:

Título: Re: Ejemplitos en C para 16F648A
Publicado por: jfh900 en 22 de Junio de 2006, 19:13:33

Es normal que sea necesaria esa instrucción. Me explico: cuando trabajamos con interrupciones por nivel, necesitamos conocer el nivel anterior para comparale con la entrada actual y determinar si hay un cambio de nivel, esto se consigue mediante unos lanch. Cuando hay un cambio de nivel, se activa la interrupción y tenemos un valor distinto en el lanch que en la patilla correspondiente (por eso a saltado la interrupcion, por el cambio de nivel), el CCS no se preocupa de actualizar el lanch con lo cual si salimos de la interrupcion sin refrescar los lanch seguimos con distintos niveles en la patilla y en el lanch y se vueleve a disparar la interrupción. Como se refrescan los lanch, pues simplemente leyendo en los puertos correspondientes que estemos utilizando. Por eso es necesario poner:

input(PIN_B0);

Para que se actualicen los lanch. En el main se deberia realizar una lectura antes de activar las interrupciones para actualizar los lanch. yo uso el siguiente código:

Código: CSS

#asm movf PORTB,0 #endasm

Un saludo.

Título: Re: Ejemplitos en C para 16F648A
Publicado por: vszener en 23 de Junio de 2006, 08:35:37

Me parece que el amgino no habla de la interrupcion externa del pin B0, sino la interrupcion del puerto B de los pines 4 al 7, que en caso de algun cambio en ellos pues ocurre una interrupcion.

Suerte!!! :wink:

Título: Re: Ejemplitos en C para 16F648A
Publicado por: jfh900 en 23 de Junio de 2006, 10:08:21

Da igual sobre que pin se actue en la lectura, cuando se realiza un ciclo de lectura se refrescan todos los latch.

Un saludo.

Título: Re: Ejemplitos en C para 16F648A
Publicado por: vszener en 23 de Junio de 2006, 14:56:57

No es por marear la periz pero, ¿que tiene que ver la interrupcion del puerto b de los pines 4 al 7 con el refresco del pin b0 del puerto b? son cosas independientes, como bien has puesto en la foto, te indica que dicho refresco son sobre los pines 4 al 7, los mismos de la interrupcion, pero no del pin B0...

Suerte!!! :wink:

Título: Re: Ejemplitos en C para 16F648A
Publicado por: jfh900 en 23 de Junio de 2006, 16:59:04

Efectivamente no mareemos la perdiz. Si te has fijado, la señal que realiza el refresco es RD Port, osease lectura del puerto, siempre que se lee un pin del puerto se activa esta señal independiente del que se lea. Por otra parte si crees que no funciona con el bit B0, pues se cambia a B4 y ya esta, aunque estas discursiones no tienen sentido, se prueba y listo. Yo lo he probado y funciona, ya que me pasaba lo mismo que a Simulpic y lo solucione así y por otra parte me puedes explicar por que cuando quita la linea output_low(PIN_B0); deja de funcionar (que curioso el PIN_BO), yo he dado la explicación y lo he documentado con el esquema, puedes tu explicarlo de otra forma?.

Un saludo.

Título: Re: Ejemplitos en C para 16F648A
Publicado por: vszener en 24 de Junio de 2006, 07:19:03

Bueno sin entrar en polemicas, simplemente a favor de la ciencia para llegar a la verdad absoluta (jeje).....por partes:

1. La señal de refresco efectivamente es la lectura del puerto, eso si, si te fijas tambien es la lectura del puerto para los pines de la interrupcion, concretamente los pines B4, B5, B6 y B7. Se, ya que eres asiduo al foro, de que sabes de estos 'cacharros' bastante, pero no se si se te ha pasado o simplemente no te has dado cuenta, de que los pic's poseen una interrupcion la cual consiste en generar una interrupcion al cambio de estado de cualquier pin comprendido entre el 4 y el 7 del puerto b, esta interrupcion es la llamada interrupcion del puerto b, la cual es independiente de la interrupcion externa(la cual consiste en generar una interrupcion por el pin B0 del puerto b).

2. Con respecto a si creo que no funciona con el pin B0 y que lo cambie al pin B4, pues no es que no lo crea, es que simplemente estas hablando de cosas diferentes, como bien dice el apartado 1. , la interrupcion externa(producida por el cambio de estado del pin B0) es independiente a la interrupcion del puerto b(generada por los pines del 4 al 7 del puerto b), por lo tanto no vale como respuesta el cambiar de pines ya que no estariamos hablando de la misma interrupcion.

3. Estoy contigo de que la mejor manera es probarlo, por eso mismo el amigo Simulpic ha preguntado esa duda o ese problema que tiene él, porque se ha basado en uno de los ejemplos que esta en este post, concretamente es el ejemplo numero 48 que lo realize el dia 15/Noviembre/05, y dicho ejemplo consiste en utilizar la interrupcion del puertob comprendida por los pines 4 al 7, y es mas, dicho ejemplo consiste en mostrar como saber que pin de dicha interrupcion produce la propia interrupcion. Por lo tanto, yo no hablo sin probar las cosas, es mas el programa lo realice yo.

4. Con respecto a la instruccion output_low(PIN_B0);, ¿para que esta? ¿por que se puso en el ejemplo numero 48 que trata de la interrupcion del puerto b? pues sencillamente, nos podriamos ir al ejemplo numero 48(el cual esta en la pagina 12 de este mensaje) y veriamos que alli donde esta escrito yo comento parte del funcionamiento del programa, y en ese parrafo donde comento parte del funcionamiento del programa digo lo siguiente:

Código: [Seleccionar]

Buenas!!!!bien, el programa de hoy se basa en las interrupciones producidas al cambio de estado por uno de los pines del portb dedicados a dicha tarea, los pines que generan interrupcion son <4:7>. El programa en si realiza la secuencia de luces del coche fantastico con 4 led"s hasta que uno de los pines <4:7> cambia de estado del port b, entonces genera una interrupcion y realiza una secuencia de iluminacion de los led"s distinta, [color=red]aparte cada vez que estemos en una interrupcion se iluminara el led conectado al pin b0[/color]....bueno aqui el codigo!:

Por lo tanto que el pin B0 entre en juego en este programa es simplemente para mostrar al que lo simula o lo monte, que cuando cambie algun estado de los pines 4 al 7 del puerto b, se iluminara el pin B0 para decir al usuario que estamos dentro de la interrupcion y en el momento de haber realizada dicha interrupcion se apagara dicho pin B0 para decir al usuario que ya no estamos en la interrupcion, sino en el programa principal. Por eso mismo la instruccion output_low(PIN_B0); aparece en el programa porque al entrar en la interrupcion esta la instruccion output_high(PIN_B0);. Y no esta para nada mas que para eso, para indicar que estamos dentro o fuera de la interrupcion.

5. Con respecto a la documentacion y al esquema me parecen fabuloso que lo hagas, pero veras que el esquema trata de los pines 4 al 7, indicas en dicho esquema que para el refresco se usa la lectura del puerto b entero, claro que si, pero si te vas al data sheet del 16F648A (http://ww1.microchip.com/downloads/en/DeviceDoc/40044D.pdf) concretamente en la pagina 38(para el adobe, la pagina 36 para el data sheet) te dice que la lectura del puerto b se realiza para compararla con el estado d elo spines 4 al 7 del puerto b para ver si alguno de ellos cambia su estado y asi producir la interrupcion, pero no vale para nada mas, y en este caso el pin b0 no interviene sino simplemente los pines b4, b5, b6 y b7.

6. Para seguir documentando la explicacion y el ejemplo, el programa numero 48 como bien he mencionado ya, se basa en la interrupcion del puerto b(los cuales intervienen los pines del 4 al 7 del mismo puerto), y se basa tambien en decir al usuario que pin genero dicha interrupcion(no nos olvidemos que los pines que pueden generar la interrupcion son los pines b4,b5,b6 y b7), dicho ejemplo, como bien comento cuando lo escribi, esta en parte, sacado de la ayuda del compilador CCS, concretamente si te vas a la help del CCS (http://www.ccsinfo.com/downloads/ccs_c_manual.pdf), en la pagina 267(para el adobe, 255 para el compilador) veras que te dan un trozo de codigo para indicar que pin de la interrupcion del puerto b genera dicha interrupcion(recordar por n-esima vez que los pines para la interrupcion son simplemente los comprendidos entre el pin 4 y el 7) y veras que dicho codigo no interviene para nada el pin B0 pero si se usa la lectura del puerto b entero pero para manejarlo simplemente para los pines b4, b5, b6 y b7(esto es asi, ya que resulta mas facil leer el puerto entero que pin a pin), y veras en dicho trozo de codigo que esta en el manual del compilador que la instruccion output_low(b0); no aparece por ningun lado, claro esto es asi ya que esa instruccion la puse yo en el programa mio para indicar, como ya he mencionado, cuando estamos dentro de la interrupcion.

7. Imaginate que para generar la interrupcion sea de flanco de subida a flanco de bajada del pin, la instruccion output_low(b0); siempre generaria una interrupcion segun tu explicacion, por lo tanto algo esta mal....

En resumen, me parece que te has confundido de interrupcion, no es la interrupcion externa que si maneja en pin b0, en este caso estamos tratando la interrupcion del puerto b que maneja los pines b4, b5, b6 y b7, por lo tanto el pin b0 no interviene, ya que en el caso de intervenir tendriamos una interrupcion menos, imaginate que tenemos un programa que usa tanto la interrupcion externa(es decir el cambio de estado del pin b0) como la interrupcion del puerto b(es decir, el cambio de estado de los pines 4 al 7) y ademas, que el pin b0 este configurado para generar una interrupcion cuando cambie de '1' a '0' logico, segun tu explicacion al poner output_low(b0); al termino de la interrupcion del puerto b(los pines del 4 al 7 del puerto b) generaria segun el punto 7 de mi explicacion una interrupcion externa, ¿pero seria externa o de software? seria de software, por lo tanto esta mal tu explicacion.

Al amigo Simulpic, no le funcionara bien porque al simularlo, seguro que algun pin del puerto b(pines comprendidos unicamente del 4 al 7 ambos inclusive) cambiaran de estado, produciendole una interrupcion.

Y no quiero con esto entrar en polemicas contigo, amigo jfh900, sino dar mi explicacion de como creo que es.

Suerte!!! :wink:

Título: Re: Ejemplitos en C para 16F648A
Publicado por: jfh900 en 24 de Junio de 2006, 08:22:24

Por supuesto que no estamos entrando en polémicas, solo estamos dando nuestra opinion sobre una cuestion planteada y esto lejos de ser malo es todo lo contrario.

Volviendo al tema, estamos hablando de cosas diferentes.

Yo lo que digo es que como se compara el valor actual del pin b4/b7 con los valores de los lantch que han guardado el estado anterior, si se produce un cambio de nivel y se dispara la interrupción, hay que refrescar los lantch para que guarden el nuevo estado de los pines de entrada, y esto hay que hacerlo antes de salir de la interrupción, si no sigue habiendo un cambio de nivel y se vuelve a producir la interrupción. Como se logra refrescar los lantch mediante una lectura del puerto b, da lo mismo leer todo el puerto que un solo pin, por eso como las interrupciones se estaban produciendo en los pines b4/b7 yo leia el pin b0 que por ser del puerto.

Y como veo que has echo los deberes y te has leido el datasheet yo te pongo lo que dice el datasheet al respecto:

This interrupt can wake the device from SLEEP. The
user, in the Interrupt Service Routine, can clear the
interrupt in the following manner:
a) Any read or write of PORTB. This will end the
mismatch condition.
b) Clear flag bit RBIF.
A mismatch condition will continue to set flag bit RBIF.
Reading PORTB will end the mismatch condition and
allow flag bit RBIF to be cleared.

Donde especifica claramente como borrar la interrupcion. El problema es que el CCS solo borra el flas RBIF antes de salir de la interrupción y no actualiza los lantch, con lo que se produce un bucle infinito en la interrupción.

Un saludo.

Título: Re: Ejemplitos en C para 16F648A
Publicado por: vszener en 24 de Junio de 2006, 13:06:26

Bueno parece que ya vamos centrando el problema cada vez mas jeje, supongo que ya tenemos claro que la instruccion output_low(pin_b0); no interviene para nada en la interrupcion del puerto b(pines del 4 al 7), como bien has puesto, para terminar la interrupcion del puerto b <4:7> debemos realizar las operaciones:

a) Leer o escribir en el puerto b, y asi se eliminara la condicion de error. Quizas por eso el escribir en el pin B0 hacia que no se volviera a la interrupcion(aunque a nivel de programacion usar dicha instruccion para tal fin es un error).

b) Limpiar el bit indicado de la interrupcion RBIF

Aparte apunta y aclara el manual que en caso de condiciones de error, hagamos una lectura del puerto b para que el bit indicador de la interrupcion vuelva a su estado normal.

Bien, con estos datos en la mano vamos al lio:

1. El programador no debe realizar estas instrucciones cuando esta trabajando en lenguaje de medio/alto nivel, ya que es el compilador el que lo hace o debe hacer por uno mismo, indicas que el compilador CCS simplemente limpia el bit de la interrupcion RBIF, la verdad que no lo se, es cuestion de mirar el archivo .list que genera para ver su codigo asm, en cuanto este en mi ordenador con mis archivos lo vere y lo probare, pero volver a recalcar que poner la instruccion output_low(pin_b0); en caso de que el compilador tenga un fallo de fin d ela interrupcion es un error.

Bien, llegando a este punto aclarar y volver a recalcar que la instruccion o el manejo del pin b0 no interviene en la interrupcion del puerto b <4:7>, en caso de que el compilador no tenga en cuenta el punto a) que indicas y simplemente tenga en cuneta el punto b), pues tendra problemas cuando surgan condiciones anomalas como bien indica el data sheet del dispositivo, por lo tanto estamos ante un fallo del compilador....a la espera de confirmar esto para la semana que viene que estare en mi ordenador con mis archivos, corto y cambio.

Suerte!!! :wink:

Título: Re: Ejemplitos en C para 16F648A
Publicado por: jfh900 en 24 de Junio de 2006, 14:12:30

Efectivamente ya se va centrando el tema, pero debo de aclarar que yo en ningun caso he dicho que para refrescar los lantch haya que poner output_low(pin_b0); eso estaba en un programa que Simulpic posteo y que no entendia para que servia. Yo lo que puse fue utilizar: #asm movf PORTB,0 #endasm que lo que hace es leer el puerto B y como hemos visto refrescar los lantch. Por que he hecho de esta forma?: en primer lugar como es una instrucción que hay que poner dentro del tratamiento de la interrupción, debe de ser lo mas corta ya rapida posible, por eso la pongo en ASM para que el compilador no ponga su tratamiento de entradas y salidas. Como ves lo que hago es leer el puerto b mediante la lectura del pin B0, ¿por qué el B0? pues por que es el primero numéricamente y como da igual leer uno que otro he seleccionado este. Un programa de prueba podria ser:

#include <16F84.h>
#fuses NOWDT,RC, NOPUT, NOPROTECT
#use delay(clock=4000000)

int nInd;
BOOLEAN lInterrupt;

#int_RB
RB_isr()
{
nInd++;
lInterrupt = TRUE;
#asm movf PORTB,0 #endasm
}

void main() {

nInd = 0;
lInterrupt = FALSE;

set_tris_a(0x0); // Todo salidas
set_tris_b(0xFF); // Todo entradas
output_a(0xFF);

setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);
enable_interrupts(INT_RB);
enable_interrupts(GLOBAL);

while(true)
{
if (lInterrupt==TRUE)
{
output_a(nInd);
lInterrupt = FALSE;
}
}
}

Podras ver todo lo comentado, si comentas y descomentas la línea: #asm movf PORTB,0 #endasm
y realizas una simulación en Proteus.

Un saludo.

Título: Re: Ejemplitos en C para 16F648A
Publicado por: vszener en 01 de Julio de 2006, 09:59:00

Buenas!!! lo prometido es deuda!!! como bien dice el amigo jfh900, el compilador de la casa CCS no hace un tratamiento de la interrupcion del cambio d elos pines del puerto b <4:7> correctamente, concretamente no realiza bien la tarea al abandonar la interrupcion, ya que ellos simplementen borran el flag de la interrupcion(el RBIF) y como bien indica el manual, debemos borrar ese flag pero aparte leer/escribir en el puerto b, asi que nuestro compilador se le 'ha olvidado' esa parte de leer en el puerto b, provocando asi una llamada continua de la funcion de interrupcion, para poner pruebas tenemos el programa del amigo jfh900, y aqui otro:

Este programa consiste en cuatro pulsadores conectados a la parte alta del puerto b, si son presionados cambiaran el estado del bit correspondiente del puerto b generando una interrupcion, en dicha interrupcion, incrementaremos una variable global la cual nos servira en el programa principal para encender led's, aqui el programa:

Código: C

////////////////////////////////////////////////////////////////////////////////////
//                                                      VsZeNeR'06              
//                                                 01/Julio/06
//
//      Programa:       Prueba Interrupcion debido a cambio de estado del portb <4:7>
//      Version:        0.0
//
//      Dispositivo: PIC 16F648A                        Compilador:      CCS vs3.249
//      Entorno IDE: MPLAB IDE v7.40            Simulador:       Proteus 6.9sp4
//
//      Notas: Este programa se encarga de ver si el compilador de la casa CCS no desactiva
//                 correctamente la interrupcion del puerto b, para ello debe:
//                              1. Leer el puerto del puerto B
//                              2. Borrar el bit de la interrupcion(bit RBIF)
//                 Cada vez que hay un cambio de estado en los pines del puerto B <4:7>
//                 se producira una interrupcion, la cual incrementa una variable que se utilizara
//                 en el programa principal para mostrar la iluminacion de led's. Aparte, 
//                 cada vez que se produzca una interrupcion se iluminara un led conectado al pin
//                 A4 que se apagara cuando salgamos de dicha interrupcion.
//
//                 Conexiones:          A0 -> A dec 4028                      
//                                                      A1 -> B dec 4028
//                                                      A2 -> C dec 4028
//                                                      A3 -> D dec 4028
//                                                      A4 -> led indicador de interrupcion                     
//                                                      B4 -> boton             
//                                                      B5 -> boton               
//                                                      B6 -> boton           
//                                                      B7 -> boton     
//
//                 Conclusion:  El CCS no realiza bien el tratamiento de la interrupcion 
//                                              del portB, por lo que tendremos que leer/escribir algun pin 
//                                              del portB o el puerto entero.
//////////////////////////////////////////////////////////////////////////////////
 
#include <16f648a.h>                                    //pic a utilizar                        
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP             //ordenes para el programador 
#fuses INTRC                                                    //oscilador interno
#use delay (clock=4000000)                              //Fosc=4Mhz
#use fast_io(b)
#use fast_io(a)
 
 
///DECLARACION DE VARIABLES GLOBALES
int variable=0;         
 
///LLAMADA FUNCION INTERRUPCION
#INT_RB
void IntPortB4_7()
{                                       
        output_high(pin_a4);            //indicador de interrupcion on
 
//Activar la linea de abajo para ver los cambios!!!     
//      while(!input(PIN_B4) || !input(PIN_B5) || !input(PIN_B6) || !input(PIN_B7));    //elimina rebotes
//en caso que funcione el ccs no deberia abordar de nuevo la interrupcion hasta un cambio de estado
//de cualquiera de los pines <4:7> del portb. El CCS falla, por lo que si tenemos la linea de lectura/escritura
//del puerto b(o alguno de sus pines) desactivada siempre nos entrara en la interrupcion!
 
        variable++;                                     //incrementamos variable
        
        if(variable>0b00001001)         //¿se ha iluminado el ultimo led?
                variable=0;                             //SI -> reset variable
        
        output_low(pin_a4);                     //indicador interrupcion off
}
 
///PROGRAMA
void main(void)
{
        setup_oscillator(OSC_4MHZ);             //configuramos el oscilador a 4MHz
 
        set_tris_a (0x00);                              //porta salida
        set_tris_b (0xFF);                              //portb entrada 
        
        enable_interrupts(int_rb);              //activar interrupcion rb4:7
        enable_interrupts(GLOBAL);              //activar interrupciones
        
        output_low(pin_a4);                             //indicador de la interrupcion off
 
        do{                                                             //bucle...
                output_a(variable);                     //mostramos por el porta el valor de variable
                }while(TRUE);                           //...infinito
}

Bien, ahora vamos con las explicaciones, el programa tal como esta, si lo simulamos o lo montamos, nos enerara interrupciones siempre, ya que el CCS no realiza correctamente el fin de la interrupcion como es debido, para que funcione correctamente, debemos leer/escribir en el puerto b, vereis que en el programa hay una linea de codigo comentada, es esta:

Código: C

while(!input(PIN_B4) || !input(PIN_B5) || !input(PIN_B6) || !input(PIN_B7));    //elimina rebotes

Descomentadla y volver a simular o a cargar el archivo e el pic y ponerlo andar vereis que ya funciona correctamente, esto es debido a que dicha linea, aparte de eliminar los rebotes, lee el estado de alguno de los pines del puerto b, por lo que segun nos dicta el manual, cumplimos correcamente los pasos a seguir para desactivar la interrupcion del puerto b.

En CCS, existe otra funcion la cual limpia las interrupciones: clear_interrupt(level); , la he probado y simplemente borra el bir RBIF, por lo que no nos vale....

Asi que recordar que para un buen tratamiento de la interrupcion del puerto b, tendremos que leer/escribir en dicho puerto para no tener problemas, ya que nuestro compilador no nos hace el trabajo que deberia hacer.

Y con respecto al programa que el amigo Simulpic puso, decir y volver a repetir que la funcion output_log/high no tenia nada que ver en el funcionamiento del porgrama en si para el tratamiento correcto de la funcion de interrupcion, simplemente era de indicador de que la habiamos abordado, lo que pasa que al escribir sobre un pin del puerto b pues ya corregimos el error del CCS...

PD: Supongo que no es un error en si del CCS, quizas no puso la sentencia de lectura del puerto b porque es de esperar que en el abordaje de la interrupcion el programador vea que pin a realizado dicha llamada de interrupcion, por lo que ya estamos leyendo en el puerto b, aunque deberian indicarlo por algun lado...

Suerte!!! :wink:

Título: Re: Ejemplitos en C para 16F648A
Publicado por: jfh900 en 01 de Julio de 2006, 10:05:19

Totalmente de acuerdo con el mensaje. :)

Un saludo

Título: Re: RE: Ejemplitos en C para 16F648A
Publicado por: rage78 en 14 de Julio de 2006, 08:41:15

Cuando escribes:
printf(lcd_putc,"hola mundo ; )
VsZeNeR"05" ) ; //muestra por pantalla el mensaje

No entiendo muy bien la forma en que utilizas el printf:
- Creo que sobra un paréntesis, concretamente el 1º de cierre
- También sobra unas comillas, concretamente la que van entre VsZener y 05

Puede que me esté equivocando, pero en todo caso si está bien... ¿podrías explicarme el motivo?

Muchas grácias.

Título: Re: Ejemplitos en C para 16F648A
Publicado por: vszener en 14 de Julio de 2006, 10:24:37

Buenas!!!! exactamente sobra unas comillas doble (") las cuales estan entre VsZeNeR y el 05, por lo demas esta todo bien, lo que parece ser que paso, es que al cambiar a este nuevo foro, pues dicha instruccion no se copio correctamente, si te bajas el archivo para ver el programa y simularlo veras que la instruccion correcta es esta:

Código: C

printf(lcd_putc,"hola mundo ; ) \nVsZeNeR'05" ); //muestra por pantalla el mensaje

Veras que el primer parentesis de cierre simplemente sirve para conjuntamente con el punto y coma hacer el dibu del guiño, y comprobaras que no existe las segundas comillas entre VsZeNeR y 05, sino una comilla simple, aqui esta el mensaje original antes de ser traspasado a este nuevo foro, veras que tambien esta correcto:
Ejemplitos en C para el 16F648A en mi@ (http://miarroba.com/foros/ver.php?foroid=46840&temaid=4061462&pag=4)

Aconsejo que os bajeis los programas y veais el codigo, ya que estan compilados y simulados, gracias por avisarme!!!

Suerte!!! :wink:

Título: Re: Ejemplitos en C para 16F648A
Publicado por: umalrovi en 18 de Julio de 2006, 13:30:55

me sale este mensaje de error a la hora de ejecutar el programa rs232 & keypad.

SIMULATION LOG
==============
Design: C:\Documents and Settings\Alfonso\Escritorio\vs_rs232&keypad.DSN
Doc. no.: <NONE>
Revision: <NONE>
Author: <NONE>
Created: 17/09/05
Modified: 17/09/05

Compiling source files...
Processing vs_rs232&keypad.c...
NOT built - requires CCSC
N.B. 3rd party assemblers such as MPASM, ASEM51, ASM11 and AVRASM can be installed using the Proteus SETUP program.

Build FAILED with 1 error(s).

¿SabéIS de que puede ser?

gracias

Título: Re: Ejemplitos en C para 16F648A
Publicado por: vszener en 18 de Julio de 2006, 16:10:20

Eso es porque no tienes integrado CCS en PROTEUS, puedes hacer dos cosas:

1. Integrar el compilador CCS en PROTEUS, aqui en este post te puedes bajar un tutorial para tal fin: [MANUAL] Integrar CCS en PROTEUS (http://www.todopic.com.ar/foros/index.php?topic=12184.0).
2. Quitar el archivo para tener integrado el CCS en PROTEUS, para ello deberas seguir los siguientes pasos:
En el menu de herramientas: Source -> Add/Remove Source files ->Remove
Asi ya no tendras en el ejemplo para simular, integrado el CCS en PROTEUS.

Suerte!!! :wink:

Título: Re: Ejemplitos en C para 16F648A
Publicado por: Luis_Chogi en 22 de Julio de 2006, 01:32:59

Hola Vzener, tengo un problema con la lectura de un teclado matricial, lo que pasa es lo siguiente:

Trato de leer un teclado matricial para obtener un numero de dos digitos dentro de un ciclo, es decir que si yo presiono la tecla 1 y luego la 2, al final del ciclo obtenga yo el numero 12, esto lo quiero para que después de obtener este digito, ejecute un ciclo durante XX minutos, por ejemplo en este caso si presiono ‘1’ y ‘2’, yo ejecute un proceso durante 12 minutos (lo que yo estoy mostrando durante este tiempo es el voltaje de un potenciómetro conectado RA0). Sin embargo no eh podido obtener este numero, espero que me puedas ayudar (TU ERES MI IDOLO... ayudameeeeeee plis).

Codigo:

int unidad,decena,segundos;
char c;

// Llamo a la funcion para pedir los minutos
void pide_minutos(void){

   lcd_putc("\f Minutos:\n");   //imprimo mensaje en LCD

    for(k=0;k<=1;k++){ // Hago un ciclo para pedir dos numeros del teclado

do {         //espera a que pulse una tecla
         c=kbd_getc();
         }while(c==0);
switch (c)
{
case '0' : if (k=1) //Si es el segundo ciclo que la variable leida la ponga en unidad.
unidad=c;
else
decena=c; // Si el ciclo se ejecuta por promera ver que el valor leido lo ponga en decena
case '1' : if (k=1)
unidad=c;
else
decena=c;
case '2' : if (k=1)
unidad=c;
else
decena=c;
case '3' : if (k=1)
unidad=c;
else
decena=c;
case '4' : if (k=1)
unidad=c;
else
decena=c;
case '5' : if (k=1)
unidad=c;
else
decena=c;
case '6' : if (k=1)
unidad=c;
else
decena=c;
case '7' : if (k=1)
unidad=c;
else
decena=c;
case '8' : if (k=1)
unidad=c;
else
decena=c;
case '9' : if (k=1)
unidad=c;
else
decena=c;
default : if (k=1) //si leo * o # que en unidad o decena ponga 0
unidad=0;
else
decena=0;
}
}

decena=decena10; // multiplico decena por 10
segundos=decena+unidad; // y aquí termina el proceso pero no sale………….

}

Posiblemente mi problema esta en las variables pero no se.

Título: Re: Ejemplitos en C para 16F648A
Publicado por: vszener en 22 de Julio de 2006, 07:10:57

Buenas!!! sin estudiar bien el codigo, aqui hay un fallo de sintaxis en la sentencia if, te falta un igual, es decir, para comprobar si es igual o no, la sentencia if debe ser la siguiente:

Código: C

if (k==1){
                     codigo;
                }
               else{
                     codigo;
               }

Pruebalo asi y si no te funciona ya nos metemos de lleno en ver el codigo

Suerte!!! :wink:

Título: Re: Ejemplitos en C para 16F648A
Publicado por: Nocturno en 22 de Julio de 2006, 13:09:24

Mmmmm, no preguntes lo mismo en varios sitios hombre, que al final cruzamos las respuestas y queda todo muy guarreado:
http://www.todopic.com.ar/foros/index.php?topic=13041.0

Título: Re: Ejemplitos en C para 16F648A
Publicado por: Luis_Chogi en 23 de Julio de 2006, 03:03:52

si sorry nocturno, de todos modos ya tome tus consejos y pude hacer algo, me podrias dar tu opinion?, claro contestando en el otro link, y tambien gracias VZENER.

:D

Título: Re: Ejemplitos en C para 16F648A
Publicado por: rashii en 20 de Agosto de 2006, 05:59:42

Una pregunta, el esquema de los diodos y el rs232 funciona sin poner el max232? yo hasta ahora creia que siempre habia que usar el max 232 pero veo que ahi prescindes de el, un saludo.

Título: Re: Ejemplitos en C para 16F648A
Publicado por: vszener en 20 de Agosto de 2006, 08:08:09

¿A qué ejemplito te refieres?

Suerte!!! :wink:

Título: Re: Ejemplitos en C para 16F648A
Publicado por: rashii en 20 de Agosto de 2006, 10:33:44

A uno que pone rs232&leds, mas en concreto este:

Título: Re: Ejemplitos en C para 16F648A
Publicado por: cla_vnzla en 20 de Agosto de 2006, 18:34:03

Saludos a todos los de este foro en especial a vszener la cual le digo que es un tremendo maestro, yo le pediria que realizara mas ejemplos con matrices de led 7x5 y de mas de 4 caracteres para saber como poder multiplexarlos, gracias.

Un caluroso saludos desde Maracaibo Venezuela. :lol:

Título: Re: Ejemplitos en C para 16F648A
Publicado por: rashii en 21 de Agosto de 2006, 09:05:13

Otra duda que tengo y no entiendo es en el contador, pone esto:

// Notas: Contador del 0 al 9 cada 0,5s y vuelta a empezar. Tener en cuenta
// que hay que poner la directiva NOLVP para que el pin B4 sea de salida

¿Para que se necesita que el pin b4 sea de salida? no son todos de salida?

Un saludo y felicidades por el post

Título: Re: Ejemplitos en C para 16F648A
Publicado por: vszener en 21 de Agosto de 2006, 09:26:04

Buenas!!! En el montaje deberas añadir el max232, en las simulaciones se omite ya que no es necesario para probar el programa en sí y de esta forma se ahorra tiempo, de todas formas, en la pagina numero 7 (http://www.todopic.com.ar/foros/index.php?topic=4530.90) de este post, puse el primer ejemplo de manejo del hyperterminal con el respectivo max232 y aclaré que no es necesario para las simulaciones por lo tanto lo omitiría.

Gracias cla_vnzla por tu comentario!!!a ver si tengo algo de tiempo libre y me pongo manos a la obra!!!

rashii, los pines son bidireccionales siempre y cuando los programes para tal fin, debes mirarte el data sheet del microcontrolador a usar y programar los pines a las necesidades del programador y de la aplicación, hay que poner la instrucción NOLVP para indicar que queremos usar dicho pin como un periferico de entrada/salida.

Suerte!!! :wink:

Título: Re: Ejemplitos en C para 16F648A
Publicado por: rashii en 21 de Agosto de 2006, 11:25:28

gracias vszener, no habia leido lo del max232 en la otra pagina :)

Respecto a lo de que son bidireccionales si lo programas asi no lo sabia, creia que podian ser o solo de entrada o solo de salida, pero en ese caso, ¿para que quieres que sea de entrada y salida a la vez ese pin? ¿no te vale con que sea solo de salida si no tiene conectado ningun interruptor ni nada para leer? Un saludo

Título: Re: Ejemplitos en C para 16F648A
Publicado por: vszener en 21 de Agosto de 2006, 14:03:25

Me he explicado mal :? jeje, cuando digo que los pines pueden ser bidireccionales, me refiero a que s epueden programar de entrada o de salida, no que sean de entrada/salida simultaneamente, pero el pin RB4, si te miras el data sheet, para que sea un pin de entrada o de salida debemos desactivar la programación en bajo nivel, por lo tanto debemos especificar en el compilador en los fuses el novlp.

Suerte!!! :wink:

Título: Re: Ejemplitos en C para 16F648A
Publicado por: rashii en 21 de Agosto de 2006, 15:04:39

Gracias vszener, es que no lo encontre en el datasheet (son mas de 200 paginas)...pero ya me quedo claro, es que no entendia porque al principio no lo ponias en los primeros ejemplos y luego si, pero ahora con la respuesta me quedo claro, ya que al principio usabas lo de fast_io claro con eso no hacia falta pero luego con el standard_io si. Un saludo.

Título: Re: Ejemplitos en C para 16F648A
Publicado por: quirogaareal en 25 de Septiembre de 2006, 17:12:31

Hola :

Tendrias algun ejemplito de como manejar un variador de velocidad de motores?

Título: Re: Ejemplitos en C para 16F648A
Publicado por: manuelroin24 en 03 de Octubre de 2006, 19:47:12

Hola VsZener quisiera aprender mucho el C pero necesito alguna ayudita no entiendo mucho a que se debe los primeros comandos que se colocan por ejemplo cuando usas use_FAST_IO o cuando usas PUT o esta #bit RB1=0x106.1 no entiendo muy bien las directivas se me hace un mundo yo se porgramar en Assembler pero quiero aprender el C muchas gracias

Título: Re: Ejemplitos en C para 16F648A
Publicado por: cayograco en 04 de Octubre de 2006, 17:45:29

Señor VsZener:
Le pregunto si por casualidad ud. no dispondría de los ejemplos para teclado 4x4 y LCD dot matrix en assembly.

Perdone mi ignorancia, pero además de no contar con herramientas de trabajo en C, no es un lenguaje que maneje.

Algunos ya somos viejitos para incorporar un lenguaje más a nuestra cabeza.

Desde ya le agradezco la gentileza.

Hasta pronto.

Cayo Graco

Título: Re: Ejemplitos en C para 16F648A
Publicado por: vszener en 07 de Octubre de 2006, 06:24:55

Buenas!!!¿qué tal amigos? hacia tiempo que no me pasaba por este post!!!a ver...

quirogaareal: No tengo ningún ejemplito de manejo de variador de velocidad, aunque con el periférico PWM puedes usarlo, y en este post, sí hay programas de su uso.

manuelroin24: Seguro que cuando empieces te enganchas a este lenguaje, lo de fast_io es para la configuración del puerto, así el compilador no configurará cada vez que se utilize las funciones de entrada/salida del pin, sino que ya tomará la configuración que demos al principio del programa, lo de PUT es un fuse, mirate el data sheet o en los fuses del CCS, la de #bit estña explicada en la primera página de este post, es para definir el pin B1 del puerto B y así poder usarlo en el programa mediante la definición B1.

cayograco: De ASM no tengo muchos ejemplitos, aunque en el subforo de ASM si hay bastantes (y varios post abiertos de ejemplitos), de todas formas, aqui te paso un enlace donde podras encontrar bastantes cosas: link (http://personales.ya.com/cepalacios/Proteus.htm)

PD: Lo siento por la tardanza

Suerte!!! :wink:

Título: Re: Ejemplitos en C para 16F648A
Publicado por: vszener en 20 de Octubre de 2006, 13:28:09

Buenas!!! he retocado el índice para que cada programa/ejemplo tenga su enlace directo y no el enlace a la página dónde se encontraba el respectivo programa/ejemplo, de esta manera queda más ordenado y directo.

Suerte!!! ;)

Título: Re: Ejemplitos en C para 16F648A
Publicado por: manuelroin24 en 22 de Octubre de 2006, 22:18:04

Bueno este post me ayudo a aprender mucho el C esto no quiere decir que yasea un capo pero toy aprendiendo gracias VsZener aunque hay muchas cosas aun que me confunden jejejejeje ya estare molestandote

Título: Re: Ejemplitos en C para 16F648A
Publicado por: LABmouse en 13 de Diciembre de 2006, 19:56:01

vszener felicitaciones por tan organizado y buen trabajo.

Felicitaciones

:x) feliz navidad y prospero año nuevo.!

Título: Re: Ejemplitos en C para 16F648A
Publicado por: vszener en 15 de Diciembre de 2006, 21:19:51

Gracias por vuestras felicitaciones, es un gran honor el que este post os haya servido.

Feliz Navidad!!! ;)

Título: Re: Ejemplitos en C para 16F648A
Publicado por: marcos en 31 de Diciembre de 2006, 13:12:32

Ola VsZener,

Meu nome é Marcos , sou inicante nesta area e estou aprendendo muito com seus exemplos.
Estou procurando alguma coisa com o 12F629 ou 675 e não encontro.
Tenho duvidas quanto configuração do mesmo.
Se voce tiver, vc pode me mandar algum exemplo, qualquer coisa.

Desde ja fico grato

Feliz 2007

Marcos.

Título: Re: Ejemplitos en C para 16F648A
Publicado por: vszener en 31 de Diciembre de 2006, 13:18:02

¿Qué tipo de dudas tienes sobre ese micro? ¿qué tipo de ejemplo te gustariía?

PD: Todos estos ejemplitos se pueden adaptar a cualquier pic, simplemente hay que ver sus caracteristicas.

Suerte!!! ;)

Título: Re: Ejemplitos en C para 16F648A
Publicado por: marcos en 01 de Enero de 2007, 20:44:15

Ola VsZener,
Quanto a exemplos poderia ser qualquer um que me desse uma noção quanto as primeiras configuarações.

Sem mais ,

Marcos

Título: Re: Ejemplitos en C para 16F648A
Publicado por: quirogaareal en 02 de Enero de 2007, 09:24:36

Hola VsZener:

Mira estoy realizando una aplicacion batante grande y me ha entrado la duda de si puedo forza a ciertos pines a funcionar como PWM. A modo similar de como usas use portB_lcd_true (mas o menos asi).

Saludos desde Cordoba Argentina

Título: Re: Ejemplitos en C para 16F648A
Publicado por: vszener en 05 de Enero de 2007, 15:19:14

¿Te refieres a la instrucción #if....#endif? Usarla puedes usarla, ahora bien, esa instrucción es sólo para el compilador a la hora de compilar el programa, es decir, por soft debes indicar que pines van actuar como PWM y ya no s epodrá cambiar más hasta que se vuelva a compilar de nuevo.

Suerte!!! ;)

Título: Re: Ejemplitos en C para 16F648A
Publicado por: vszener en 05 de Enero de 2007, 15:20:40

marcos, puedes usar estos mismo esjemplos y adaptarlos al pic de la familia 12 que quieras, no es dificil pasar a esa familia, intenta el de encender y apagar un led.

Suerte!!! ;)

Título: Re: Ejemplitos en C para 16F648A
Publicado por: electronando en 22 de Febrero de 2007, 21:02:17

No se si estar poir alli vszener , hola disculpas pusistes una direccion donde se podrian
descargar un tutorial de enlace del ccs con el proteus pero al entrar aparecen cero archivos en todas las carpetas ,donde los puedo encontrar si no es molestia

Título: Re: Ejemplitos en C para 16F648A
Publicado por: vszener en 23 de Febrero de 2007, 13:23:48

Buenas!!! el disco virtual ya no está, lo volveré a poner pronto (en cuanto encuentre tiempecillo jeje)

Lo que ha pasado es tengo que ingresar como mínimo una vez al mes en la página esa donde estaba el disco virtual, no entré por descuido, y me han borrado la cuenta.

Suerte!!! ;)

Título: Re: Ejemplitos en C para 16F648A
Publicado por: electronando en 23 de Febrero de 2007, 13:55:53

ok Gracias por la ayuda :mrgreen:

Título: Re: Ejemplitos en C para 16F648A
Publicado por: J.C en 06 de Marzo de 2007, 12:51:05

me haria falta saber que espasio de memoria ROM y RAM te ocupo el programa del DS1302 con LCD saludos J.C

Título: Re: Ejemplitos en C para 16F648A
Publicado por: vszener en 07 de Marzo de 2007, 12:29:02

Te lo puedes bajar, y lo compilas y ya te da la información que requieres.

Suerte!!! ;)

Título: Re: Ejemplitos en C para 16F648A
Publicado por: mariano_pic en 09 de Marzo de 2007, 19:02:53

Hola VsZener, esta todo muy bien y los ejemplos muy buenos pero como me gustaria bajar todos los ejemplos y tenerlos para usarlos offline entre a tu disco duro virtual pero aparese en "0" todos los archivos. Entonses me preguntaba si no los as subido, todabia o los estas quitando, por favor cuentanos si los volveras a colocar en otro laddo o ahi mismo
muchas gracias

Título: Re: Ejemplitos en C para 16F648A
Publicado por: vszener en 10 de Marzo de 2007, 13:54:52

Los volveré a subir en ese mismo lugar lo antes posible.

PD: Disculpad las molestias.

Suerte!!! ;)

Título: Re: Ejemplitos en C para 16F648A
Publicado por: vszener en 16 de Marzo de 2007, 12:02:19

Ya está subido de nuevo los ejemplitos para que se puedan descargar todos conjuntamente, esta vez los he puesto en otro lugar, esta es la dirección:
http://www.box.net/shared/4l7bedpqrz

Suerte!!! ;)

Título: Re: Ejemplitos en C para 16F648A
Publicado por: lexer en 22 de Marzo de 2007, 00:43:14

Hola

Por favor si alguien me pouede ayudar, estoy haciendo pruebas con el ejemplito #52, Trato de escribir en la EEPROM, pero no lo está haciendo bien. Por ejemplo trate de escribir segun las instrucciones del programa en la direccion 00 la letra a (61 Hex), Estoy usando el compilador de CCS versión 3.249 integrado con Mplab 7.41, para simular el proteus 6.9 SP4. Anexo print screen

Título: Re: Ejemplitos en C para 16F648A
Publicado por: vszener en 23 de Marzo de 2007, 06:38:28

Si usas el mismo programa sin modificarlo, debe funcionar, ya que la escritura es en hexadecimal también.

Suerte!!! ;)

Título: Re: Ejemplitos en C para 16F648A
Publicado por: jeremylf en 31 de Mayo de 2007, 15:41:27

Hola Vszener, eres una gran persona al dar ejemplos asi para q la gente pueda aprender y entender gracias a tus explicaciones y dicho sea de paso me incluyo en ellos. Deverdad gracias a tus ejemplos e aprendido muchas cosas ya sea AD, EEPROM, etc... y queria agradecerte :-/ Enserio se agradace tanto esfuerzo de tu parte y lo mas importante el tiempo q te tomas para esto :o Gracias.

Ahora que me ha llegado los DS1302 q pedi e comenzado a probarlo cn tu ejemplo y dejame decirte q es un gran ejemplo (como los demas claro :mrgreen:), el problema q tengo esq yo uso el PIC18F2550 y nose si alterara algo el programa... creo q ay q configurar ago aqui:

Código: [Seleccionar]

setup_counters(RTCC_INTERNAL,RTCC_DIV_256);

Ya me habian hablado de esto pero no logro entenderlo muy y pues por eso creo q abra q modificarlo o algo no ¿? :? Tambien para el DS1302 uso un cristal de 455KH y se que en el datashet dicen q tiene q ser de 37,64KH si mal no recuerdo, por eso quiero saber cual usas tu y si este q uso alteraria algo. Y bien, el lcd y todo funciona pero al salir del menu d configuracion los segundos no avanzan o avanzan muy muy lentos y aveces toman valores en hexadecimal o almenos asi parece; ese es el problema q tengo, porsiacaso te dejo el proyecto q no e modificado nada solo pines y nada, todo lo entiendo... como aces esto y el otro :) :

Código: [Seleccionar]

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR'05      
//                     09/Septiembre/05
//                  vszener@gmail.com
//   Programa:   Reloj-Calendario DS1302
//   Version:   0.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.227
//   Entorno IDE: MPLAB IDE v7.21      Simulador:    Proteus 6.7sp3
//
//   Notas: Se muestra por pantalla de lcd(LM016L) la FECHA y hora obtenida mediante la
//         lectura del DS1302. Pudiendose modificar mediante los botones CONF/Ok y up.
//         Se utiliza variables globales:
//            ·day-> dia ds1302
//            ·mth -> mes ds1302
//            ·year -> año ds1302
//            ·hour -> hora ds1302
//            ·min -> minutos ds1302
//            ·sec-> segundos ds1302
//            ·menu -> variable que muestra opcion del menu CONFigurar
//            ·flag -> variable que cuenta hasta 130ms aprox.
//            ·var -> ajuste fino para que desborde cada 130ms aprox.
//         Se carga el TMR0 con 0 por lo tanto se desborda en 65ms aprox, queremos
//         visualizar y restaurar valores cogidos del ds1302 cada 130ms aprox por lo tanto
//         utilizamos una variable llamada flag que sera la encargada de dicha tarea.
//         Al inicio del programa debe ser CONFigurado el reloj, siendo el boton 'up' el
//         encargado de ir moviendose mediante las opciones del menu:hora,minutos,....
//         y el boton 'CONF/Ok' el encargado de CONFigurar el reloj(cuando estemos en modo ver
//         hora y FECHA) o el encargado de salir de la CONFiguracion de las opciones(cuando
//         estemos en formato de CONFigurar FECHA y hora).
//         Tener en cuenta que hay que poner la directiva NOLVP para que el pin B4 sea de 
//         salida. 
//   Conexiones:      A0 -> RST DS1302
//               A1 -> SCLK DS1302
//               A2 -> I/O DS1302
//               C7 -> Boton 'up'
//               A5 -> Boton 'CONF/Ok'
//               B0 -> E            
//               B1 -> RS         
//               B2 -> RW      
//               B4 -> D4        
//               B5 -> D5            
//               B6 -> D6   
//               B7 -> D7
//               B3 -> Zumbador(beep)                   
//////////////////////////////////////////////////////////////////////////////////

#include <18F2550.h>            //pic a utilizar          
#use delay(CLOCK=4000000)         //Fosc=4Mhz 
#fuses HS,NOPUT,NOPROTECT,NOBROWNOUT,NOLVP,NOWDT,NOMCLR   //comandos para el programador 
#use standard_io(c)
//#use standard_io(b)
//#define use_portb_lcd TRUE         //utilizar el port b para lcd 
#define RTC_SCLK PIN_C1            //A  definimos pin's...
#define RTC_IO   PIN_C2
#define RTC_RST  PIN_C0            //...de conexion de la rtc ds1302
#include <ds1302.c>               //libreria de rtc ds1302 
#include <lcd_F2550.c>                //libreria de lcd

///VARIABLES GLOBALES
byte day,mth,year,dow,hour,min,sec;   //variabes para ds1302
byte menu=0,flag=0,var=2;         //variables para menu CONFigurar

///DEFINICION DE FUNCIONES   
void CONFigurar(void);
void horas(void);               
void minutos(void);
void dia(void);
void mes(void);
void anio(void);
void beep(void);

///LLAMADA FUNCION INTERRUPCION
#INT_TIMER0
void interrupcion()
{
   if(flag>var){      //¿ya es 130ms aprox?
      var--;         //SI -> decremento var... 
      if(var==0)
         var=2;      //...ajuste fino de 130ms aprox
      flag=0;         //reset flag para contar 130ms aprox
      rtc_get_date(day,mth,year,dow);      //coge dia,mes,año
         rtc_get_time(hour,min,sec );      //coge hora,minuto,segundo
      printf(lcd_putc,"\fFECHA: %2X/%2X/%2X\nHORA: %2X:%2X:%2X",day,mth,year,hour,min,sec);   //lcd 
      }
      
   set_timer0(0);      //reset TMR0
   flag++;            //incremento variable flag
}

///PROGRAMA
void main(void){ 
   
   enable_interrupts(INT_TIMER0);            //interrupcion TIMER0 activada
   setup_counters(RTCC_INTERNAL,RTCC_DIV_256);   //CONFiguracion interrupcion TMR0
   set_timer0(0);                        //carga TMR0
   
   lcd_init();          //inicializa lcd
   rtc_init();          //inicializa rtc
   
   lcd_putc("RELOJ CALENDARIO\n   VZENER'05");   //presentacion...
   delay_ms(800);                           //...inicial
   
   CONFIGURAR();                        //ve a menu CONFIGURAR
   enable_interrupts(GLOBAL);               //activadas interrupciones
   
    for(;;){         //bucle...
      if(input(PIN_A5)==0){            //Si se pulsa CONF....
         while(!input(PIN_A5)){}         //elimina rebotes
         beep();
         CONFIGURAR();
         }                        //ve a menu CONFIGURAR
      }             //...infinito      
} 

///FUNCION CONFIGURAR
void CONFIGURAR(void){
   disable_interrupts(GLOBAL);               //desactivadas interrupciones
   
   do{
      switch(menu){
         case 0:   lcd_putc("\fCONFIGURAR\nHORAS?");      //horas
               if(!input(PIN_C6)){
                  while(!input(PIN_C6)){}
                  beep();
                  horas();
                  menu=1;                        //apunta siguiente opcion
                  }
               break;
         case 1: lcd_putc("\fCONFIGURAR\nMINUTOS?");      //minutos
               if(!input(PIN_C6)){
                  while(!input(PIN_C6)){}
                  beep();
                  minutos();
                  menu=2;                        //apunta siguiente opcion
                  }
               break;
         case 2: lcd_putc("\fCONFIGURAR\nDIA?");         //dias
               if(!input(PIN_C6)){
                  while(!input(PIN_C6)){}
                  beep();
                  dia();
                  menu=3;                        //apunta siguiente opcion
                  }
               break;
         case 3: lcd_putc("\fCONFIGURAR\nMES?");         //mes
               if(!input(PIN_C6)){
                  while(!input(PIN_C6)){}
                  beep();
                  mes();
                  menu=4;                        //apunta siguiente opcion
                  }
               break;
         case 4: lcd_putc("\fCONFIGURAR\nANIO?");      //años
               if(!input(PIN_C6)){
                  while(!input(PIN_C6)){}
                  beep();
                  anio();
                  menu=5;                        //apunta siguiente opcion
                  }
               break;
         case 5: lcd_putc("\fSALIR\nCONFIGURAR?");      //salir CONFiguracion
               if(!input(PIN_C6)){
                  menu=6;
                  beep();
                  }               
         }
         
      if(!input(PIN_C7)){            //controla el boton up...
         while(!input(PIN_C7)){}
         menu++;
         if(menu>5)
            menu=0;
         }                     //...para mostrar menu por lcd
         
      delay_ms(130);               //retardo para ver lcd
      }while(menu<6);
      
      menu=0;                                 //actualiza indices menu
      rtc_set_datetime(day,mth,year,dow,hour,min);   //nueva hora,minuto,...
      enable_interrupts(GLOBAL);                  //activadas interrupciones
      set_timer0(0);                           //carga TMR0
}
///FUNCION CONFIGURA HORAS
void horas(void){
   printf(lcd_putc,"\fCONF.HORAS:\nHORA: %2X:%2X:%2X",hour,min,sec);   //muestra por lcd
   do{
      if(!input(PIN_C7)){                  //¿se ha pulsado up?
         while(!input(PIN_C7)){}            //elimina rebotes
         hour++;                        //SI -> incremento hour
         switch(hour){                  //limites...
            case 0x0A:   hour=0x10;break;      
            case 0x1A:   hour=0x20;break;
            case 0x24:   hour=0x00;
            }                        //...hour
         printf(lcd_putc,"\nHORA: %2X:%2X:%2X",hour,min,sec);   //muestra por lcd hour
         }
      }while(input(PIN_C6));
   while(!input(PIN_C6)){}         //elimina rebotes
}
///FUNCION CONFIGURA MINUTOS
void minutos(void){
   printf(lcd_putc,"\fCONF.MINUTOS:\nHORA: %2X:%2X:%2X",hour,min,sec);   //muestra por lcd
   do{
      if(!input(PIN_C7)){            //¿se ha pulsado up?
      while(!input(PIN_C7)){}         //elimina rebotes
      min++;                     //SI -> incremento min
      switch(min){               //limites...
         case 0x0A:   min=0x10;break;
         case 0x1A:   min=0x20;break;
         case 0x2A:   min=0x30;break;
         case 0x3A:   min=0x40;break;
         case 0x4A:   min=0x50;break;
         case 0x5A:   min=0x00;
         }                     //...min
      printf(lcd_putc,"\nHORA: %2X:%2X:%2X",hour,min,sec);   //muestra por lcd min
      }
      }while(input(PIN_C6));
   while(!input(PIN_C6)){}         //elimina rebotes
}
///FUNCION CONFIGURA DIAS
void dia(void){
   printf(lcd_putc,"\fCONF.DIAS:\nFECHA: %2X/%2X/%2X",day,mth,year);   //muestra por lcd
   do{
      if(!input(PIN_C7)){               //¿se ha pulsado up?
         while(!input(PIN_C7)){}         //elimina rebotes
         day++;                     //SI -> incremento day
         switch(day){               //limites...
            case 0x0A:   day=0x10;break;
            case 0x1A:   day=0x20;break;
            case 0x2A:   day=0x30;break;
            case 0x32:   day=0x01;
            }                     //...day
         printf(lcd_putc,"\fCONF.DIAS:\nFECHA: %2X/%2X/%2X",day,mth,year);   //muestra por lcd day
         }
      }while(input(PIN_C6));
   while(!input(PIN_C6)){}         //elimina rebotes
}
///FUNCION CONFIGURA MES
void mes(void){
   printf(lcd_putc,"\fCONF.MES:\nFECHA: %2X/%2X/%2X",day,mth,year);   //muestra por lcd
   do{
      if(!input(PIN_C7)){               //¿se ha pulsado up?
         while(!input(PIN_C7)){}         //elimina rebotes
         mth++;                     //SI -> incremento mth
         switch(mth){               //limites...
            case 0x0A:   mth=0x10;break;
            case 0x13:   mth=0x01;
            }                     //...mth
      printf(lcd_putc,"\fCONF.MES:\nFECHA: %2X/%2X/%2X",day,mth,year);   //muestra por lcd
         }
      }while(input(PIN_C6));
   while(!input(PIN_C6)){}         //elimina rebotes
}
///FUNCION CONFIGURA AÑOS
void anio(void){
   printf(lcd_putc,"\fCONF.ANIO:\nFECHA: %2X/%2X/%2X",day,mth,year);   //muestra por lcd
   do{
      if(!input(PIN_C7)){               //¿se ha pulsado up?
         while(!input(PIN_C7)){}         //elimina rebotes
         year++;                     //SI -> incremento mth
         switch(year){               //limites...
            case 0x0A:   year=0x10;break;
            case 0x1A:   year=0x20;break;
            case 0x2A:   year=0x30;break;
            case 0x3A:   year=0x40;break;
            case 0x4A:   year=0x50;break;
            case 0x5A:   year=0x60;break;
            case 0x6A:   year=0x70;break;
            case 0x7A:   year=0x80;break;
            case 0x8A:   year=0x90;break;
            case 0x9A:   year=0x00;
            }                     //...year
      printf(lcd_putc,"\fCONF.ANIO:\nFECHA: %2X/%2X/%2X",day,mth,year);   //muestra por lcd
         }
      }while(input(PIN_C6));
   while(!input(PIN_C6)){}         //elimina rebotes
}
///FUNCION BEEP
void beep(void){
   output_high(PIN_B3);   //activa zumbador
   delay_ms(50);
   output_low(PIN_B3);      //desactiva zumbador
}

Lo de la modificacion de las letras (mayuscula/minuscula) de lo q se muestra por el LCD llo cambie porq en minusculas aveces ocurren errores :S Y lo de <lcd_f2550> es una moficacion q hice para q el lcd funcionara de eso no ay nada q preocuparse.

Ah cambie los pines de conexion del DS1302 y los botones pocierto :mrgreen:

Espero q me puedas ayudar :-) Gracias de antemano.
salu2 8) 8) 8)

Título: Re: Ejemplitos en C para 16F648A
Publicado por: jeremylf en 31 de Mayo de 2007, 20:32:50

Hola, disculpen el doble post pero esque regreso de comprarme el Cristal 32.768 q me piden en el datashet para el DS1302; lo cambie y el problema persiste... todo bien pero cuando salgo de la configuracion se demora como 1 minuto en ejecutar el Timer0 por asi decirlo; despues, los segundos avanzan al parecer bien pero en el lcd no se muestra o se muestra por partes, y si se muestra lo hace aveces en haxadecimal :?. Parece q el problema, como ya e dicho, esta en esta linea:

Código: [Seleccionar]

setup_counters(RTCC_INTERNAL,RTCC_DIV_256);

Dado q uso otro PIC (18F2550), aunq no estoy del todo seguro. Haber Vszener si me das una ayudita porfavor :lol: o quien sepa del tema, cualquier ayuda es bienvenida :)

salu2 8) 8) 8)

Título: Re: Ejemplitos en C para 16F648A
Publicado por: vszener en 01 de Junio de 2007, 09:31:28

Los pic's de la familia mejorada de 8-bits, es decir, los PIC18, el timer puede ser configurable de 8 o 16-bits, me parece que ese es el problema, que por defecto viene configurado a 16-bits, configuralo a 8-bits y ya el timer estará solucionado.

Suerte!!! ;)

Título: Re: Ejemplitos en C para 16F648A
Publicado por: jeremylf en 01 de Junio de 2007, 15:57:51

Cita de: vszener en 01 de Junio de 2007, 09:31:28

Los pic's de la familia mejorada de 8-bits, es decir, los PIC18, el timer puede ser configurable de 8 o 16-bits, me parece que ese es el problema, que por defecto viene configurado a 16-bits, configuralo a 8-bits y ya el timer estará solucionado.

Suerte!!! ;)

Y como hago eso? :? Disculpa mi ignorancia :$

salu2 8)

Título: Re: Ejemplitos en C para 16F648A
Publicado por: vszener en 01 de Junio de 2007, 17:59:44

Buenas!!! No pretendo ser gruñón, pero en la 'help' del compilador está todas las funciones del mismo y sus respectivas configuraciones, en este caso, la del timer0, sólo para la família PIC18 están estas dos nuevas configuraciones:

Código: C

PIC18XXX only: RTCC_OFF, RTCC_8_BIT

Por lo tanto, nuestra línea de código referente al timer0, debe quedar tal como sigue:

Código: C

setup_timer_0(RTCC_8_BIT|RTCC_INTERNAL|RTCC_DIV_256);

Así, diremos que configure el timer0 como timer interno, de 8-bits y un preescaler de 256, con lo que quedaría equivalente al de la família PIC16.

Suerte!!! ;)

Título: Re: Ejemplitos en C para 16F648A
Publicado por: jeremylf en 01 de Junio de 2007, 18:25:24

Gracias Vszener, disculpa mi ignorancia ^.^'

Bueno ahora todo bien, pero hay un pequeño problemita y es que cuando los segundos llegan al 10 enves de este aparece: 0A luego 0B, 0C, 0D, 0E, 0F y de ahi se pone en 10 y comienza recien en 11, 12... y asi pasa en el 20, 30... y por eso acaban los segundos en el 40 creo. ¿ Sabes q esta pasando ? :?

Ah, y me surge una preguntita y esque en el puerto B en el pin 5 puse un led para comprobar el funcionamiento, prendiendolo justo cuando salimos del menu de configuracion. Entonces, saliendo del menu configurar, este led comienza a oscilar contnuamente cada 250ms masomenos y bueno queria saber a q se debe esto :-) Ah y me acabo de dar cuenta q pasa lo mismo con los minutos :? supongo q tb para las horas sera igual y para los dias y eso :? :? :(

Gracias nuevamente :P
salu2 8) 8)

Título: Re: Ejemplitos en C para 16F648A
Publicado por: jeremylf en 02 de Junio de 2007, 14:20:57

Bueno, ya encontre el fallo y esq solo tenia q cambiar el %2X por %02u :-/ Si, estuv revisando la ayuda del CCS :-)

Gracias dnuevo Vszener por estos grandiosos ejemplos :o

salu2 8) 8) 8)

PD: Disculpn el doble post :mrgreen:

Título: Re: RE: Ejemplitos en C para 16F648A
Publicado por: zagoaristides en 29 de Julio de 2007, 13:22:05

Cita de: vszener en 05 de Septiembre de 2005, 06:01:00

Vamos con un ejemplito mas de manejo de lcd!!!esta vez haremos un contador de 0 a 9 y vuelta a empezar pero con un pulsador, es decir cada vez que presionemos el pulsador se mostrara el siguiente digito de nuestro contador hasta llegar a 9 que entonces si volvemos a pulsar el boton volvera a cero y se escuchara un beep del zumbador conectado al pic:

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"05
//                    27/Agosto/05
//
//   Programa:   Contador 0a9 por LCD con pulsador y buzzer
//   Version:   0.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.227
//   Entorno IDE: MPLAB IDE v7.21      Simulador:    Proteus 6.7sp3
//
//   Notas: Se muestra por pantalla de lcd(LM016L) un mensaje de inicio del programa
//        y se espera hasta que pulsemos el boton, entonces se borra pantalla y cada vez
//        que presionemos el boton se ira incrementando en un valor el digito mostrado en
//        la mitad de la fila 1º del lcd hasta llegar a 9 que entonces volvera a 0 y se
//     emitira un beep.
//        Tener en cuenta que hay que poner la directiva NOLVP para que el pin B4 sea de
//        salida.
//            ·tabNum[] -> vector donde se almacenan numeros del contador 0a9
//            ·i -> indice para vector tabNum
//   Conexiones:      B0 -> E
//               B1 -> RS
//               B2 -> RW
//               B4 -> D4
//               B5 -> D5
//               B6 -> D6
//               B7 -> D7
//               B3 -> Buzzer(beep)
//////////////////////////////////////////////////////////////////////////////////

#include <16f648a.h>            //pic a utilizar
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP      //ordenes para el programador
#use delay (clock=4000000)         //Fosc=4Mhz
#define use_portb_lcd TRUE         //definir portb lcd
#include<lcd.c>                  //libreria manejo lcd

///PROGRAMA
void main(void)
{
   char tabNum[10]={"0","1","2","3","4","5","6","7","8","9"},i=0;   //tabla y variable definida

   lcd_init();         //inicializa lcd
   printf(lcd_putc,"Presione boton
para contador0a9" );   //muestra mensaje inicio

   do{                     //espera hasta que se pulse boton...
   }while(input(PIN_A0)==1);
   printf(lcd_putc,"f" );      //...para borrar pantalla e iniciar contador

   printf(lcd_putc,"
         VsZeNeR"05" );   //auto publicidad en la 2ºfila lcd
   lcd_gotoxy(8,1);                  //vuelve 1ºfila lcd y apunta la mitad de la columna

   for( ; ; ){                     //bucle...
      if(!input(PIN_A0)){                  //¿se ha pulsado el boton?
         do{                           //SI -> eliminar...
         }while(!input(PIN_A0));            //...rebotes del boton
         if(i>9){                     //¿se ha mostrado digito 9?
            i=0;                     //SI -> restaura valor indice(para mostrar digito 0)
            output_high(PIN_B3);         //activa buzzer(beep)
            delay_ms(50);               //tiempo de escucha del beep
            output_low(PIN_B3);            //desactiva buzzer(beep)
            }
         printf(lcd_putc,"%c",tabNum[ i ]);   //muestra por pantalla el numero
         printf(lcd_putc,"" );            //retrasa el cursor una posicion(escribe encima)
         i++;                        //incremento contador indice tabNum
         }
      }                     //...infinito
}

Ya tenemos nuestro primer contador en lcd!!!<img src="http://pics.miarroba.com/caretos/wink.gif" alt="Giño" title="Giño" />

Hola, bueno tengo un problemita, aunque el array está definido como tipo char, el compilador CCS v 4.023 me da un error, solo sacando las comillas de los números adentro del array se compila correctamente.

Título: Re: Ejemplitos en C para 16F648A
Publicado por: RedPic en 29 de Julio de 2007, 14:02:09

Ponle simples comilla '0' en lugar de las dobles comilla "0". Las dobles comillas son para strings y las simples para chars. Prueba y dinos algo. :P

Título: Re: RE: Ejemplitos en C para 16F648A
Publicado por: zagoaristides en 29 de Julio de 2007, 21:57:01

Cita de: vszener en 20 de Septiembre de 2005, 11:02:00

Y aqui esta un ejemplito mas!!!esta vez el ejemplo consiste en un teclado y una lcd conectados....decir que para este ejemplo hacen falta las librerias lcd2.c y kbd3x4.c que las podreis encontrar en el post anterior....lcd2.c maneja la lcd pero las lineas de control estan en el porta y las de datos en el b, tambien decir que usamos 8bits de datos, y la kbd3x4.c es para manejar teclados 3x4 y esta conectado al portb conjuntamente al lcd por lo tanto debemos hacer una seleccion dinamica para manejar conjuntamente el lcd y el teclado(de eso se encargan la slibrerias....jeje), bueno el programa consiste en mostrar por lcd la tecla pulsada en el teclado:

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"05
//                    17/Septiembre/05
//
//   Programa:   LCD y teclado 3x4
//   Version:   0.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.227
//   Entorno IDE: MPLAB IDE v7.21      Simulador:    Proteus 6.7sp3
//
//   Notas: Se muestra por lcd la tecla pulsada conectado un
//        keypad 3x4 al pic. Tener en cuenta que hay que poner la directiva
//        NOLVP para que el pin B4 sea de salida.
//
//   Conexiones:      B0 -> D0 LCD/Columna 1 keypad
//               B1 -> D1 LCD/Columna 2 keypad
//               B2 -> D2 LCD/Columna 3 keypad
//               B3 -> D3 LCD
//               B4 -> D4 LCD/Fila A keypad
//               B5 -> D5 LCD/Fila B keypad
//               B6 -> D6 LCD/Fila C keypad
//               B7 -> D7 LCD/Fila D keypad
//               A0 -> RS LCD
//               A1 -> RW LCD
//               A2 -> E LCD
//////////////////////////////////////////////////////////////////////////////////
#include <16f648a.h>            //pic a utilizar
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP,NOBROWNOUT      //ordenes para el programador
#use delay (clock=4000000)         //Fosc=4Mhz
#include<kbd3x4.c>               //libreria manejo keypad
#include<lcd2.c>               //libreria manejo lcd 8bits
#use fast_io(A)
#use fast_io(B)

///PROGRAMA
void main(void)
{
   char c;         //variable donde se almacena tecla pulsada

   lcd_init();      //inicializa lcd

   lcd_putc(" VsZeNeR"05
Tecla pulsada:" );   //presentacion
   lcd_gotoxy(15,2);                        //donde se va a mostrar tecla

   for( ; ; ){   //bucle...
      do{               //espera hasta...
         c=kbd_getc();
         }while(c==0);   //...pulsar una tecla

      lcd_putc(c);      //muestra tecla pulsada en lcd
      lcd_putc("" );      //retrocede una posicion(escribe encima de la ultima tecla mostrada)
      }      //...infinito


}

Pues ya sabemos usar lcd y teclado!!!jeje hasta pronto!<img src="http://pics.miarroba.com/caretos/wink.gif" alt="Giño" title="Giño" />

Que porquería, las librerías no están en ningun lado. LA MEN TA BLE

Título: Re: RE: Ejemplitos en C para 16F648A
Publicado por: zagoaristides en 30 de Julio de 2007, 01:44:16

Cita de: vszener en 20 de Septiembre de 2005, 11:02:00

Y aqui esta un ejemplito mas!!!esta vez el ejemplo consiste en un teclado y una lcd conectados....decir que para este ejemplo hacen falta las librerias lcd2.c y kbd3x4.c que las podreis encontrar en el post anterior....lcd2.c maneja la lcd pero las lineas de control estan en el porta y las de datos en el b, tambien decir que usamos 8bits de datos, y la kbd3x4.c es para manejar teclados 3x4 y esta conectado al portb conjuntamente al lcd por lo tanto debemos hacer una seleccion dinamica para manejar conjuntamente el lcd y el teclado(de eso se encargan la slibrerias....jeje), bueno el programa consiste en mostrar por lcd la tecla pulsada en el teclado:

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"05
//                    17/Septiembre/05
//
//   Programa:   LCD y teclado 3x4
//   Version:   0.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.227
//   Entorno IDE: MPLAB IDE v7.21      Simulador:    Proteus 6.7sp3
//
//   Notas: Se muestra por lcd la tecla pulsada conectado un
//        keypad 3x4 al pic. Tener en cuenta que hay que poner la directiva
//        NOLVP para que el pin B4 sea de salida.
//
//   Conexiones:      B0 -> D0 LCD/Columna 1 keypad
//               B1 -> D1 LCD/Columna 2 keypad
//               B2 -> D2 LCD/Columna 3 keypad
//               B3 -> D3 LCD
//               B4 -> D4 LCD/Fila A keypad
//               B5 -> D5 LCD/Fila B keypad
//               B6 -> D6 LCD/Fila C keypad
//               B7 -> D7 LCD/Fila D keypad
//               A0 -> RS LCD
//               A1 -> RW LCD
//               A2 -> E LCD
//////////////////////////////////////////////////////////////////////////////////
#include <16f648a.h>            //pic a utilizar
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP,NOBROWNOUT      //ordenes para el programador
#use delay (clock=4000000)         //Fosc=4Mhz
#include<kbd3x4.c>               //libreria manejo keypad
#include<lcd2.c>               //libreria manejo lcd 8bits
#use fast_io(A)
#use fast_io(B)

///PROGRAMA
void main(void)
{
   char c;         //variable donde se almacena tecla pulsada

   lcd_init();      //inicializa lcd

   lcd_putc(" VsZeNeR"05
Tecla pulsada:" );   //presentacion
   lcd_gotoxy(15,2);                        //donde se va a mostrar tecla

   for( ; ; ){   //bucle...
      do{               //espera hasta...
         c=kbd_getc();
         }while(c==0);   //...pulsar una tecla

      lcd_putc(c);      //muestra tecla pulsada en lcd
      lcd_putc("" );      //retrocede una posicion(escribe encima de la ultima tecla mostrada)
      }      //...infinito


}

Pues ya sabemos usar lcd y teclado!!!jeje hasta pronto!<img src="http://pics.miarroba.com/caretos/wink.gif" alt="Giño" title="Giño" />

Bueno amigo Zenner, todos los ejemplos para simular LCD con otra cosa (teclado, rs232, etc) me tira el error en Proteus 7.1:

NOT BUILT - requires CCSC (pero yo lo compilé antes)

Thanks for ayudarme as soon as posible

Un abrazo

Título: Re: Ejemplitos en C para 16F648A
Publicado por: zagoaristides en 30 de Julio de 2007, 01:59:13

Cita de: umalrovi en 18 de Julio de 2006, 13:30:55

me sale este mensaje de error a la hora de ejecutar el programa rs232 & keypad.

SIMULATION LOG
==============
Design: C:\Documents and Settings\Alfonso\Escritorio\vs_rs232&keypad.DSN
Doc. no.: <NONE>
Revision: <NONE>
Author: <NONE>
Created: 17/09/05
Modified: 17/09/05

Compiling source files...
Processing vs_rs232&keypad.c...
NOT built - requires CCSC
N.B. 3rd party assemblers such as MPASM, ASEM51, ASM11 and AVRASM can be installed using the Proteus SETUP program.

Build FAILED with 1 error(s).

¿SabéIS de que puede ser?

gracias

A MI LO MISMO

Título: Re: Ejemplitos en C para 16F648A
Publicado por: zagoaristides en 30 de Julio de 2007, 02:07:38

Yo tengo el mismo problema, pudiste solucionarlo???

Título: Re: Ejemplitos en C para 16F648A
Publicado por: pelusac en 30 de Julio de 2007, 08:54:23

Prueba esto:
Ve a la pestaña SOURCE del proteus ,cuando lo tengas abierto , con el esquema cargado y listo para simular.
Despliega la pestaña y entra en ADD/REMOVE SOURCE FILES dentro en la pestaña de CODE GENERATION TOOL selecciona NONE y arriba en SOURCE CODE FILENAME que no ponga nada.
Acepta y prueba a simular.
Si haciendo esto funciona el simulador, el error es que no tienes integrado el CCS con PROTEUS.

Saludos

Título: Re: Ejemplitos en C para 16F648A
Publicado por: pelusac en 30 de Julio de 2007, 09:13:21

Con respecto a las librerías aquí están, ves como no es tan lamentable la filosofia del foro es compartir y compartir y compartir.
Saludos

Título: Re: Ejemplitos en C para 16F648A
Publicado por: RedPic en 30 de Julio de 2007, 09:26:41

zagoaristides:

Lo que me parece de verdad lamentable es tu comentario despectivo, primero porque no es de buena educación despreciar de esa forma lo que se recibe gratuitamente y después y principal porque es injusto: este trabajo ha sido realizado con gran esfuerzo por parte del amigo vszener y otros amigos del foro que desinteresadamente lo ponen a disposición de todo el que acierta a pasar por aquí. y así durante años. Y ciertamente no es una porquería.

Te pongo este post porque sé que la prudencia del amigo vszener le va a impedir contestarte como es debido, pero te ruego que en lo sucesivo pienses en las consecuencias de tus palabras antes de escribirlas.

Muchas gracias.

Título: Re: Ejemplitos en C para 16F648A
Publicado por: Nocturno en 30 de Julio de 2007, 09:46:17

Cierto, para LA MEN TA BLE, tu actitud zagoaristides.

Título: Re: Ejemplitos en C para 16F648A
Publicado por: vszener en 30 de Julio de 2007, 11:13:16

Sin entrar en batallas inecesarias, voy a lo práctico:

1. Que un código no te compile tal cual está en el foro, es normal, ya que antes este post, y todo este foro, estaba alojado en miarroba, al mudarnos de servidor, pues algunos post se modificaros, uno de ellos el de la lcd, aunque si te bajas el archivo, está correctamente escrito, es más, ya a un integrante del foro, en este mismo tema, me preguntó algo similar y le contesté lo que acabo de poner arriba.

2. Todas las librerias como así todos los ejemplitos puestos en este post, están listos para ser descargados desde este mismo post, pero aparte, en el índice del post, está también un enlace a un disco virtual, donde te podrás descargar todos los ejemplitos y todas las librerias.

4. Todos los problemas posibles que te puedas encontrar con estos ejemplitos están respondidas en alguna parte de las 18 páginas que tiene este post, normalmente cerca de la página donde está el ejemplito en sí, que está puesta en el índice del post.

3. Todos los ejemplitos aquí puestos, es simplemente una mera orientación de cómo se puede usar los periféricos del pic en lenguaje C.

Y para concluir, me quedo con una frase de la firma del amigo RedPic: Contra la estupidez los propios dioses luchan en vano

Suerte!!! ;)

Título: Re: Ejemplitos en C para 16F648A
Publicado por: MGLSOFT en 30 de Julio de 2007, 19:08:17

Te metiste mal Zago querido!!
Estas en uno de los hilos mas leidos del foro, te recomiendo que antes de patear otro hormiguero aqui, antes seas capaz de hacer por los demas solo un decimo de lo que ha hecho en este hilo el amigo Vszener!!

Hay dos formas de componer un lio de estos:
Una es pedir disculpas por el exabrupto...
La segunda es no meterse en estos lios... :mrgreen: :mrgreen:

Título: Re: Ejemplitos en C para 16F648A
Publicado por: Burzredion en 21 de Agosto de 2007, 21:28:26

Saludos,

muy bueno el cursillo, yo también empecé a hacer mis pininos gracias a este cursillo y no había tenido oportunidad de agradecer a Vszener por su arduo trabajo.

Pues también quería aprovechar para pedir si pueden subir la librería del teclado matricial 4x4 para Proteus que pues lo he perdido y no lo hallo por ninguna parte.

gracias.

Título: Re: Ejemplitos en C para 16F648A
Publicado por: vszener en 22 de Agosto de 2007, 05:21:31

Buenas!!! Gracias por haber usado estos ejemplitos.

En el Disco Virtual (http://www.box.net/shared/4l7bedpqrz), que puse el link e el índice, te puedes descargar todo lo que existe en este post.

Suerte!!! ;)

Título: Re: Ejemplitos en C para 16F648A
Publicado por: jarod03 en 27 de Agosto de 2007, 21:45:38

Buen dia para todos los amantes de pic....
Soy nuevo en la programacion de pic en C, todo lo que hecho con pic ha sido en assembler.

quiero hacer un reloj con el ds1307 y ademas conectarle una teclado matricial para poder configurarlo y que la hora se visualice en una pantalla de lcd.

hice una parte en assembler pero en C no se como arrancar si me pudierana ayudar se los agradeceria

Título: Re: Ejemplitos en C para 16F648A
Publicado por: jeremylf en 27 de Agosto de 2007, 23:53:28

Se que esto esta dedicado a los 16F648A pero si te sirve de algo hice algo con el DS1307 usando un PIC18F2550 q spongo puede ser facilmente adaptado al otro PIC.

Driver DS1307:

Citar

////////////////////////////////////////////////////////////////////////////////
/// DS1307.C ///
/// Driver for Real Time Clock ///
/// ///
/// ds1307_init() - Enable oscillator without clearing the seconds register -///
/// used when PIC loses power and DS1307 run from 3V BAT ///
/// - Disable squarewave output ///
/// ///
/// ds1307_set_date_time(day,mth,year,dow,hour,min,sec) Set the date/time ///
/// ///
/// ds1307_get_date(day,mth,year,dow) Get the date ///
/// ///
/// ds1307_get_time(hr,min,sec) Get the time ///
/// ///
////////////////////////////////////////////////////////////////////////////////

#ifndef RTC_SDA
#define RTC_SDA PIN_C1 //4
#define RTC_SCL PIN_C0 //3
#endif

#use i2c(master, sda=RTC_SDA, scl=RTC_SCL)

BYTE bin2bcd(BYTE binary_value);
BYTE bcd2bin(BYTE bcd_value);

void ds1307_init(void)
{
BYTE seconds = 0;

i2c_start();
i2c_write(0xD0); // WR to RTC
i2c_write(0x00); // REG 0
i2c_start();
i2c_write(0xD1); // RD from RTC
seconds = bcd2bin(i2c_read(0)); // Read current "seconds" in DS1307
i2c_stop();
seconds &= 0x7F;

delay_us(3);

i2c_start();
i2c_write(0xD0); // WR to RTC
i2c_write(0x00); // REG 0
i2c_write(bin2bcd(seconds)); // Start oscillator with current "seconds value
i2c_start();
i2c_write(0xD0); // WR to RTC
i2c_write(0x07); // Control Register
i2c_write(0x80); // Disable squarewave output pin
i2c_stop();

}

void ds1307_set_date_time(BYTE day, BYTE mth, BYTE year, BYTE dow, BYTE hr, BYTE min, BYTE sec)
{
sec &= 0x7F;
hr &= 0x3F;

i2c_start();
i2c_write(0xD0); // I2C write address
i2c_write(0x00); // Start at REG 0 - Seconds
i2c_write(bin2bcd(sec)); // REG 0
i2c_write(bin2bcd(min)); // REG 1
i2c_write(bin2bcd(hr)); // REG 2
i2c_write(bin2bcd(dow)); // REG 3
i2c_write(bin2bcd(day)); // REG 4
i2c_write(bin2bcd(mth)); // REG 5
i2c_write(bin2bcd(year)); // REG 6
i2c_write(0x80); // REG 7 - Disable squarewave output pin
i2c_stop();
}

void ds1307_get_date(BYTE &day, BYTE &mth, BYTE &year, BYTE &dow)
{
i2c_start();
i2c_write(0xD0);
i2c_write(0x03); // Start at REG 3 - Day of week
i2c_start();
i2c_write(0xD1);
dow = bcd2bin(i2c_read() & 0x7f); // REG 3
day = bcd2bin(i2c_read() & 0x3f); // REG 4
mth = bcd2bin(i2c_read() & 0x1f); // REG 5
year = bcd2bin(i2c_read(0)); // REG 6
i2c_stop();
}

void ds1307_get_time(BYTE &hr, BYTE &min, BYTE &sec)
{
i2c_start();
i2c_write(0xD0);
i2c_write(0x00); // Start at REG 0 - Seconds
i2c_start();
i2c_write(0xD1);
sec = bcd2bin(i2c_read() & 0x7f);
min = bcd2bin(i2c_read() & 0x7f);
hr = bcd2bin(i2c_read(0) & 0x3f);
i2c_stop();

}

BYTE bin2bcd(BYTE binary_value)
{
BYTE temp;
BYTE retval;

temp = binary_value;
retval = 0;

while(1)
{
// Get the tens digit by doing multiple subtraction
// of 10 from the binary value.
if(temp >= 10)
{
temp -= 10;
retval += 0x10;
}
else // Get the ones digit by adding the remainder.
{
retval += temp;
break;
}
}

return(retval);
}

// Input range - 00 to 99.
BYTE bcd2bin(BYTE bcd_value)
{
BYTE temp;

temp = bcd_value;
// Shifting upper digit right by 1 is same as multiplying by 8.
temp >>= 1;
// Isolate the bits for the upper digit.
temp &= 0x78;

// Now return: (Tens * 8) + (Tens * 2) + Ones

return(temp + (temp >> 2) + (bcd_value & 0x0f));
}

Programa en C:

Citar

#include <18F2550.h>
#fuses HS,MCLR,NOWDT,NOPROTECT,NOPUT,NOBROWNOUT,NOPBADEN,NOLVP,NOCPD,NODEBUG,NOWRT,NOVREGEN
#use delay(clock=12000000)
#use rs232(baud=9600, xmit=PIN_C6, rcv=PIN_C7)

//Antes de incluir la libreria del ds1307, tiens q poner q pines vas a usar para la conexionde este al pic (VIA I2C):
#define RTC_SDA PIN_C1
#define RTC_SCL PIN_C0

//Ahora si lo incluyes:
#include <ds1307.c>

//Variables necesarias para el ds1307, almacenamiento de lo q cojes.
BYTE sec;
BYTE min;
BYTE hrs;
BYTE day;
BYTE month;
BYTE yr;
BYTE dow;

void main()
{
ds1307_init(); //inicializo ds1307.

ds1307_set_date_time(15,6,5,2,15,20,55); //fija dia, mes, año, dow, hora, minutosy segundos como quiera.

while(1)
{
delay_ms(1000); //Espero CASI un segundo.

ds1307_get_date(day,month,yr,dow); //Cojo dia, mes, año y dia de la semana actuales y los almaceno en esas variables.
ds1307_get_time(hrs,min,sec); //Lo mismo pero cogiendo las horas, minutos y segundos.

printf("\f\%02d/\%02d/\%02d\r\n",day,month,yr); //lo mando al rs232.
printf("\%02d:\%02d:\%02d", hrs,min,sec);
}
}

La compatibilizacion sera solo cambiando el Include y los fusibles me supongo y claro el cristal q uses. Ah y la definicion del pic q uses parala conexion I2C con el Ds1307 tb.

Espero te sirva.

Un saludo 8) 8) 8) 8)

PD: Lo del teclado ya ingeniatelas :D

Título: Re: Ejemplitos en C para 16F648A
Publicado por: vszener en 28 de Agosto de 2007, 09:02:14

Buenas!!! El ejemplito número 33 es lo que tú deseas pero con un DS1302, pero vamos, el amigo jeremylf ha dejado la libreria para el dispositivo que quieres, no se te hará muy dificil la adaptación.

Suerte!!! ;)

Título: Re: Ejemplitos en C para 16F648A
Publicado por: aitopes en 01 de Septiembre de 2007, 17:49:43

Cita de: vszener en 01 de Septiembre de 2005, 09:46:00

// Conexiones: B0 -> E
// B1 -> RS
// B4 -> D4
// B5 -> D5
// B6 -> D6
// B7 -> D7

Dos años mas tarde, un caido de la rama tiene una duda con ese código:

Estoy migrando algunos programas que tengo en BASIC (en realidad, reescribiendolos) a CCS, y me pasa por ejemplo, que la conexion del display LCD al puerto del PIC no respeta el orden establecido en LCD.C.

Concretamente: En lugar de

B0 -> E
B1 -> RS
B4 -> D4
B5 -> D5
B6 -> D6
B7 -> D7

yo tengo el hard (una placa que hice hace como 5 meses) conectado asi:

B2 -> E
B3 -> RS
B4 -> D4
B5 -> D5
B6 -> D6
B7 -> D7

¿Puedo indicarle esto al compilador sin modificar LCD.C ?

Gracias, y perdon por la preguntonta, pero he buscado largo rato por el foro y no he encontrado la respuesta.

Saludos!

Título: Re: Ejemplitos en C para 16F648A
Publicado por: aitopes en 01 de Septiembre de 2007, 18:27:23

Hola otra vez!

Creo que no se puede. Pero encontre el foro de CCS, en ingles, y ahi hay un hilo muy interesante sobre LCD.

http://www.ccsinfo.com/forum/viewtopic.php?t=24661

Ahi van a encontrar esta libreria:

Flexible driver for a 16x2 LCD:
This is an adaptation of the CCS LCD driver. This isn't intended to replace the CCS driver or Mark's driver. It's just another option
that I decided to put out there.

Advantages:
1. This driver allows you to simply specify the LCD pins at the top of the file. This would be useful if your board doesn't fit the CCS driver, and you don't want to spend the time to figure out how to modify the CCS driver.

2. You can put the LCD pins on several different ports. Also, the data bus pins don't have to be in numerical order or on the same port.

Disadvantages or Limitations:
1. This driver requires CCS "standard i/o" mode (The default mode of the compiler). If you want to use fast i/o mode, then use the CCS
driver or Mark's driver ( http://www.ccsinfo.com/forum/viewtopic.php?t=20182 )

2. This driver uses about 50% more ROM than the CCS driver. That's because it does individual pin i/o rather than byte-wide i/o,
and because it uses standard i/o mode.

Espero les sirva.

Título: Re: Ejemplitos en C para 16F648A
Publicado por: MGLSOFT en 01 de Septiembre de 2007, 21:04:34

Tal cual, no se puede sin declarar los pines tal como los tenes vos...
Te pongo un ejemplo de la libreria que yo utilizo, con Tunning acorde a mi pinout, veras que uso pines de dos puertos diferentes, y no aumenta el codigo como dice el de la pagina de CCS... :mrgreen: :mrgreen:
Yo uso Standard_IO, proba de utilizarla con los otros modos a ver como va...

Código: [Seleccionar]

///////////////////////////////////////////////////////////////////////////
////                         LCD Controlador.C                         ////
////                 Driver para manejar el display LCD                ////
////                                                                   ////
////  lcd_init()   Debe ser llamada antes que ninguna funcion.         ////
////                                                                   ////
////  lcd_putc(c)  Escribe el caracter C en la proxima posicion        ////
////               de la linea actual del LCD.                         ////
////               Las siguientes son modificadores especiales:        ////
////                      \f  Borra el display                         ////
////                      \n  Va al principio de la segunda linea      ////
////                      \b  Se desplaza atras una posicion           ////
////                                                                   ////
////  lcd_gotoxy(x,y) Elige la posicion a escribir en el display       ////
////                    LCD (arriba a la izquierda es 1,1)             ////
////                                                                   ////
////  lcd_getc(x,y)   Devuelve el caracteren la posicion x,y del LCD   ////
////                                                                   ////
////  desplazar_display(x,y) Mueve el contenido escrito en el display  ////
////                          la cantidad de espacios x, en el sentido ////
////                          indicado por y (0=Izquierda, 1=Derecha)  ////
////                                                                   ////
///////////////////////////////////////////////////////////////////////////


// Las dos siguientes estructuras estan dirigidas a poder usar el display en:
//     A0  rs
//     A1  enable
//     A2  rw        hasta aqui es la estructura de los comandos

struct lcd_pin_map_a
{
   BOOLEAN rs;
   BOOLEAN enable;
   BOOLEAN rw;
   BOOLEAN Latch;
   BOOLEAN ShiftIn;
   BOOLEAN ClockIn;
} lcd_Command;

//     B2  D4
//     B3  D5
//     B4  D6
//     B5  D7        y aqui es la de datos, lineas que son entradas o salidas.

struct lcd_pin_map_b
{
   BOOLEAN ClockOut;
   BOOLEAN ShiftOut;
   int     data : 4;
   BOOLEAN Unused;
   BOOLEAN Unused2;
} lcd_Data;


// esto situa la estructura entera
#if defined(__PCH__)                //Si es un PIC18
   #byte lcd_Data = 0xF81                 // en port B (direccion 0xF81)
   #byte lcd_Command = 0xF80              // en port A (direccion 0xF80)
#else                               //Si es un PIC16
   #byte lcd_Data = 6                     // en port B (direccion 6)
   #byte lcd_Command = 5                  // en port A (direccion 5)
#endif

   #define set_tris_lcd_Data(x) set_tris_b(x)

   #define set_tris_lcd_Command(x) set_tris_a(x)

   #define Izquierda 0
   #define Derecha   1

   #define lcd_type 2           // 0=5x7, 1=5x10, 2=2 lines
   #define lcd_line_two 0x40    // Direccion LCD RAM de la segunda linea
   // Otras definiciones para usar en lcd_send_byte
   #define LCD_CLEAR  0x01
   #define LCD_HOME   0x02

   #define LCD_DISPLAY_OFF       0x08
   #define LCD_DISPLAY_ON        0x0C
   #define LCD_Caracter_BLINK    0x0D
   #define LCD_CURSOR_ON         0x0E
   #define LCD_CURSOR_BLINK      0x0F

   #define LCD_CURSOR_SHIFT_RIGHT  0x10
   #define LCD_CURSOR_SHIFT_LEFT   0x14
   #define LCD_DISPLAY_SHIFT_RIGHT 0x18
   #define LCD_DISPLAY_SHIFT_LEFT  0x1C

   BYTE const LCD_INIT_STRING[4]={0x20|(lcd_type<<2),LCD_DISPLAY_ON,LCD_CLEAR,6};
   // Esto es enviado al LCD para inicializarlo bien     //


   // Lo siguiente es usado para setear la direcion de los registros I/O.

   // Seteo del puerto A:
   struct lcd_pin_map_a const LCD_WRITE_a = {0,0,0,0,1,0}; // Para modo escritura todos
   //los bits deben ser salidas menos ShiftIn, que es entrada, por eso se pone en 1 .-

   // Seteo del puerto B:
   struct lcd_pin_map_b const LCD_WRITE_b = {0,0,0,0,0}; // Para modo escritura todos
   //los bits de datos deben ser salidas .-
   struct lcd_pin_map_b const LCD_READ_b = {0,0,15,0,0}; // Para modo lectura todos
   //los bits de datos deben ser entradas , por eso se ponen en 1 .-


/* aqui comienzan las funciones del display LCD */
//#separate
   BYTE lcd_read_byte()
   {
      BYTE low,high;
      set_tris_lcd_Data(LCD_READ_b);
      lcd_Command.rw = 1;
      delay_us(1);
      lcd_Command.enable = 1;
      delay_us(1);
      high = lcd_Data.data;
      lcd_Command.enable = 0;
      delay_us(1);
      lcd_Command.enable = 1;
      delay_us(1);
      low = lcd_Data.data;
      lcd_Command.enable = 0;
      set_tris_lcd_Data(LCD_WRITE_b);
      return( (high<<4) | low);
   }
//#separate
   void lcd_send_nibble( BYTE n )
   {
      lcd_Data.data = n;
      delay_us(1);
      lcd_Command.enable = 1;
      delay_us(1);
      lcd_Command.enable = 0;
   }

   void lcd_send_byte( BYTE address, BYTE n )
   {
      lcd_Command.rs = 0;
      //delay_us (600);//trabaja sin la siguiente linea...
      while ( bit_test(lcd_read_byte(),7) ) ;
      lcd_Command.rs = address;
      delay_us(1);
      lcd_Command.rw = 0;
      delay_us(1);
      lcd_Command.enable = 0;
      lcd_send_nibble(n >> 4);
      lcd_send_nibble(n & 0xf);
   }


   void lcd_init()
   {
      BYTE i;
      set_tris_lcd_Command(LCD_WRITE_a);
      set_tris_lcd_Data(LCD_WRITE_b);
      lcd_Command.rs = 0;
      lcd_Command.rw = 0;
      lcd_Command.enable = 0;
      delay_ms(50);
      for(i=1;i<=3;++i)
      {
         lcd_send_nibble(3);
         delay_ms(5);
      }
      lcd_send_nibble(2);
      for(i=0;i<=3;++i)
         lcd_send_byte(0,LCD_INIT_STRING[i]);
   }


   void lcd_gotoxy( BYTE x, BYTE y)
   {
      BYTE address;
    // Solo permite el rango (1, 1) a (16, 2)
    if (x == 0 || x > 16 || y == 0 || y > 2)
        return;

      if(y!=1)
         address=lcd_line_two;
      else
         address=0;
      address+=x-1;
      //envia el comando de posicion del cursor
      lcd_send_byte(0,0x80|address);
   }

   void lcd_putc( char c)
   {
      switch (c) {
         case '\f'   : lcd_send_byte(0,LCD_CLEAR);
         delay_ms(2);
         break;
         case '\n'   : lcd_gotoxy(1,2);        break;
         case '\b'   : lcd_send_byte(0,LCD_CURSOR_SHIFT_RIGHT);  break;
      default     : lcd_send_byte(1,c);     break;
      }
   }

   char lcd_getc( BYTE x, BYTE y)
   {
      char value;

      lcd_gotoxy(x,y);
      while ( bit_test(lcd_read_byte(),7) );
      // espera mientras el flag Busy esta en bajo
      lcd_Command.rs=1;
      value = lcd_read_byte();
      lcd_Command.rs=0;
      return(value);
   }

   void desplazar_display(int posiciones, boolean sentido)
   {
  // Primer parámetro: Numero de desplazamientos
// Segundo parámetro: Sentido del desplazamiento (TRUE=Derecha, FALSE=Izquierda)
      int i,aux;
      if (sentido) aux=LCD_DISPLAY_SHIFT_RIGHT;   // Desplazamiento a la derecha
      else  aux=LCD_DISPLAY_SHIFT_LEFT;

      for (i=1; i<=posiciones; i++)
      {
         lcd_send_byte(0,aux);
      }
   }

Ojo!! esta libreria utiliza el Pin R/W del display, adaptando las velocidades de funcionamiento segun la temperatura y velocidad de respuesta del LCD, es lo mas aconsejable...
Esta testeada a frecuencias de reloj desde 3,6864 Mhz hasta 20 Mhz, funciona con todas las frecuencias de reloj, el tunning anda OK!!! :mrgreen: :mrgreen:

Título: Re: Ejemplitos en C para 16F648A
Publicado por: Nocturno en 02 de Septiembre de 2007, 01:44:36

Y si no lo consigues con la de Marcos, inténtalo con la Flex-LCD. Está publicada en alguna parte del foro y en la zona de descargas de mi página.

Si lo consigues con la de Marcos, indícalo, para que no se ponga celoso :mrgreen:

Título: Re: Ejemplitos en C para 16F648A
Publicado por: RedPic en 02 de Septiembre de 2007, 04:18:39

Yo tengo disponible una versión de la Flex-LCD (http://picmania.garcia-cuervo.com/Proyectos_AUX_LCD.htm) así como algún programa de ejemplo.

(http://picmania.garcia-cuervo.com/images/LCD_Artist_Foto.JPG)

Título: Re: Ejemplitos en C para 16F648A
Publicado por: aitopes en 02 de Septiembre de 2007, 10:43:17

Hola muchachos! (aunque algunos ya no son taaaaan muchachos... :D :D :D )

Gracias por toda la info. Anoche descubri la flex, y tambien estuve mirando lo que posteo MGLSOFT.
Ya habia metido mano a LCD.C para que me funcionara (me encanta lo rapido que le voy tomando la mano a esto), pero me parecia que iba a encontrar algo parecido al BASIC para no tener que "ajustar" LCD.C en cada proyecto (bueno...eso mas o menos es lo que hace flex..).

Por supuesto, esta "incomodidad" redunda en programas mas chicos. Por ejemplo, un secuenciador de luces programables que programe en BASIC y en CCS resulta mucho mas corto en CCS, es mas, si tengo que fabricar algun otro, podre usar un 16F627A en lugar de un 16F628A. No hay diferencia de $$$, pero si no consigo uno, puedo usar el otro sin problemas.

Lo del LCD esta finiquitado. Ahora voy a reconvertir mis rutinas BASIC para leer los sensores 1-wire. Vi que hay bibliotecas hechas en CCS, pero les tengo cariño a las mias por que las hice desde cero en BASIC. :)

Gracias por todo!
Me voy a prender fuego para el asadito....;)

Título: Re: Ejemplitos en C para 16F648A
Publicado por: MGLSOFT en 02 de Septiembre de 2007, 13:33:07

Ya esta el asado??? :lol: :lol:

Título: Ejemplitos en C para 16F648A
Publicado por: cerebro en 25 de Septiembre de 2007, 16:58:41

buenas...............como se aprende con estos ejemplitos!!!!!! :-/ aca subo uno basado en el cartel que se mueve por un lcd pero viendo que la frase no pasaba a la segunda fila si no se completaba.......... lo modifique para pasar a la segunda fila mientras se mostraba por la primera como una marquesina(no es la gran cosa pero algo es algo)..... un saludo y vamos a seguir practicando para poder postear ejemplos mas copados... saludos

Título: Re: Ejemplitos en C para 16F648A
Publicado por: RedPic en 25 de Septiembre de 2007, 17:30:06

Cita de: aitopes en 02 de Septiembre de 2007, 10:43:17

Hola muchachos! (aunque algunos ya no son taaaaan muchachos... :D :D :D )

Eso no lo dirás por mi ¿verdad? Ja, ja, ja :D :D :D

Muy bien Cerebro por tu aporte. Poco a poco entre todos hacemos grande este Foro. :mrgreen:

Título: Re: Ejemplitos en C para 16F648A
Publicado por: cerebro en 15 de Octubre de 2007, 02:33:31

hola maestros!! eeeeeeee surgio una consulta revisando el problemita de "Escribir & leer eeprom externa 24LC256 y mostrarla por lcd"
en cuanto a los fuses colocaron #fuses HS.....(eso no es para un oscilador de alta velocidad? de 8 a 20 Mhz) y sin embargo utilizamos
un oscilador de 4 Mhz :shock:...... nuevamente gracias un abrazo. Esta pensando en postear algo relacionado al WDT estaria bueno o lo dejamos nomas? :-/

Título: Re: Ejemplitos en C para 16F648A
Publicado por: vszener en 15 de Octubre de 2007, 05:31:56

Exacto, pero si te vas a la revisión de dicho programa, notarás que ya está solucionado con el fuse correcto en XT.

Con respecto al WDT, simplemente en cualquier programa de estos, ponerle la instrucción e ir refrescandolo cada cierto tiempo.

Suerte!!! ;)

Título: Re: Ejemplitos en C para 16F648A
Publicado por: cerebro en 19 de Octubre de 2007, 22:46:50

holaaaa amigos del foro! :-/ gran vszener gracias por responder la consulta ( aunque sea media tonta jejejejeje ) es que todavia soy muy novato...... bueno haber si se entiende lo que queria hacer con el WDT........ en el ejemplito que quiero compartir es el siguiente: mostramos por lcd la marquesina anterior pero la diferencia está en que cada vez que mostramos por lcd tiramos un numero al azar y con una probabilidad de que llegue a una condicion de error sin salida, entonces ahi desborda el WDT y resetea el micro para salir del cuelgue...... he aqui la cuestion problematica cada vez que se resetea el micro la fnc rand() y srand() tiran la misma secuencia (supongo que el reloj tmb se resetea y de ahi saca las constantes para calcular los numeros al azar :?)..... probe mil y una maneras pero no logre resultados satisfactorios...... sera que dios no juega a los dados despues de todo jajajaja un saludo cerebro. :lol:
---falta mucho mucho para alcanzar el nivel de un ejemplo de vszener! :( :(

Título: Re: Ejemplitos en C para 16F648A
Publicado por: vszener en 26 de Octubre de 2007, 05:47:22

Buenas!!! La función srand() es la semilla para generar los números aleatorios y ahí es donde creo que está la clave, no me acuerdo muy bien como iba la historia ya que hace tiempo que no lo uso, cuando vuelva a casa miro el manual del CCS y te contesto con más datos.

Suerte!!! ;)

Título: Re: Ejemplitos en C para 16F648A
Publicado por: cerebro en 26 de Octubre de 2007, 21:09:58

yo mire la ayuda y decia algo que para generar nuevas secuencias habia que tomar tomar un reloj externo.... e hice una analogia con los algoritmos utilizados en las pc de numeros aleatorios (que se manejan tomando unas constantes del reloj de la compu).....
pero.......... no me dejen mentir :D (no mire las fnc srand() por dentro)..... saludos
P/D: puedo pedir un ejemplito? quisiera conocer mas el Detector de frecuencia NE567
si molesto mucho obviar el pedido :-/......

Título: Re: Ejemplitos en C para 16F648A
Publicado por: cerebro en 31 de Octubre de 2007, 21:17:14

HOLA!!!! es verdad vszener srand(unsigned int32 seed) es la semilla ( punto de partida ) de la secuencia pero...siempre es la misma secuencia con esa semilla a eso voy :) y nos proponen pasar el tiempo desde otra fuente para nuevas secuencias con la misma seed (por eso creo que toma otros datos mas ). Una cosita ya que estamos en el tema en el ejemplo del dado " srand(10) "// esto solo permite un punto de partida desde 10..... para limitar el maximo hay que definir RAND_MAX antes de llamar a la libreria con el maximo (como lo hiciste en el ejemplo del dado lcd).... y si llamamos a la libreria el maximo que retorna es 32767 podemos posteriormente calcular el modulo pero bue va en gusto. perdon por ser tan pesado :(! Saludos.. numeros aleatorios cerrado

Título: Re: Ejemplitos en C para 16F648A
Publicado por: rodrigodedomingo en 04 de Noviembre de 2007, 21:45:19

Hola,

tengo un problema,creo que con los tipos de datos q estoy usando.Estoy recibiendo un dato por RS232 y tengo q hacer un cambio de variable antes de sacarlo por el puerto de salida del PIC.El cambio es y=201/93*x-48-32 y redondear el resultado al entero mas proximo pero no me va.
Estoy usando enteros para todo,q pasa cuando multiplicas un entero por un numero decimal y lo vuelcas en un entero otra vez?¿no se redondea el resultado automaticamente?¿como deberia hacer ese cambio de variable?

Muchas gracias,

Saludos.

Título: Re: Ejemplitos en C para 16F648A
Publicado por: dawaherjesus en 09 de Febrero de 2008, 05:49:40

hola como les va soy totalmente nuevo en esto de los pic NO SE PRÁCTICAMENTE NADA
e estado viendo algunos ejemplos que hay por aquí tengo algunas dudas

E tratado de compilar un ejercicio que esta al principio de LCD y el compilador me da un erro en el comando VsZeNeR"05" ); //muestra por pantalla el mensaje exactamente con el 05
el compilador que estoy utilisando es el CCS C
otra duda de donde puedo descargar el proteus para simular C
necesito hacer una comvercion de analogico a digital y mostrarla en un LCD como lo puedo hacer

me caería muy bien su ayuda gracias

Título: Re: Ejemplitos en C para 16F648A
Publicado por: Cryn en 10 de Febrero de 2008, 21:32:15

haber puedo contestarte algunas preguntas, porque no me las se todas :mrgreen:

Citar

E tratado de compilar un ejercicio que esta al principio de LCD y el compilador me da un erro en el comando VsZeNeR"05" ); //muestra por pantalla el mensaje exactamente con el 05

esta no la entendí mbien, podrías colocar el link del mensaje (eso lo hacer haciendo click derecho en el titulo del numero del post y abrir en otra ventana o copiar la ruta), y decir que mensaje te sale en el compilador

Citar

otra duda de donde puedo descargar el proteus para simular C

de su pagina, hay versiones demo, o puedes comprarlo tb de la misma pagina: http://www.labcenter.co.uk/

Citar

# necesito hacer una comvercion de analogico a digital y mostrarla en un LCD como lo puedo hacer

de esto para hacerlo en el 16f648a, no creo que se pueda, pues este micro no posee conversor A/D, pero con uno que tenga, como el 16f88 u otro, creo que tendrás que hacer algo así:

definiendo antes todos los fuses y librerias necesarias, como la lcd.c; vendría:

Código: [Seleccionar]

... includes pic, libreria lcd
#device adc=8 // puede ser de 8 o 10 bits
#fuses ...
#use delay (clock=4000000)

void main()
{
   int16 adcValue;
   setup_adc_ports(RA0_ANALOG); //RA0 entrada analógica, según el micro que uses, la sentencia RA0_ANALOG a veces cambia
   setup_adc(ADC_CLOCK_INTERNAL); // reloj interno
   set_adc_channel(0);      // selecciona el canal 0
   set_tris_a(0xFF);
   lcd_init();

   do
   {
         adcValue=read_adc();     // Lee el resultado de la conversion
         delay_us(20);            // Retardo para carga del cap. de muestreo
         printf (lcd_putc,"\fValor:%u", adcValue);
         // el printf puede desplegar los datos en varios formatos, la u dice que mostrará el dato como entero sin signo, tb se puede usar una X (mayúscula o minúcula) y se mostrará en hexa, mas datos los puedes ver en el manual de CCS, que tb esta en su pagina: http://www.ccsinfo.com/downloads.php Current Compiler Manuals
   } while (TRUE);
}

creo que con eso puedes empezar, mucha de la info que te he dado esta por el foro, siempre usa el buscador dawaherjesus, que seguro ahí lo encuentras. un saludo

Título: Re: Ejemplitos en C para 16F648A
Publicado por: vszener en 16 de Febrero de 2008, 08:04:49

Ese ejemplo a sido motivo de discordia desde que nos mudamos de foro, no se respetaron las tabulaciones y quedó de esa manera, y claro, si se hace un 'copy & paste' pues es lógico que dé error.

Bajate el archivo correspondiente de ese ejemplito y verás que está bien redactado y no dá errores.

Suerte!!! ;)

Título: Re: Ejemplitos en C para 16F648A
Publicado por: Cryn en 16 de Febrero de 2008, 13:07:42

si, eso es muy correcto, yo me descargue ese programa una vez y funcionó mbien, y hasta armando daba excelente :mrgreen:

Título: Re: RE: Ejemplitos en C para 16F648A
Publicado por: diego_z en 26 de Febrero de 2008, 01:18:05

hola medio tarde en esto pero estoy aprendieno sepan disculpar

este es uno el tercer ejemplo de esta post=y dice asi
En esta dire podeis descargaros los archivos: c, hex, dsn(proteus) del programa anterior del encendido de tres led"s de tres formas diferentes

<a href="http://miarroba.com/foros/ver.php?foroid=348538&temaid=3484219

me dice que el foro no existe mas podrian poner el ejemplo de nuevo no se como van las conexiones y me da error el proteus gracias :mrgreen:

Título: Re: Ejemplitos en C para 16F648A
Publicado por: cerebro en 27 de Febrero de 2008, 10:07:27

revisa la pagina 8 o 9 creo que estan todos los ejemplos en un archivo rar para descargar. saludos

Título: Re: Ejemplitos en C para 16F648A
Publicado por: vszener en 27 de Febrero de 2008, 16:36:27

Se me pasó ese enlace al antiguo foro, en el primer mensaje de este post, hay un enlace para descargarte todos los ejemplitos expuestos en este post.

Suerte!!! ;)

Título: Re: Ejemplitos en C para 16F648A
Publicado por: diego_z en 27 de Febrero de 2008, 17:11:54

gracias hermanito por tu interes en ayudarme si descargando ya :mrgreen:

te e comentado que este foro es un libro abierto?
pues si en realidad esta muuuuuuuuuuuy bueno :-/

solo tengo una duda como pongolas salidas de un puerto e anivel bajo al arrancar antes de wile?

Título: Re: Ejemplitos en C para 16F648A
Publicado por: vszener en 01 de Marzo de 2008, 13:10:19

Buenas!!! De esta manera:

Código: C

output_b(0x00);

Donde la letra b corresponde al puerto en cuestión.

PD: Hat más formas, te invito a que indagues en los ejemplitos para aprenderlas.

Suerte!!! ;)

Título: Re: Ejemplitos en C para 16F648A
Publicado por: dawaherjesus en 27 de Marzo de 2008, 20:22:14

hola com les va, e estado practicando con algunos de los programas que tienen aqui que estan muy buenos pero en algunos cuando los modifico y los compilo para obtener el .hex el CCS C me da un error con la linea donde se le indica las orden para el programador exactamente con la orden NOLVP que puede ser? y para que es esa orden?
la otra duda que tengo es que la tabla de prueba que tengo lo que es led los tiene por portc y los programas aqui estan por portb como hago para cambiar eso y para elegir un pin en especifico del micro, no se como configurar los pines de entrada y salida como aria
el pic que estoy usando es el 16F690
muchas gracias

Título: Re: Ejemplitos en C para 16F648A
Publicado por: scientist en 28 de Marzo de 2008, 03:04:26

hola dawaherjesus
mira el fuse NOLVP se trata de decirle al micro que no trabaje con voltaje bajo a programacion (no low voltage programing),en teoria no te deberia salir error,eso si el micro que usas soporta esa opcion, deberias checar el datasheet si es que lo tiene,sino lo tiene,simplemente quitaselo,a la otra pregunta pues simplemente cambia el
#use fast_io(c) y cambias en el output_high(PIN_C0); por ejemplo,aunque hay varias maneras,para configurar los pines de entrada y salida se hace con el
set_tris_x(0x0b00001100); si es 1 es entrada, 0 es salida

Título: Re: Ejemplitos en C para 16F648A
Publicado por: dawaherjesus en 28 de Marzo de 2008, 03:37:11

estube viendo en el foro que el NOLVP nada mas se usa para el portb y yo lo estoy cambiando por el portc y el pic que estoy usando es el PIC16F690

otraa duda que opinan de las targetas de entrnamiento? quiero hacer una para practicar por que es un fastidio armar en protoboard estube pensando en armar la del amigo RedPic el RRBOARD2 que se ve chevere pero me gustaria saber si hay algo mas nuevo o mejor?
vi tambien la de los dsPic pero aqui en mi pais no es muy facil y economico los 33f

Título: Re: Ejemplitos en C para 16F648A
Publicado por: scientist en 28 de Marzo de 2008, 04:04:32

bueno,te digo que yo sepa,este fuse,el NOLVP,es para decirle al micro que trabaje con 3.6 volts,en lugar de los 5 volts, sino es asi,ruego me lo digan,ahora,yo creo que antes de hacer tu tarjeta de desarrollo,prueba el proteus, que es un programa que te simula tus programas compilados,solo cargas el .hex y ya esta,a saber si funciona o no,ahora si quieres armarla,adelante,ya que las practicas que ha hecho el maestro Redpic son compatibles,saludos

Título: Re: Ejemplitos en C para 16F648A
Publicado por: vszener en 31 de Marzo de 2008, 05:44:15

El fuse NOLVP es para programación en bajo voltaje.

Suerte!!! ;)

Título: Re: Ejemplitos en C para 16F648A
Publicado por: DDG en 10 de Abril de 2008, 19:19:31

Hola bueno este es mi primer mensaje en el foro espero no sea del todo muy egoista pero el link de el manual en español de C para pics que esta en el primer mensaje no funciona alguien podria decirme donde localizarlo por fabor y por otra parte quiziera felicitar atodos los moderadors y usuarios de este foro pues realmente es sorprendente todo lo que se puede encontrar en el. devo decir que si mi maestro de universidad conociera esta pagina su clase no fuera tan aburrida pues existen muchisimos proyectos intereseanes y practicos que realmente motivan a aprender esto de los pics, bueno por el momento es todo espero poder contribuir algun dia a esta comunidad.

Título: Re: Ejemplitos en C para 16F648A
Publicado por: vszener en 11 de Abril de 2008, 10:21:15

Gracias por avisar del link roto, ya está solucionado, está en el primer post la dirección correcta que es este link (http://www.box.net/shared/khtawd0o4s).

Decirque que este documento es una traducción del manual antiguo del compilador de la empresa CCS.

Suerte!!! ;)

Título: Re: Ejemplitos en C para 16F648A
Publicado por: DDG en 12 de Abril de 2008, 10:59:38

OK el link funciona perfecto, muchas gracias, ya estaba liado con el manual en ingles y todo iva bien pero muy lento, espero que con esto se agilise mas un poco la curva de aprendisaje de estos tan utiles PIC's

Título: Re: Ejemplitos en C para 16F648A
Publicado por: topocito en 13 de Abril de 2008, 10:28:09

hola como estas esta muy bueno el trabajo sabes necesito hacer el encendido de unos leds de matriz [3]*[2] en funciones sera que me puedes ayudar para ocho tramos
:-/ :shock: :(

Título: Re: Ejemplitos en C para 16F648A
Publicado por: vszener en 16 de Abril de 2008, 10:06:20

Empieza el programa y tus dudas postéalas, cualquiera de los miembros, incluido yo, te hecharemos una mano en lo que podamos.

En este post, hay un ejemplito de manejo simple de una matriz.

Suerte!!! ;)

Título: Re: Ejemplitos en C para 16F648A
Publicado por: Bemor en 26 de Mayo de 2008, 15:56:40

Hola: Quería saludar a todos los participantes en el foro y deciros que estoy aprendiendo mucho,
aunque poco a poco, de todos vosotros.
Los ejemplos de vszener son muy buenos para aprender y las aportaciones de los demás muy
interesantes. Quiero que sepan que su trabajo nos sirve de mucho a otros.
Muchas gracias

Título: Re: Ejemplitos en C para 16F648A
Publicado por: V0LC0M en 27 de Mayo de 2008, 12:59:20

Muy buenas¡ Querria saber si me pudierais hechar una mano con este ejercicio, y decirme si estaria bien hecho. La cuestion es que tendria que haberse hecho con "interrupciones" y no es asi, de todas maneras querria saber si funcionaria. Y por otro lado si me lo pudierais rehacer con las interrupciones correspondientes. Aqui os dejo el programa y el titulo, muchas gracias y un saludo.

Se ha de visualizar en el Lcd: Total=98 y cada vez que en el interruptor RA3 se produzca un flanco de bajada se suman 4 y cada 500ms se restan automaticamente 2
Nunca pueden sobrepasar los limites de 0 a 98. Si llegamos a 0 se ha de visualizar " Sin un duro" y si llegamos a acumular 98 se visualizara " Estoy forrado". En este punto se acaba el proceso.
El sistema empieza con 96

T O T A L = 9 6
E S T O Y F O R R A D O

El recuadro del LCD no lo doy pintando pero serian 2 columnas de 16 filas empezando pegado a la derecha
Y aqui os dejo el ejercicio

#include "C:\Documents and Settings\User\Escritorio\FernandoLouzaoLeon.h"
#include <Lcdlib.c>
#include <stdlib.h>
#include <stdio.h>

void IniciaLcd( void );
void EscrituraLcd( int Dat, short RS );
void TextoLcd( char *cadea );

void main()
{

int8 total;
char cadena_total[]={"TOTAL ="};
char cadena_euros[]={"96"}
char cadena_pierde[12]={"SIN UN DURO"};
char cadena_gana[14]={ESTOY FORRADO};
int8 nivel_anterior=1,nivel_actual;

port_b_pullups(TRUE);
setup_timer_0(RTCC_INTERNAL|RTCC_DIV_4);
set_tris_a (0b00000100);
IniciaLcd();

EscrituraLcd(0x80,CTRL);
TextoLCD(cadena_total);
EscrituraLcd(0x87,CTRL);
TextoLCD(cadena_euros);

total=96;

do{

delay_ms(500);
total=total-2;

itoa(total,10,cadena_euros);
EscrituraLcd(0x87,CTRL);
TextoLCD(cadena_euros);

nivel_actual=input(PIN_A3);

if((nivel_anterior==1)&&(nivel_actual==0))
{

total=total+4;

}

itoa(total,10,cadena_euros);
EscrituraLcd(0x87,CTRL);
TextoLCD(cadena_euros);

if (total>=98)
{
EscrituraLcd(0xC0,CTRL);
TextoLCD(cadena_gana);

break;
}

if (total<=0)
{
EscrituraLcd(0xC0,CTRL);
TextoLCD(cadena_pierde);

break;
}

nivel_anterior=nivel_actual;

}while(1);
}

Título: Re: Ejemplitos en C para 16F648A
Publicado por: Chenao en 26 de Septiembre de 2008, 16:52:49

Un saludo VSZENER. Te tengo un preguntica. estuve observando tus ejemplos para el manejo de un display de 7 secmento conectados en paralelo, la pregunta es la siguiente:

Si un micro hace una división de 16 BITS (2 registro), y se me toma mucho tiempo para realizar la operación, como hago para refrescar el display desde
la división para que no me parpadé los displays. Espero que me constestes un abrazo.

Un saludo desde Pereira - Colombia.

Título: Re: Ejemplitos en C para 16F648A
Publicado por: Cryn en 26 de Septiembre de 2008, 17:47:08

si quieres que el refresco de los display sea constante y no se retarde por rutinas largas, tendrás que utilizar interrupciones, para que cada vez qeu ocurra la interrupción tus displays sean refrescados, en esta aplicación tendrás que utilizar interrupcion de algún temporizador del micro

saludos

Título: Re: Ejemplitos en C para 16F648A
Publicado por: MLO__ en 27 de Septiembre de 2008, 12:40:44

Hola.

Mira este link 7 Segmentos con int Timer0 (http://www.todopic.com.ar/foros/index.php?topic=21738.0), puede ser util para ti.

Saludos

Título: Duda
Publicado por: yarelios en 29 de Septiembre de 2008, 18:50:23

Holaaaa!!!, soy nueva en el foro y programando PICs, jeje, bueno el chiste es que entiendo bien que onda con lo del teclaod matricial, el problemilla aqui presente, es que por ejemplo mi teclado esta en
#define FILA1 PORTBbits.RB7 //ENTRADA
#define FILA2 PORTBbits.RB6 //ENTRADA
#define COLUMNA1 PORTBbits.RB4 //SALIDA
#define COLUMNA2 PORTBbits.RB3 //SALIDA
#define COLUMNA3 PORTBbits.RB2 //SALIDA
bueno yo quiero manejarlo con matices en c, pero no se como, yo lo que hago es darle valor automático a las columnas y depues pregunto por la fila, pero eso es un gorro tremendo, lo que quiero es saber como implementar matrices, y si puedo hacer que columna[ i ] puede ser definida en #define COLUMNA1 PORTBbits.RB4 //SALIDA....Para poder usar un ciclo y recorrerlas todas???...

Mil gracias!!! :shock:

Título: Re: Ejemplitos en C para 16F648A
Publicado por: kicho en 16 de Noviembre de 2008, 17:01:37

Hola, antes que nada darte las gracias por tanto ejemplo y tan claros.

queria decirte que e intentado montar el ejemplo 24 sobre el Mplab con el plugin para css y no hay manera, creo k es por una incompatibilidad de librerias , al menos eso e leido, pero queria saber que es lo k me pasa realmente. esto es lo k me da mplab:

Executing: "C:\Program files\Picc\CCSC.exe" +FH "flex_lcd_c.c" +EXPORT +DF +LN +T +A +M +Z +Y=9 +EA
*** Error 128 "C:\Documents and Settings\Pedro Francisco\Desktop\16f84_flexlcd\flex_lcd_c.c" Line 28(142,183): A #DEVICE required before this line
C:\Documents and Settings\Pedro Francisco\Desktop\16f84_flexlcd\flex_lcd_c.o ===> 1 Errors, 0 Warnings.
Halting build on first failure as requested.
BUILD FAILED: Sun Nov 16 19:57:11 2008

Cuando monto tu ejemplo, por que me da este error??.

Un saludo

Título: Re: Ejemplitos en C para 16F648A
Publicado por: MLO__ en 16 de Noviembre de 2008, 17:50:26

Hola.

No incluyas las librerias en Source Files. El CCS se encarga de todo :mrgreen: , tu incluyelas en el codigo fuente con #include

Saludos

Título: Re: Ejemplitos en C para 16F648A
Publicado por: Vicfred en 09 de Marzo de 2009, 04:10:45

hola, el ccs es de de paga verdad? no hay una version gratis ademas del demo?

Título: Re: Ejemplitos en C para 16F648A
Publicado por: vszener en 09 de Marzo de 2009, 13:07:28

Buenas:

kicho: El error que te da el CCS es que debes definir un micro antes de incluir las librerías, tal y como se hace en el Ejemplito 24, de todas formas, si continúas con el error, sube el archivo o ponlo en el foro.

Vicfred: CCS posee licencia de uso y no es gratuita, es de pago, la única opción es la demo que mencionas.

Suerte!!! ;)

Título: Re: Ejemplitos en C para 16F648A
Publicado por: juansi en 10 de Marzo de 2009, 15:56:31

vszener sigo tus ejemplos como si de una religion se tratase, y me gustaria q me resolvieras una duda q es la siguiente:
quiero hacer un contador de 0 a 9999 q incremente en 1 cuando pulse el pin A4 sin rebotes, el caso es que si mantengo pulsado el pulsador se apagan los displayshasta q suelte.
La cuestion es si la forma como la hice esta bien o se puede simplificar de alguna manera.
aqui va el codigo:

Código: C

#include <16f84a.h>
#fuses XT,NOWDT,NOPROTECT,PUT
#use standard_io(B)
#use standard_io(A)
#use delay (clock=4000000)
 
 
 
void main(void)
{
char i=0,j=0,k=0,l=0,p;
 
int tab7seg[10]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x67};
set_tris_b(0x00);
set_tris_a(0x00);
disable_interrupts(GLOBAL);
 
do{
output_a(0b1110);
delay_ms(10);
output_b(tab7seg[i]);
output_a(0b1101);
delay_ms(10);
output_b(tab7seg[j]);
output_a(0b1011);
delay_ms(10);
output_b(tab7seg[k]);
output_a(0b0111);
delay_ms(10);
output_b(tab7seg[l]);
 
if(!input(pin_a4)){
   i++;
      if(i>9){
         i=0;
         j++;
         if(j>9){
            j=0;
            k++;
            if(k>9){
               k=0;
               l++;
                  if(l>9)
                     l=0;
            }
         }
      }
}
 
   while(!input(pin_a4)){
output_a(0b1110);
delay_ms(10);
output_b(tab7seg[i]);
output_a(0b1101);
delay_ms(10);
output_b(tab7seg[j]);
output_a(0b1011);
delay_ms(10);
output_b(tab7seg[k]);
output_a(0b0111);
delay_ms(10);
output_b(tab7seg[l]);
}
 
 
}while(true);
}

Título: Re: Ejemplitos en C para 16F648A
Publicado por: MLO__ en 11 de Marzo de 2009, 00:46:09

Hola.

Lo que pasa es que tu muestra de datos en los displays lo haces en el programa principal, por ende, el segun tu rutina, el programa se queda clavado hasta que no sueltes el pulsador y no puede continuar con la rutina de visualizacion.

Cita de: MLO__ en 27 de Septiembre de 2008, 12:40:44

Mira este link 7 Segmentos con int Timer0 (http://www.todopic.com.ar/foros/index.php?topic=21738.0), puede ser util para ti.

Ahi propongo crear la rutina de visualizacion independientemente del programa principal (mediante las interrupciones del Timer0), de esta manera siempre vas a ver el numero en los diplays.

Saludos

Título: Re: Ejemplitos en C para 16F648A
Publicado por: juansi en 11 de Marzo de 2009, 20:22:46

MLO soy muy novato para hacerlo con el timer0, lo he intentado pero no consigo eliminar los rebotes, y ademas ni siquiera me funcionaba bien.
Te inportaria orientarme un poco??? mil gracias por la ayuda q prestais en el foro si no fuera por vosotros no seria capaz de aprender esto.

Título: Re: Ejemplitos en C para 16F648A
Publicado por: MLO__ en 11 de Marzo de 2009, 22:08:51

Hola.

Los rebotes en los pulsadores se pueden eliminar colcando un antirrebotes -valga la redundancia-. Un codigo podria ser el siguiente:

Código: [Seleccionar]

if(input_state(pin_a1))//o cualquier otro pin donde tengas conectado el pulsador
{
 delay_ms(50);//tiempo que espero hasta que se estabilice
 if(input_state(pin_a1))//verifico si el pulsador sigue presionado
 {
  ....//Hago lo que tenga que hacer
  while(input_state(pin_a1));//Espero hasta que se deje de presionar el pulsador
 }
}

Dime que dudas tienes y las iremos resolviendo entre todos...

Saludos

Título: Re: Ejemplitos en C para 16F648A
Publicado por: juansi en 11 de Marzo de 2009, 23:12:47

MLO a ver q te parece este codigo para evitar el while(!input()){} y eliminar los rebotes con una variable

Código: C

#include <16f870.h> //pic a utilizar
#fuses XT,NOWDT,NOPROTECT,PUT
#use standard_io(B)
#use standard_io(A)
#use standard_io(C)
#use delay (clock=4000000)
 
 
 
void main(void)
{
int i=0,j=0,k=0,l=0,rem=0;
 
int tab7seg[10]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x67};
set_tris_b(0x00);
set_tris_c(0x00);
disable_interrupts(GLOBAL); //activadas interrupciones
 
do{
output_c(0b1110);
delay_ms(10);
output_b(tab7seg[i]);
output_c(0b1101);
delay_ms(10);
output_b(tab7seg[j]);
output_c(0b1011);
delay_ms(10);
output_b(tab7seg[k]);
output_c(0b0111);
delay_ms(10);
output_b(tab7seg[l]);
 
   if(rem==1){
      i++;
      if(i>9){
         i=0;
         j++;
         if(j>9){
            j=0;
            k++;
            if(k>9){
               k=0;
               l++;
                  if(l>9)
                     l=0;
            }
         }
      }
   }
if(!input(pin_a0)){
   rem++;
   if(rem>2)
      rem=2;
}
else{
rem=0;
}
}while(true);
}

la variable rem la utilizo para eliminar rebotes y asi no se apagan los displays cuando el boton esta pulsado
¿crees q seria mejor hacerlo de otra manera?¿hay una mas simple?
Gracias por tu ayuda de nuevo.

Título: Re: Ejemplitos en C para 16F648A
Publicado por: MLO__ en 12 de Marzo de 2009, 15:10:41

Hola.

Lo ideal es que la visualizacion siempre este activa sin importar que se haga en el programa principal, por eso es mejor usar las interrupciones del Timer para gestionar la rutina de visualizacion.

Dime que dudas tienes de la rutina en el timer y vamos aclarandolo, no importa si eres novato, mira que aprenderias a usar el timer!!!

Título: Re: Ejemplitos en C para 16F648A
Publicado por: juansi en 16 de Marzo de 2009, 19:50:00

Hola mlo.
La unica forma que se me ocurre es encendiendo los displays en la interrupcion pero tendria mandar bits al puerto en la interrupcion, yo creia q no se podia hacer eso, que en la interrupcion solo se manejaban variables.
¿estoy en lo cierto?¿o me equivoco?.
Si me pudieras dar un empujoncito para guiarme el camino.
GRACIAS

Título: Re: Ejemplitos en C para 16F648A
Publicado por: ppyote en 16 de Marzo de 2009, 22:37:58

con el timer0 configurar los displays de leds es muy facil, a cada interrupcion del timer0, un contador suma, cuando da de valor 1,enciende el primer display,cuando el valor es 2, enciende el segundo,cuando el valor es tres el tercero y asi sucesivamente..... asta el ultimo display, que pondra el contador en 0 y empezara de nuevo la cuenta....
creo recurdar que hay un ejemplo

AQUI (http://www.todopic.com.ar/foros/index.php?topic=21738.0) lo tienes

Título: Re: Ejemplitos en C para 16F648A
Publicado por: MLO__ en 19 de Marzo de 2009, 13:45:34

Hola.

Tu puedes modificar pines y variables en la interrupcion, no hay problema, la idea es no demorarse tanto.

Para el despliegue de los displays de 7 segmentos, es muy sencillo usando el timer, veamos:

Configuracion del Timer0 para escoger la base de tiempo de multiplexacion, es decir cuanto tiempo va a permanecer encendido cada display:

Código: [Seleccionar]

setup_timer_0(RTCC_8_BIT | RTCC_DIV_4 | RTCC_INTERNAL);

Es decir, uso un registro de 8 bits, por lo que tendre un desborde cada 256uS (usando un cristal de 4MHz, cada tick del reloj es de 1uS por 256 = 256uS) y al usar un prescaler de 4 la interrupcion saltara cada 4 * 256uS = 1.024mS. Por ende cada display se visualizara cada 1.024mS (casi 1mS).

Definimos la interrupcion:

Código: C#

#int_TIMER0
void Timer0_isr(void)
{
 ++ ints_timer0;//Sumo uno al contador cada que entre a la interrupcion
 dato_1 = int2bcd(value_1);//Convierto el valor de la variable a BCD
 if(ints_timer0==1)
 {
  off(dec_p);//Apago habilitador decenas
  unidades_p = dato_1 & 0x0F;//Separo las unidades de las decenas
  display(unidades_p);//Pongo en el puerto las unidades
  on(uni_p);//Habilito el display de las unidades
 }
 if(ints_timer0==2)
 {
  off(uni_p);//Apago el habilitador de las unidades
  decenas_p = (dato_1>>4) & 0x0F;//Separo las decenas de las unidades
  display(decenas_p);//Pongo en el puerto las decenas
  on(dec_p);//Habilito el display de las decenas
  ints_timer0 = 0;//Pongo a ceros el contador para volver al estado inicial
  }
}

Saludos

Título: Re: Ejemplitos en C para 16F648A
Publicado por: J_jOsE en 03 de Abril de 2009, 18:38:28

Hola a todos :)

estuve viendo las respuesta y realmente a uno le hayudan bastante y felicidades por eso :-/

pero ahora me encontre con un problema, :(
estoy trabajando en un pruyecto donde utilizo un uC 16F690 y el CSS C 4.065
y obserbando su datasheet vi que se puede configurar interrupciones para cada pin del puerto A y B, como tambien los pull-up
individualmente de cada pin

ahora mi problema radica enque no pude configurar dichas interrupciones ni los pull-up
en si lo que nesecito es habilitar los pull-up individualmente de los pins RA1 , RA2 y adicionalmente poder habilitar sus interrupciones de cada pin individualmente tmb. para asi utilizarlo como entradas digitales

espero su F1 o mejor dicho su hayuda :mrgreen:
y de antemano gracias

Título: Re: Ejemplitos en C para 16F648A
Publicado por: Cryn en 05 de Abril de 2009, 11:18:57

Hola paisano, para los pull-up tienes que usar, en el main (esto solo si el micro tiene los pull-up disponibles para esos pines):

PORT_x_PULLUPS(pin_a1);
PORT_x_PULLUPS(pin_a2);

y para las interrupciones:

#int_ra1
void isr_int_a1(void){
...//la rutina
}

#int_ra2
void isr_int_a2(void){
...//la rutina
}

y en el main:

enable_interrupts(int_ra1);
enable_interrupts(int_ra2);
enable_interrupts(global);

En teoría tendría que funcionar así, pruébalo y nos avisas. Que lindo pic, tiene muchas cosas

Un saludo, que gusto es ver gente boliviana, y que mejor cochala por el foro :-/

pd. creo que debiste haber creado otro tema, porque este es dedicado solo al 16f648a, si tenes algún código por ahí también serviría para ver si tienes solamente alguna falla por ahí

Título: Re: Ejemplitos en C para 16F648A
Publicado por: J_jOsE en 06 de Abril de 2009, 10:44:25

MUCHAS GRACIAS Cryn :)

lo estoy probando y si no me resulta
creare un nuevo tema y lo subo el cod. pa q lo revisen

y…. arriba los bolivianos :-/

Título: Re: Ejemplitos en C para 16F648A
Publicado por: J_jOsE en 06 de Abril de 2009, 18:14:42

bueno Cryn

respecto a los pull-up
el compilador genera error :(
creo q es por la version del compilador (v4.065) por q estuve viendo el archivo 16F690.h
y la configuracion para estas se encuentran en ese archivo

respecto a la int de cada pin
tmb. el compilador genera error

bueno
ahora lo ise con la interrupcion del puerto, no esta como queria pero hace lo q dbria :?

aca esta el programilla (lo basico)

http://www.todopic.com.ar/foros/index.php?topic=25489.new#new

bye

Título: Re: Ejemplitos en C para 16F648A
Publicado por: zagoaristides en 09 de Abril de 2009, 15:56:23

Cita de: MGLSOFT en 30 de Julio de 2007, 19:08:17

Te metiste mal Zago querido!!
Estas en uno de los hilos mas leidos del foro, te recomiendo que antes de patear otro hormiguero aqui, antes seas capaz de hacer por los demas solo un decimo de lo que ha hecho en este hilo el amigo Vszener!!

Hay dos formas de componer un lio de estos:
Una es pedir disculpas por el exabrupto...
La segunda es no meterse en estos lios... :mrgreen: :mrgreen:

Sorry very much!!!!
Por atolondrado!

Título: Re: Ejemplitos en C para 16F648A
Publicado por: zagoaristides en 09 de Abril de 2009, 16:00:49

Cita de: RedPic en 30 de Julio de 2007, 09:26:41

zagoaristides:

Lo que me parece de verdad lamentable es tu comentario despectivo, primero porque no es de buena educación despreciar de esa forma lo que se recibe gratuitamente y después y principal porque es injusto: este trabajo ha sido realizado con gran esfuerzo por parte del amigo vszener y otros amigos del foro que desinteresadamente lo ponen a disposición de todo el que acierta a pasar por aquí. y así durante años. Y ciertamente no es una porquería.

Te pongo este post porque sé que la prudencia del amigo vszener le va a impedir contestarte como es debido, pero te ruego que en lo sucesivo pienses en las consecuencias de tus palabras antes de escribirlas.

Muchas gracias.

En realidad fue de atolondrado, porque con mis amigos decimos Lamentable cuando algo nos sale mal y nos lamentamos, es más de nuestros pagos y me doy cuenta que sonó como el ortis, pero eso me pasa por escribir tan rápido y no releer. Ahora el lamentable soy io!

Abrazo y disculpas a todos los que ofendí sin querer.

Título: Re: Ejemplitos en C para 16F648A
Publicado por: Armand en 04 de Mayo de 2009, 13:21:41

hola, saludos a todos.

soy nuevo en ccs y quisiera saber si alguien podria ayudarme a realizar un programa que detecte 9 bits (address detection)via la usart del pic 16f873 y el dato lo envie al pc, cuando el pc envie la respuesta el pic nuevamente coloque el 9 bit y lo envia al dispositivo.
es decir un programa que maneje 2 puertos seriales uno con 9 bits y el otro con 8.
gracias

Título: Re: Ejemplitos en C para 16F648A
Publicado por: darck_khronos en 19 de Mayo de 2009, 00:47:35

Alguien aun tendra estas librerias

#include<kbd4x4ABCD_PROTEUS.c> //libreria manejo keypad
#include<lcd2.c> //libreria manejo lcd 8bits

Título: Re: Ejemplitos en C para 16F648A
Publicado por: vszener en 20 de Mayo de 2009, 05:26:44

Buenas:

Si te vas al primer mensaje de este hilo, encontrarás un enlace donde te podrás descargar todo lo que aparece aquí.

Suerte!!! ;)

Título: Re: Ejemplitos en C para 16F648A
Publicado por: darck_khronos en 20 de Mayo de 2009, 10:41:23

Cita de: vszener en 20 de Mayo de 2009, 05:26:44

Buenas:

Si te vas al primer mensaje de este hilo, encontrarás un enlace donde te podrás descargar todo lo que aparece aquí.

Suerte!!! ;)

Manda a un sitio de miarroba mas que aparece como ya no existente o erro 404

Título: Re: Ejemplitos en C para 16F648A
Publicado por: Suky en 20 de Mayo de 2009, 12:40:40

AQUI (http://www.box.net/shared/4l7bedpqrz) están. :wink: (Es el link al que se refería Vszener)

Título: Re: Ejemplitos en C para 16F648A
Publicado por: darck_khronos en 20 de Mayo de 2009, 14:02:18

Cita de: Suky en 20 de Mayo de 2009, 12:40:40

AQUI (http://www.box.net/shared/4l7bedpqrz) están. :wink:

gracias por el aporte

Título: Re: Ejemplitos en C para 16F648A
Publicado por: jhozate en 07 de Junio de 2009, 20:53:55

bueno antes q nada, mis agradeciemientos a vszener por este hilo me será de mucha ayuda, recien estoy pasando del ASM al C y me cuesta un poco ....ahora me propongo a hacer algo parecido a las lucecitas del auto fantastico...pero lo que quiero hacer es lo siguiente:
si RA0=1 pongo en el puertoB 11111110 y roto el cero segun RA1
si RA0=0 pongo en el puertoB 00000001 y roto el uno segun RA1

si RA1=1 roto hacia la derecha
si RA1=0 roto hacia la izquierda

seguro q con lo q hay en el hilo podre hacer las rotaciones, me pregunto si en ccs puedo hacer comparaciones del estado de los bits, asi

Código: CSS

IF(PIN_A0==0;PIN_A1==0)
    {
    OUTPUT_B(0B00000001);
    //rutina para rotar el uno hacia la izquierda
 
else if (PIN_A0==0;PIN_A1==1)
       .
       .
       .          
//asi sucesivamente con las combinaciones de A0 y A1
 
 
saludos

Título: Re: Ejemplitos en C para 16F648A
Publicado por: Suky en 07 de Junio de 2009, 21:24:40

Para hacer el testeo de 2 pines a la vez seria:

if (PIN_A0==0 && PIN_A1==0){

Título: Re: Ejemplitos en C para 16F648A
Publicado por: hayn en 09 de Junio de 2009, 11:21:46

Buenas amigos, soy nuevo y me gustaria aprender a programar en c los pic, pero tengo problemas al tratar de bajar el demo de ccs que aparece al principio de este hilo, ya yo lo habia bajado y no se si es solo por tiempo limitado que lo puedo usar y no he podido volver a bajarlo, les estaria eternemente agradecido si me indicaran algun sitio en donde obtenerlo. Ya he intentado en la pagina del fabricante y nada. :( :( :( :( :( :(...........gracias.

Título: Re: Ejemplitos en C para 16F648A
Publicado por: Cryn en 09 de Junio de 2009, 12:14:01

y acá (http://www.ccsinfo.com/ccsfreedemo.php)?? llenando su formulario?

Título: Re: Ejemplitos en C para 16F648A
Publicado por: hayn en 09 de Junio de 2009, 14:01:44

amigo cryn, despues que lleno el formulario y lo descargo arroja un error, que otra cosa puedo hacer???? :( :( :(

Título: Re: Ejemplitos en C para 16F648A
Publicado por: jhozate en 09 de Junio de 2009, 21:01:32

tengo una duda con el programa del carro fantastico, pongo el codigo

Código: CSS

for(;;){ //CICLO INFINITO - SIEMPRE USAR
   
   disable_interrupts(GLOBAL);
   set_tris_b(0x00);
   a=1;
      for(i=1;i<=8;i++)
      {
      output_b(a);
      a=a*2;
      delay_ms(500);
      }
      a=128;
      for(i=1;i<=8;i++)
      {
      output_b(a);
      a=a/2;
      delay_ms(500);
      }
  
  
   }
  
   //FIN DEL CODIGO DE USUARIO - NO ESCRIBIR CODIGO A PARTIR DE AQUI
}

como es sabido el programa debe hacer las luces del carro fantastico, pero el primer for funciona bien el segundo necesita q yo le declare la variable "a" fuera del for , por que? se supone que del for anterior ya viene con 128

Título: Re: Ejemplitos en C para 16F648A
Publicado por: Cryn en 09 de Junio de 2009, 21:37:33

en el bucle for, según el código (http://www.todopic.com.ar/foros/index.php?topic=4530.msg38866#msg38866) de vszener es:

i=1;i<8,i++

y tu colocaste i<=8

quizá ahí este el problema..

Título: Re: Ejemplitos en C para 16F648A
Publicado por: hayn en 09 de Junio de 2009, 22:08:19

gracias a aquellas personas que con su ayuda desinteresada llevan luz donde no la hay haciendo de este mundo un sitio mas plural donde vivir gracias....... :-/ :-/ :-/ :-/ :-/ :-/

Título: Re: Ejemplitos en C para 16F648A
Publicado por: Cryn en 09 de Junio de 2009, 22:23:22

Cita de: hayn en 09 de Junio de 2009, 22:08:19

gracias a aquellas personas que con su ayuda desinteresada llevan luz donde no la hay haciendo de este mundo un sitio mas plural donde vivir gracias....... :-/ :-/ :-/ :-/ :-/ :-/

:z) eh? y que paso? jajajajaja
no pasa nada hayn, para eso estamos para ayudarnos :wink:

Título: Re: Ejemplitos en C para 16F648A
Publicado por: jhozate en 09 de Junio de 2009, 23:25:47

gracias a este aporte, pongo mi granito de arena para los q apenas empiezan en el lenguaje C como yo. con ayuda de este hilo hice un programa que emula las luces del carro fantastico pero le podemos poner direccion y ademas elegir si queremos rotar un "1" o un "0"...no se si es la forma mas optimizada pero funciona

A0 A1 Salida rotacion
0 0 00000001 <<<<<<
0 1 00000001 >>>>>>
1 0 11111110 <<<<<<
1 1 11111110 >>>>>>

Código: CSS

for(;;){ //CICLO INFINITO - SIEMPRE USAR
   
   set_tris_b(0x00);
   set_tris_a(0xff);
   if( input(PIN_A0)==0 && input(PIN_A1)==0)
      {
      i=0b00000001;
      for(a=1;a<=8;a++)
      {
   
      output_b(i);
      rotate_left( &i, 1);
      delay_ms(100);
      } 
      }
  if ( input(PIN_A0)==0 && input(PIN_A1)==1)
      {
      i=0b00000001;
      for(a=1;a<=8;a++)
      {
   
      output_b(i);
      rotate_right( &i, 1);
      delay_ms(100);
      }
      }
  if ( input(PIN_A0)==1 && input(PIN_A1)==0)
      {
      i=0b11111110;
      for(a=1;a<=8;a++)
      {
   
      output_b(i);
      rotate_left( &i, 1);
      delay_ms(100);
      }
      }
  if ( input(PIN_A0)==1 && input(PIN_A1)==1)
      {
      i=0b11111110;
      for(a=1;a<=8;a++)
      {
   
      output_b(i);
      rotate_right( &i, 1);
      delay_ms(100);
      }
      }
      
      }//fin del for infinito
      //FIN DEL CODIGO DE USUARIO - NO ESCRIBIR CODIGO A PARTIR DE AQUI
}//fin void main

ahora, quisiera saber como puedo hacer para que inmediatamente ocurra el cambio de los bit A0, A1 cambie el programa tambien.,ademas de otras alternativas para hacer el programa, ademas que pasa con el else if del ccs cuando lo pongo aparece "A numeric expression must appear here."

Título: Re: Ejemplitos en C para 16F648A
Publicado por: Cryn en 09 de Junio de 2009, 23:54:02

Hola jhozate,

Creo que para que cambie inmediatamente de función cuando cambies los estado de los pines A en tu caso, se podría hacer dos cosas:

Utilizar interrupciones, para la temporización, cambiaría bastante la estructura; ya que de la manera que la hiciste ejecuta un proceso hasta que lo acabe, y al final recíen consulta por nuevos estados. Por interrupciones consultarías constantemente los estados para ejecutar una u otra secuencia
Dentro de los for usar la instrucción BREAK consultando (con un if) por cambios de estado en los pines del puerto A, para que pase a preguntar por el nuevo estado en los pines del puerto A

Esa pregunta del else if, no la entendí, pero esta es lo que yo hago:

if(condición1){
...//proceso1
}
else if(condición2){
...//proceso2
}
else if(condición3){
...//proceso3
}
.... // solo se ejecutará un proceso, o ninguno

esto funciona como un switch:
switch(variable){
case x: {... proceso1;
break;
}
case y: {... proceso2;
break;
}
....
} //solo se ejecutará un caso o ninguno cada vez que se ejecute el switch

algunas diferencias, ventajas y desventajas entre ellos, lo usarás de acuerdo a tus necesidades

espero sirva, un saludo.

Título: URGENTE NECESITO LA LIBRERIA KBD3X4.C
Publicado por: cascabelito666 en 11 de Junio de 2009, 03:23:08

OYE CUATE NECESITO URGENTE PARA MI TESIS LA LIBRERINA KBD3X4 .C NO LA ENCUENTRO EN NINGUN LADO TENGO LA KBD.C PERO NO SE SI ESTA ME TRAIGA PROBLEMAS AL METER EN EL MISMO PUERTO EL TECLADO Y EL LCD POR FAVOR SI LA TIENES MANDAMELA TE LO AGRADECERIA PARA TODA LA VIDA MI CORREO ES LAPPRAS@HOTMAIL.COM

Título: Re: Ejemplitos en C para 16F648A
Publicado por: vszener en 11 de Junio de 2009, 10:51:53

Buenas:

Antes que nada cascabelito666 , usa el buscador si requieres algo, en caso de no dar con ello, busca donde aparezca dicha librería, y si no obtienes frutos de ninguna de las opciones, pídelo de forma respetuosa.

¿Por qué digo respetuosa? Simplemente porque te estás saltando a la torera más de una norma del foro, y visto que es tu primer mensaje por estos lugares, te aconsejo que te la repases.

Y hay algo en este hilo, que abrí hace mucho y me ha reportado tanto, que no logro entender, todo, repito, absolutamente todo lo que aparece en este hilo (librerias, ejemplos, etc) está en el primer mensaje, concretamente hay un espacio donde pone: Disco Virtual vszener, desde ahí os mandará para la descarga de cualquier elemento que haya aparecido en este hilo.

Suerte!!! ;)

Título: Re: URGENTE NECESITO LA LIBRERIA KBD3X4.C
Publicado por: darck_khronos en 11 de Junio de 2009, 22:19:47

Cita de: cascabelito666 en 11 de Junio de 2009, 03:23:08

OYE CUATE NECESITO URGENTE PARA MI TESIS LA LIBRERINA KBD3X4 .C NO LA ENCUENTRO EN NINGUN LADO TENGO LA KBD.C PERO NO SE SI ESTA ME TRAIGA PROBLEMAS AL METER EN EL MISMO PUERTO EL TECLADO Y EL LCD POR FAVOR SI LA TIENES MANDAMELA TE LO AGRADECERIA PARA TODA LA VIDA MI CORREO ES LAPPRAS@HOTMAIL.COM

esa libreria que necesitas en las kdb.c de CCS es generica, y si lo quieres usar por el puerto B solo tienes que de clararla

aqui te al dejo ya modificada

Título: Re: Ejemplitos en C para 16F648A
Publicado por: jhozate en 19 de Junio de 2009, 23:39:07

en ccs no hay q estar pendiente de poner las banderas de interrupcion nuevamente a cero?....al igual que en assembler retorna al lugar donde ocurrió la interrupcion?

Título: Re: Ejemplitos en C para 16F648A
Publicado por: Suky en 20 de Junio de 2009, 00:46:24

Cita de: jhozate en 19 de Junio de 2009, 23:39:07

en ccs no hay q estar pendiente de poner las banderas de interrupcion nuevamente a cero?....al igual que en assembler retorna al lugar donde ocurrió la interrupcion?

Exactamente, el compilador se encarga de eso, de guardar y restablecer los registros y borrar las banderas. Pero para la interrupción por cambio de estado de RB4-RB7, donde como requisito hay que hacer una lectura/escritura del Puerto B no lo realiza, así que a tenerlo en cuenta.

Título: Re: RE: Ejemplitos en C para 16F648A
Publicado por: aragonevil en 03 de Julio de 2009, 16:56:49

hola amigo vszener necesito que me ayudes en unas cosillas en c , con el programa para desplegar un mensaje ya que deseo desplegar un mensaje de 30 caracteres lo estoy haciendo con la libreria del ccs lcd.c pero no lo consigo he leido que necesito mover el cursor del lcd pero no se como hacerlo si tienes tiempo te lo agradeceria 1000000 jajaja gracias sigue con tus grandes aportes he aprendido bastante :-/ :-/

Título: Re: RE: Ejemplitos en C para 16F648A
Publicado por: Suky en 03 de Julio de 2009, 19:13:29

Cita de: aragonevil en 03 de Julio de 2009, 16:56:49

hola amigo vszener necesito que me ayudes en unas cosillas en c , con el programa para desplegar un mensaje ya que deseo desplegar un mensaje de 30 caracteres lo estoy haciendo con la libreria del ccs lcd.c pero no lo consigo he leido que necesito mover el cursor del lcd pero no se como hacerlo si tienes tiempo te lo agradeceria 1000000 jajaja gracias sigue con tus grandes aportes he aprendido bastante :-/ :-/

Para pasar a la siguiente linea solo coloca lcd_gotoxy(1,2); o un lcd_putc("\n");

Si quieres mostrar el mensaje en una sola linea y desplazar el mensaje puedes enviar este comando varias veces después de haber escrito el mensaje:
lcd_send_byte(0,0x1C); Esto mueve el display una posición a la derecha, o lcd_send_byte(0,0x18); Esto mueve el display una posición a la izquierda

Título: Re: Ejemplitos en C para 16F648A
Publicado por: mexpic en 14 de Julio de 2009, 15:52:35

hola a todo el mundo en especial a vszener q nos hace favor de compartir su conocimiento con todos

bueno antes q nada pedir disculpas si me desvio un poco del tema o algo asi jaja

entonces bueno tengo un problema lo que pasa es que quiero hacer un glucometro con un pic estoy actualmente con el 16f877a sobradisimo no pero el de batalla
ya tengo las siguientes funciones para esto bueno lo que me pidieron segun esto seria mejor con un dspic en esa es mi primera cuestion, bueno entonces iguiendo con lo que estaba me piden esto bueno la mayoria ya lo tengo aqui estan:
1.- la lectura de los datos osea que convertir la señal de entrada que segun yo es analogica y convertirla a datos digitales (el pic lo tiene q vendicion asi no compro otro pero no se si sea el adecuado).
2.-la lectura pasa a visualizarse en la LCD que conjunte para mostrar los datos de entrada pero ya convertidos a datos digitales.
3.-la comunicacion con rs232 solo los datos que envia el pic (estos datos los visualizo en visual basic 6).

ahora bien queria saber como ustedes son mu buenos para esto hacerles unas preguntas.
1.- que me convendria mas usar este pic o usar otro no se si pueda ser los dspic.
2.- desviando unpoco lo del pic que sensor me podrian recomendar para poder tener la señal de glucosa en la sangre (estaba pensando en laser o algo asi).
3.- si tengo queusar algun A/D que no sea del pic.

bueno un saludo y espero que me puedan ayudar o dandome alguna idea
les repito una disculpa si me desvio del tema
gracias. :?

Título: Re: RE: Ejemplitos en C para 16F648A
Publicado por: palmas5678 en 23 de Septiembre de 2009, 22:54:13

Hola vszener, tal vez puedas ayudarme, necesito reemplazar el codec HT12E y el decode HT12D con el pic 16f84 o 16F628 (por que no los encuentro, ya estoy esperando mas de tres meses y no llegan al Perú). La idea es enviar un dato en forma serial por cualquier pin del puerto B, cuando se activa un pulsador y recibirlo por un puerto B de otro pic similar, luego al soltar el pulsador, el led se apagará. Lo que quiero es saber el código de la transmisión serial y poder encender un led y apagarlo cuando activo un pulsador en el otro pic. Gracias.

Palmas

Título: Re: RE: Ejemplitos en C para 16F648A
Publicado por: Suky en 23 de Septiembre de 2009, 23:40:04

Cita de: palmas5678 en 23 de Septiembre de 2009, 22:54:13

Hola vszener, tal vez puedas ayudarme, necesito reemplazar el codec HT12E y el decode HT12D con el pic 16f84 o 16F628 (por que no los encuentro, ya estoy esperando mas de tres meses y no llegan al Perú). La idea es enviar un dato en forma serial por cualquier pin del puerto B, cuando se activa un pulsador y recibirlo por un puerto B de otro pic similar, luego al soltar el pulsador, el led se apagará. Lo que quiero es saber el código de la transmisión serial y poder encender un led y apagarlo cuando activo un pulsador en el otro pic. Gracias.

Palmas

Revisa el siguiente ejemplo (http://www.todopic.com.ar/foros/index.php?topic=4530.msg38961#msg38961) de vszener, a partir de ese ya podes ir diseñando el tuyo. Y revisa que vi un par de ejemplos más de comunicación RS23 ;-)

Saludos!

Título: Re: Ejemplitos en C para 16F648A
Publicado por: bakhosm en 17 de Octubre de 2009, 21:35:48

hola, estoy tratando de hacer un programa que en C, que envie un mensaje de la siguiente manera:

PIC1 > PIC2 > PC

para explicarlo de mejor manera:

el PIC1 envia "sistema activo", y el PIC2 reenvia el mensaje a la PC.

supongo que es por medio del getc() pero no veo por donde empezar :?

la comunicacion la se hacer el problema es tomar el MENSAJE y reenviarlo

la comunicacion entre el PIC1 y el PIC2 es HALF, solo el PIC1 le transmite informacion al PIC2, pero entre el PIC2 y la PC es FULL.

espero haberme explicado bien y gracias de antemano

alguna idea de como tomar el mensaja del PIC1 y reenviarla en este caso a la PC?

Título: Re: Ejemplitos en C para 16F648A
Publicado por: LABmouse en 17 de Octubre de 2009, 22:48:21

Código: [Seleccionar]

value=getchar();

printf("%C",value);

Eso de atrás, toma un dato por RS232, luego lo envía.

Título: Re: Ejemplitos en C para 16F648A
Publicado por: Suky en 17 de Octubre de 2009, 23:23:06

Por aquí (http://www.todopic.com.ar/foros/index.php?topic=26297.msg216070#msg216070) hay ejemplos de uso de 2 comunicaciones seriales en un PIC, como recibir/enviar con cada bus.-

Saludos!

Título: Re: Ejemplitos en C para 16F648A
Publicado por: bakhosm en 17 de Octubre de 2009, 23:55:02

gracias suky y PICmouse, estare probando...

Título: Re: Ejemplitos en C para 16F648A
Publicado por: bakhosm en 18 de Octubre de 2009, 01:23:15

sigo con el mismo problema pero ahora el PIC2 transmite nada, tome el ejemplo de Suky y lo adapte a lo que necesitaba (y creo que le falta mas al codigo), llevo dias con esto, y se que estoy cerca pero no hallo la solucion :? :(

les adjuntaré el esquematico y los codigos a ver si me pueden ayudar

el del PIC1 no es nada complicado, solo un envio de mensaje para poder hacer la comunicacion

Código: [Seleccionar]

#include <16F877A.h>

#FUSES NOWDT                    //No Watch Dog Timer
#FUSES XT                       //Crystal osc <= 4mhz
#FUSES NOPUT                    //No Power Up Timer
#FUSES NOPROTECT                //Code not protected from reading
#FUSES NODEBUG                  //No Debug mode for ICD
#FUSES NOBROWNOUT               //No brownout reset
#FUSES NOLVP                    //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
#FUSES NOCPD                    //No EE protection
#FUSES NOWRT                    //Program memory not write protected

#use delay (clock=4000000)
#use RS232 (baud=9600,parity=N,xmiT=PIN_C6,rcv=PIN_C7,bits=8)

void main(void)
{
printf("  Bienvenidos...   \rSistema Encendido\r");
}

cuando coloco el codigo de la pagina que dijo suky en el PIC2 el terminal de proteus no se ve nada, aqui se los dejo

Código: [Seleccionar]

#include <16F877A.h>
#include <string.h>

#FUSES NOWDT                    //No Watch Dog Timer
#FUSES XT                       //Crystal osc <= 4mhz
#FUSES NOPUT                    //No Power Up Timer
#FUSES NOPROTECT                //Code not protected from reading
#FUSES NODEBUG                  //No Debug mode for ICD
#FUSES NOBROWNOUT               //No brownout reset
#FUSES NOLVP                    //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
#FUSES NOCPD                    //No EE protection
#FUSES NOWRT                    //Program memory not write protected

#use delay (clock=4000000)
#use RS232 (STREAM= ROBOT, baud=9600,parity=N,xmiT=PIN_C4,rcv=PIN_C5,bits=8) 
#use RS232 (STREAM= PC,baud=9600,parity=N,xmiT=PIN_C6,rcv=PIN_C7,bits=8)    

char string_robot[16];
char string_pc[16];
int1 kbhit_robot=0; // Para saber si llego dato desde la alarma.
int1 kbhit_pc=0; // Para saber si llego dato desde el modem.

#int_EXT
void ext_isr()
{
 gets(string_pc,PC);
 kbhit_pc=1;
}

#int_RDA
void rda_isr()
{
 gets(string_robot,robot);
 kbhit_robot=1;
}

void main(void)
{ 
printf("esperando dato");

SET_TRIS_C(0b10100000);
 ext_int_edge(H_TO_L);
 enable_interrupts(int_RDA);
 enable_interrupts(int_EXT);
 enable_interrupts(GLOBAL);
while(1)
 {
  while(kbhit_robot==0&&kbhit_pc==0){} //Espero a que llegue dato desde algun dispositivo.
       if(kbhit_robot)
       {
        fprintf(ROBOT,"\n\rEl dato de la alarma fue: %s",string_robot);
       }
       if(kbhit_pc)
       {
        fprintf(PC,"\n\rEl dato del modem fue: %s",string_robot);
       }
  kbhit_robot=0;
  kbhit_pc=0; // Reinicio bandera para proxima espera.
 } 
}

Tengo proteus 7.6 SP0 y el compilador de C es CCS COMPILER 4.023 (IDE / PCB / PCM / PCH)

a ver si ustedes lo ven desde otra perspectiva, xq de verdad no doy con la falla.

de antemano muchas gracias

Título: Re: Ejemplitos en C para 16F648A
Publicado por: bakhosm en 18 de Octubre de 2009, 21:22:12

:-/ :-/ :-/ :-/ :-/ :-/ :-/ :mrgreen: :mrgreen: :mrgreen: :mrgreen: :mrgreen: :mrgreen: :mrgreen:

LISTOOOOOOOOOOO LO LOGREEEE :mrgreen: :mrgreen: :-/ :-/ :-/

logre la comunicacion entre los dos pics y la pc el problema era el proteus que no funcionaba el CPP y no funcionaba la simulacion del hiperterminal, no funciono ni el 7.6 SP0 mni el 7.5 SP3

alguna sugerencia???

Título: Re: Ejemplitos en C para 16F648A
Publicado por: Cryn en 18 de Octubre de 2009, 21:50:28

no confíes mucho en el proteus, si ayuda bastante, pero a veces trae más de un dolor en la panza

que bien que ya te haya funcionado

Título: Re: Ejemplitos en C para 16F648A
Publicado por: bakhosm en 18 de Octubre de 2009, 23:06:57

si eso aprendi de esta experiencia, perdi toda la noche de ayer solo y media mañana con un amigo probando gracias a el logre hacer un protocolo y detectar la falla jeje...

en un rato quemo los pics cuando termine mi proyecto publico el protocolo que usé para que funcionará.

mi proyecto lleva sensor de ultrasonido PING )) de paralax, seguire con el programa, tengo un codigo en ASM, a ver como lo adapto sin usar #ASM y #ENDASM

Título: Re: Ejemplitos en C para 16F648A
Publicado por: RALF2 en 25 de Octubre de 2009, 20:03:45

Que tal amigos!
Aqui les coloco un nuevo ejemplito :mrgreen:
Esta vez se trata del juego de luces del auto fantastico (http://www.youtube.com/watch?v=9qA3tll5Bmg). ;-)

Citar

// Luces del auto fantastico por Ralf2, Foro todopic!
#include <16F876a.h>
#device adc = 10
#use delay (CLOCK = 4000000)
#fuses XT,NOWDT,NOLVP
#byte port_b=6
#byte port_c=7
#use fast_io(all)

void main()
{
int x;
port_b=0;
port_c=0;
set_tris_b(0);
set_tris_c(0);
port_b=1;
while(1)
{
for (x=0;x<=14;x++)
{
shift_left(&port_b,2,0);
delay_ms(100);
}

for (x=0; x<=14;x++)
{
shift_right(&port_b,2,0);
delay_ms(100);
}
}

}

Título: Re: Ejemplitos en C para 16F648A
Publicado por: Miquel_S en 18 de Noviembre de 2009, 19:59:29

Hola, alguien puede decirme porque en este codigo de VsZeNer puedo cambiar los mensajes excepto el primero.

Código: CSS

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"05      
//                     30/Agosto/05
//
//   Programa:   Escribir & leer eeprom interna del PIC y mostrarla por lcd
//   Version:   0.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.227
//   Entorno IDE: MPLAB IDE v7.21      Simulador:    Proteus 6.7sp3
//
//   Notas: Se muestra por pantalla de lcd(LM016L) la informacion grabada en la memoria
//         interna del PIC(eeprom) y luego se muestra por la lcd
//         Se utiliza variables locales:
//            ·LAST_VOLUME -> posicion a grabar en la eeprom del pic
//            ·mensaje1[] -> contiene 1º mensaje a escribir en eeprom y mostrar en lcd
//            ·mensaje2[] -> contiene 2º mensaje a escribir en eeprom y mostrar en lcd
//            ·mensaje3[] -> contiene 3º mensaje a escribir en eeprom y mostrar en lcd
//            ·mensaje4[] -> contiene 4º mensaje a escribir en eeprom y mostrar en lcd
//            ·volume -> contiene mensaje leido por la eeprom interna del pic
//         Tener en cuenta que hay que poner la directiva NOLVP para que el pin B4 sea de
//         salida.
//   Conexiones:      B0 -> E            
//               B1 -> RS         
//               B2 -> RW      
//               B4 -> D4        
//               B5 -> D5            
//               B6 -> D6   
//               B7 -> D7                  
//////////////////////////////////////////////////////////////////////////////////
 
#include <16f648a.h>            //pic a utilizar          
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP      //ordenes para el programador
#use delay (clock=4000000)         //Fosc=4Mhz
#define use_portb_lcd TRUE         //definir portb lcd
#include<lcd.c>                  //libreria manejo lcd
 
      
///PROGRAMA
void main(void)
{
   char LAST_VOLUME=0,volume;      //variables de direccion escritura eeprom y mensaje
   char mensaje1[]="VsZeNeR"05";   //mensajes...
   char mensaje2[]="HOLA";
   char mensaje3[]="FORO";
   char mensaje4[]="TODOPIC!";      //a escribir en eeprom interna y mostrar en lcd   
      
   lcd_init();                  //inicializa lcd
   
   write_eeprom(LAST_VOLUME,mensaje1);   //escritura de los mensajes...
   LAST_VOLUME++;
   write_eeprom(LAST_VOLUME,mensaje2);
   LAST_VOLUME++;
   write_eeprom(LAST_VOLUME,mensaje3);
   LAST_VOLUME++;
   write_eeprom(LAST_VOLUME,mensaje4);   //...en la eeprom interna(0 hasta la 3)
   
   for( ; ; ){   //bucle...
      for(LAST_VOLUME=0;LAST_VOLUME<4;LAST_VOLUME++){   //bucle que recorre las posiciones de eeprom
      volume = read_EEPROM (LAST_VOLUME);            //almacena mensaje de la direccion eeprom
      printf(lcd_putc,"%s",volume) ;               //muestra mensaje por pantalla lcd
      delay_ms(500);
      lcd_putc("f" );                           //borra pantalla lcd
      }      //...infinito
   }
}

Título: Re: Ejemplitos en C para 16F648A
Publicado por: Suky en 18 de Noviembre de 2009, 21:37:13

Revisa por aquí (http://www.todopic.com.ar/foros/index.php?topic=27691.msg228448#msg228448), se comenta el mismo problema y Mig explica como se debe hacer correctamente.

Saludos!

Título: Re: Ejemplitos en C para 16F648A
Publicado por: delth en 13 de Diciembre de 2009, 23:58:29

Hola Vszener,

Primero que nada muchas gracias por tus valiosas contribuciones en este foro...

Estoy tratando de probar los ejemplos pero me marca el siguiente error al compilar el ejemplo del "Parpadeo de un led cada 0.5s":

*** Error 24 "C:\Program Files\PICC\devices\18f452.h" Line 2(9,18): Unknown device type
1 Errors, 0 Warnings.

Este es mi escenario (integrando el compilador CCS en Mplab y modificando el codigo para usar el Pic18F452 en lugar del Pic16F648A):
MPLAB 8.40
CCS 4.13 (Demo Version)
ICD2 Debugger
PIC18F452 (Device)
PICDEM 2 PLUS (Target)

De antemano muchas gracias.

Título: Re: Ejemplitos en C para 16F648A
Publicado por: vszener en 16 de Diciembre de 2009, 05:23:55

Buenas delth:

Asegurate que la librería de tu dispositivo se encuentra en la siguiente dirección: C:\Program Files\PICC\devices\

Un saludi. ;)

Título: Re: Ejemplitos en C para 16F648A
Publicado por: Cortijero en 07 de Abril de 2010, 07:20:26

Hola! estoy siguiendo este tutorial, pero me he atascado :(
Estoy intentando hacer el programita de la lcd y el teclado matricial, pero no soy capaz. A ver si alguien por aqui me puede ayudar (he creado un tema con esta duda, pero creo que antes deberia haber preguntado aqui )
La cuestion es que lo hago todo tal cual esta aqui, a excepcio del pic, que uso un 18f4550. Baje las bibliotecas, las puse en su lugar.... y nada de nada... Este es el codigo, a ver si veis algun error, que yo ya me he cegado y no veo nada :oops:

Código: [Seleccionar]

#include <18F4550.h>           //Libreria del PIC
#fuses XT,NOMCLR,NOWDT,NOPROTECT,NOLVP,NODEBUG,USBDIV,PLL1,CPUDIV1,NOVREGEN,NOPBADEN //Configuracion de los fuses:
#use delay (clock=4000000)    //Configuramos oscilador a 4Mhz
#include <lcd2.c>   //Libreria para la lcd
#include <kbd3x4.c>   //Libreria para teclado matricial
#use fast_io(A)
#use fast_io(B)


//---------- PROGRAMA PRINCIPAL ----------------
void main ()
{
   char tecla;   //almacena tecla pulsada
   lcd_init();      //inicializa lcd
   lcd_putc("Tecla pulsada:\n");   
   for(;;){
      do{               //espera hasta que se pulse una tecla
         tecla=kbd_getc();   
         }while(tecla==0);
         
      printf(lcd_putc,"%c",tecla);      //muestra tecla
      lcd_putc("\b");            //retrocede una posicion
      }      //...infinito
      
}

Título: Re: Ejemplitos en C para 16F648A
Publicado por: cerebro en 07 de Abril de 2010, 19:07:37

creo que el problema esta en la forma que configuras el oscilador fijate en la pagina 24 del datasheet. Si utilizas un cristal XT no es necesario activar el PLL ni el USBDIV.

Código: [Seleccionar]

#fuses XT,NOMCLR,NOWDT,NOPROTECT,NOLVP,NODEBUG,CPUDIV1,NOVREGEN,NOPBADEN a ver si resuelve tu problema.

Saludos!

PD: Si vas a utilizar el USB el fuse correcto para llegar a los 48 MHz sería XTPLL pero ya es otro tema.

Título: como hacemos para incrementar 2 numeros.
Publicado por: RAMON292 en 25 de Abril de 2010, 22:07:21

Hola a todo .- Aprovecho para felicitarlo a todo por este mundo en la electronica.- ya que para mi "PIC" es palabra mayor .--

Mi problema estoy haciendo un contador 0000 a 9999 .- lo tengo funcionando pero no estoy entendiendo como hacer ya que quiero que me sume Ej: 12 + 12 + 12 + ... y visualizar en resultado en dysplay.- 7 seg.-

le paso el codigo para que me lo analicen .- ya que no se como encarar la suma el incremento lo hace trave de un pulsador por interupcion de cambio de estado.-

#include "16F628A.h" //Incluye el fichero de símbolos y etiquetas.
#use delay (clock=4000000) //Define la frecuencia del oscilador.
#fuses HS,NOWDT,NOPUT,NOBROWNOUT,NOLVP,NOPROTECT,NOCPD//Define palabra de conf. para la grabación del micro.
#use fixed_io(a_outputs=PIN_A0,PIN_A1,PIN_A2,PIN_A3)
#use fixed_io(b_outputs=PIN_B0,PIN_B1,PIN_B2,PIN_B3)
///VARIABLES GLOBALES
int di2=0,di1=0,di0=0,di3=0;
int16 var=0;
//LLAMADA FUNCION INTERRUPCION

#INT_RB

void cualquiercosa()

{

if(input(PIN_B4)) //se ingreso dato?

{
var++; //var aumenta 1.
if(var>=1) var=0,di3++; //var es mayor o igual a 1? si=>var=0 y di2 aumenta 1.
if(di3==10) di3=0,di2++;
if(di2==10) di2=0,di1++; //di2 es igual a 10? si=>di2=0 y di1 aumenta 1.
if(di1==10) di1=0,di0++; //di1 es igual a 10? si=>di1=0 y di0 aumenta 1.
if(di0==10) di0=0; //di0 es igual a 10? si=>di0=0.

}
}

///PROGRAMA
void main(void)
{

enable_interrupts(INT_RB); //Activa Interrupcion por Cambio de Estado de PIN
enable_interrupts(GLOBAL); //Habilita Interrupciones globales

while (true)

{ output_a(0); //Saca por el Puerto A el valor 0 (todos en low)
output_high(PIN_A3); //Habilita di2
output_b(di3); //Saca por el Puerto B el valor de di2
delay_ms(10); //retardo
output_a(0); //Saca por el Puerto A el valor 0 (todos en low)
output_high(PIN_A2); //Habilita di2
output_b(di2); //Saca por el Puerto B el valor de di2
delay_ms(10); //retardo
output_a(0);
output_high(PIN_A1); //Saca por el Puerto A el valor 0 (todos en low)
output_b(di1); //Saca por el Puerto B el valor de di1
delay_ms(10); //retardo
output_a(0);
output_high(PIN_A0); //Habilita di0
output_b(di0); //Saca por el Puerto B el valor de di0
delay_ms(10);
}
}

desde ya muchas gracias.-

Título: Re: Ejemplitos en C para 16F648A
Publicado por: robotec en 01 de Julio de 2010, 16:30:59

que tal, apenas adentro al mundo de programacion en c y voy a seguir este tutorial saludos

Título: Re: Ejemplitos en C para 16F648A
Publicado por: losgrises en 30 de Agosto de 2010, 18:19:58

Hola gente del foro!! Realmente he estado leyendo hace rato muchos de los ejemplos del foro. Querria pedirles si pueden postear la libreria kdb3x4.c par usar el teclado conjuntamente con una lcd 20x2 8bit..bueno la libreria para el lcd ya la tengo lcd2.c .
Les agradeceria muchisimo que me puedan ayudar. Estoy haciendo mi proyecto de fin de carrera y una parte de ete consta de programar en un lcd un menu de opciones que dependeran estas de las teclas pulsadas del teclado 3x4 y no tengo pines de sobra para utilizar por eso tengo q realizarlo si o si de esa forma ( en conjunto ambos)(por cierto los utilizare en el puerto d a ambos).
Mi correo por si alguie quiere consultarme algo o que me faciliten la libreria kdb3x4.c es el siguiente: lui79_leon2002@yahoo.com.ar
Estare muy agradecido con cualquier ayuda!
Muchas gracias! Luis.

Título: Re: Ejemplitos en C para 16F648A
Publicado por: Suky en 30 de Agosto de 2010, 19:19:10

Es sencillo realizar la librería para un keypad, pero sino también tenes la propia de CCS, búscala como kdb.c en la carpeta driver.

Saludos!

Título: Re: Ejemplitos en C para 16F648A
Publicado por: zaratustra_x en 05 de Diciembre de 2010, 11:58:10

Cita de: pelusac en 30 de Julio de 2007, 09:13:21

Con respecto a las librerías aquí están, ves como no es tan lamentable la filosofia del foro es compartir y compartir y compartir.
Saludos

Muchas gracias por compartir las librerias :-/

Ssaludos

Título: Re: RE: Ejemplitos en C para 16F648A
Publicado por: kl-shadows en 20 de Diciembre de 2010, 18:03:10

Cita de: vszener en 22 de Septiembre de 2005, 08:28:00

Desde este enlace os podeis descargar lo necesario para el programa anterior: Claves

Suerte!!! :wink:

Vs zener :
Bueno sabes estan muy buenos tus ejemplos y ademas he logrado simularlos muy bien pero tengo un pequeño
problema porque me faltan unas librerias para el proteus.
la version mia de proteus es la v7.7 si fueras tan amable de ayudarme a conseguirlas seras un maestro para mi.
muchas gracias por tus aportes y ojala me ayudaras.

:-/

Título: Re: Ejemplitos en C para 16F648A
Publicado por: vszener en 21 de Diciembre de 2010, 13:30:41

Buenas:

Todas las librerías necesarias para los ejemplitos están puestas en el primer mensaje para su descarga. En caso de que necesites librerías específicas de Proteus no te las puedo facilitar ya que están vinculadas al propio programa mediante licencia.

Un saludo ;)

Título: Re: Ejemplitos en C para 16F648A
Publicado por: zerovlc en 03 de Marzo de 2011, 15:08:26

hola buenos primero felicitar por los ejemplos son muy utiles, me preguntaba si hay posibilidad de comunicar dos pic 16f84a utilizando el protocolo i2c y si puede ser posible algun ejemplo de este ya que voy un poco perdido gracias

Título: Re: RE: Ejemplitos en C para 16F648A
Publicado por: ingero en 13 de Marzo de 2011, 14:35:09

Cita de: vszener en 13 de Agosto de 2005, 16:38:00

El primer ejemplo como no!!! la iluminacion de un led!!!jeje alguien alguna vez a visto programa similar???jeje bueno fuera de bromas por alguno hay que empezar y este es el nivel inferior jeje. El programa consiste en el encendido y apagado d eun led cada 0.5s por el pin RB0 del pueto B:

////////////////////////////////////////////////////////////////////////////////////
//   VsZeNeR"05
// 6/Agosto/05
//
//Programa:   Parpadeo de un led cada 0.5s
//Version:   0.0
//
//Dispositivo: PIC 16F648A      Compilador:    CCS vs3.227
//Entorno IDE: MPLAB IDE v7.20   Simulador:    Proteus 6.7sp3
//
//Notas: Parpadeo de un led cada 0.5s por el pin RB0 del puerto B
//////////////////////////////////////////////////////////////////////////////////

#include <16f648a.h>         //pic a utilizar
#fuses XT,NOWDT,NOPROTECT,PUT      //ordenes para el programador
#use delay (clock=4000000)         //Fosc=4Mhz
#use fast_io(b)

///PROGRAMA
void main(void)
{
   set_tris_b(0xFE);   //portb como salida(RB0,las demas desactivadas)
   disable_interrupts(GLOBAL);   //todas las interrupciones desactivadas

   do{
      output_low(PIN_B0); //led off
      delay_ms(500);
      output_high(PIN_B0); //led on
      delay_ms(500);
   }while(TRUE);       //bucle infinito
}

Seguimos en contacto!<img src="http://pics.miarroba.com/caretos/wink.gif" alt="Giño" title="Giño" />

como kedari el ejemplo en un pic 18f2550 con proteus tambien

Título: Re: RE: Ejemplitos en C para 16F648A
Publicado por: ingero en 13 de Marzo de 2011, 14:41:46

Cita de: vszener en 29 de Agosto de 2005, 05:04:00

Y para empezar con estos "cacharros" que mejor que decir "hola mundo" jeje pues aqui esta!!!!:

////////////////////////////////////////////////////////////////////////////////////
//                     VsZeNeR"05
//                   26/Agosto/05
//
//   Programa:   Hola mundo
//   Version:   0.0
//
//   Dispositivo: PIC 16F648A         Compilador:    CCS vs3.227
//   Entorno IDE: MPLAB IDE v7.21      Simulador:    Proteus 6.7sp3
//
//   Notas: Se muestra por pantalla de lcd(LM016L) en la primera linea la
//       frase "hola mundo <img src="http://pics.miarroba.com/caretos/wink.gif" alt="Giño" title="Giño" />" y en la segunda linea "VsZeNeR"05". Tener
//       en cuenta que hay que poner la directiva NOLVP para que el pin B4 sea de
//       salida.
//
//   Conexiones:      B0 -> E
//               B1 -> RS
//               B2 -> RW
//               B4 -> D4
//               B5 -> D5
//               B6 -> D6
//               B7 -> D7
//////////////////////////////////////////////////////////////////////////////////

#include <16f648a.h>            //pic a utilizar
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP      //ordenes para el programador
#use delay (clock=4000000)         //Fosc=4Mhz
#define use_portb_lcd TRUE         //definir portb lcd
#include<lcd.c>                  //libreria manejo lcd

///PROGRAMA
void main(void)
{
   lcd_init();         //inicializa lcd
   printf(lcd_putc,"hola mundo ; )
VsZeNeR"05" );   //muestra por pantalla el mensaje
}

Jeje ya sabemos encender las lcd"s.....<img src="http://pics.miarroba.com/caretos/wink.gif" alt="Giño" title="Giño" />

como quedaria este ejemplo con el pic 18f2550

Título: Re: Ejemplitos en C para 16F648A
Publicado por: pocher en 13 de Marzo de 2011, 16:05:46

Ya se te ha dicho en otro tema que te pongas a estudiar.

¿No sabes cambiar un PIC por otro?

Debes de exponer alguna idea, algo, un mínimo ... de lo contrario los deberes no te los realizaremos.

Título: Re: Ejemplitos en C para 16F648A
Publicado por: danielpardo92 en 08 de Julio de 2011, 13:47:18

MUY BUENO... me han ayudado mucho los proyectos que ha publicado que tienen que ver con la LCD (sobre todo la del teclado) gracias...

Título: Re: Ejemplitos en C para 16F648A
Publicado por: davidrrb1 en 20 de Octubre de 2011, 02:00:39

Muy bueno estos ejemplos en pcw, pero tengo una duda sobre el ejemplo del contador de 0 a 99 con timer que es el ajuste fino como hago ese ajuste teniendo la formula del timer porque lo ponen a 50ms y le hacen el ajuste disculpen las preguntas pero soy nuevo en esto de los pics y estoy haciendo cada uno de los ejemplos
if(flag>var){      //¿ya es 1 segundo?
      var--;         //SI -> decremento var...
      if(var<18)
         var=20;      //...ajuste fino de 1s
      flag=0;         //reset flag para contar 1s
      if(i>8){
no entendi esa parte.

Título: Re: Ejemplitos en C para 16F648A
Publicado por: fran_j_P en 18 de Noviembre de 2011, 11:40:15

buen dia amigo tengo una pregunta yo le realice una modificación al programa original del 16f648a al 16f88 que el que se consigue en mi pais lo simulo y todo bien pero cuando lo monto en la practica en displey se no funciona correctamente y se coloca a saltar de un digito a otro espero pronta respuesta gracias

Título: Re: Ejemplitos en C para 16F648A
Publicado por: callecuatro1976 en 29 de Diciembre de 2011, 16:43:40

#include <16f84a.h>
#fuses nowdt,xt, put

#use delay (clock=4m)
#byte puerto_b=0x06
#use standard_io(b)
#use standard_io(a)

void ext(void);

unsigned int const display[10]={0x7e,0x30,0x6d,0x79,0x33,0x5b,0x5f,0x70,0x7f,0x73};

int x=0,y=0,z=0,o=0;

int flag=0,var=20;

void main(void{

set_tris_b(0x00);

puerto_b=0;

d:
if (input(pin_a0)==1)
ext();
output_high(PIN_A1);
output_high(PIN_A2);
output_high(PIN_A3);
output_low(PIN_A4); //activado...
output_b(display[ x ]); //...1º 7seg
delay_ms(10);
output_high(PIN_A1);
output_high(PIN_A2);
output_low(PIN_A3); //activado...
output_high(PIN_A4);
output_b(display[ y ]); //...2º 7seg
delay_ms(10);
output_high(PIN_A1);
output_low(PIN_A2); //activado...
output_high(PIN_A3);
output_high(PIN_A4);
output_b(display[ z]); //...3º 7seg
delay_ms(10);
output_low(PIN_A1); //activado...
output_high(PIN_A2);
output_high(PIN_A3);
output_high(PIN_A4);
output_b(display[ o ]); //...4º 7seg
delay_ms(10);

goto d;

}

void ext (void) {

if(x>=9){
x=0;
y++;
if(y>9){
y=0;
z++;
if(z>9){
z=0;
o++;
if(o>9)
o=0;
}
}
}
else{

x++; }

}

hise este programa basandome el el de zener y tengo un problema cuando lo cargo al pic arranca y no para nunca de contar y en el proteus anda perfecto alguna idea como seguir ,con el contador, saludos

Título: Re: Ejemplitos en C para 16F648A
Publicado por: callecuatro1976 en 29 de Diciembre de 2011, 17:28:21

Cita de: fran_j_P en 18 de Noviembre de 2011, 11:40:15

buen dia amigo tengo una pregunta yo le realice una modificación al programa original del 16f648a al 16f88 que el que se consigue en mi pais lo simulo y todo bien pero cuando lo monto en la practica en displey se no funciona correctamente y se coloca a saltar de un digito a otro espero pronta respuesta gracias

si ami me paso algo parecido y le baje la tension al pic en 3 volt y me empezo a andar , me parese que no aguanta la corriente el pic hay que ponerle transistores

Título: Re: Ejemplitos en C para 16F648A
Publicado por: jukinch en 29 de Diciembre de 2011, 18:32:49

callecuatro1976:
tenés un error aquí:

void main(void{

debería ser:

void main(void){

Saludos.
Jukinch

Título: Re: Ejemplitos en C para 16F648A
Publicado por: callecuatro1976 en 30 de Diciembre de 2011, 18:27:45

gracias era eso y me faltaba una resistencia en el pin a0`para que el ruido no moleste , saludos

Título: Re: RE: Ejemplitos en C para 16F648A
Publicado por: junior perez en 18 de Junio de 2012, 23:21:09

hola amigo para que se utiliza c=kbd_getc(); gracias...

Título: Re: Ejemplitos en C para 16F648A
Publicado por: bigluis en 18 de Junio de 2012, 23:21:56

Eso es para leer los datos provenientes de un teclado de 3x4 o de 4x4.

Título: Re: RE: Ejemplitos en C para 16F648A
Publicado por: futurama en 04 de Septiembre de 2012, 10:41:56

tengo una duda

Título: Re: RE: Ejemplitos en C para 16F648A
Publicado por: Suky en 04 de Septiembre de 2012, 10:59:54

Cita de: futurama en 04 de Septiembre de 2012, 10:41:56

tengo una duda

:mrgreen: Será Fry?

Citar

Fry: Estoy teniendo una de esas cosas... ya sabes jaquecas con imagenes...
Leela: quieres decir ideas?!
Fray: Si claro eso!!!

:mrgreen:

Título: comopuedo aplicar esta rutina al apretar un boton
Publicado por: futurama en 30 de Septiembre de 2012, 01:42:06

hola, soy nuevo en este foro, me gustaria saber como puedo activar 2 salidas con un boton, por ejemplo
BOTON (RA0) = RB0(LED PARPADEANDO) Y RB1 (LED ENCENDIDO) =(SALIDAS ACTIVADAS)
BOTON (RA1) = RB2(LED PARPADEANDO) Y RB3 (LED ENCENDIDO) = (SALIDAS ACTIVADAS), lo e intentado pero solo logro que se encienda el led, pero no lo puedo hacer parpadear.

Título: Re: Ejemplitos en C para 16F648A
Publicado por: futurama en 30 de Septiembre de 2012, 01:48:12

bueno la idea

Título: Re: Ejemplitos en C para 16F648A
Publicado por: Fer_TACA en 01 de Octubre de 2012, 01:50:46

Pues lo ideal seria que adjuntaras lo que has realizado para ver donde está el fallo

F.

Título: Re: Ejemplitos en C para 16F648A
Publicado por: swivels en 11 de Noviembre de 2012, 15:47:57

muy buen foro y todos muy atentos y ambles estoy aprendiendo mucho, aunque estoy iniciando en este medio este foro me esta ayudando bastante, felicitaciones y saludos a todos por sus aportes!!!

Título: Re: Ejemplitos en C para 16F648A
Publicado por: Kurt Cobain en 26 de Enero de 2013, 17:13:17

Algún código C para el control de servomotor con el pic16f84a?

Título: Re: RE: Ejemplitos en C para 16F648A
Publicado por: Tavo en 13 de Febrero de 2013, 16:34:35

Cita de: vszener en 20 de Septiembre de 2005, 10:57:00

Pues siguiendo la politica y filosofia de un profe mi de la universidad, el cual decia: "no pierdas el tiempo en hacer lo fabricado...." he mirado por internet y por el foro una libreria para la lcd y para el teclado, y he hallado una!!!jeje la libreria son de la empresa Microsystems Engineering...aqui dejo el enlace para que os bajeis los ejemplos donde estan la slibrerias kbd2.c y lcd2.c:
<a href="http://www.msebilbao.com/tienda/downloads_ejemplos.php" target="_blank">http://www.msebilbao.com/tienda/downloads_ejemplos.php[/url]
Decir que la libreria lcd2.c es de 8 bits y la del CCS es de 4 bits.....pero bueno ya buscaremos mas o me pondre yo mano a la obra haber que sale!!!jeje....decir quee stas librerias las vamos a usar y tb modificar.....aqui dejo el enlace para que os bajeis las librerias mencionadas y la modificacion del kbd2.c a kbd3x4.c...la modificacion la he hecho porque la kbd2.c es para teclado 4x4 y de momento nosotros vamos a usar teclados 3x4.....
<a href="http://miarroba.com/foros/ver.php?foroid=348538&temaid=3622968" target="_blank">http://miarroba.com/foros/ver.php?foroid=348538&temaid=3622968[/url]
<img src="http://pics.miarroba.com/caretos/wink.gif" alt="Giño" title="Giño" />

Hola vszener.
Los links de las librerias no funcionan.
Serias tan amable de pasarmelos ?
Gracias.

Título: Re: Ejemplitos en C para 16F648A
Publicado por: vszener en 15 de Febrero de 2013, 07:06:06

Buenas:

En el primer mensaje tienes el almacén de todos los recursos que se han necesitado para realizar los ejemplos.

Suerte ;)

Título: Re: Ejemplitos en C para 16F648A
Publicado por: kokeforever en 27 de Mayo de 2013, 21:58:24

HOLA aprecio en verdad tu trabajo y el que compartas tu conocimiento amigo.
Tengo una duda, estoy en 6to semestre de Ing. Electrónica y me están pidiendo que haga para proyecto final un circuito en protoboard el que yo quiera, ya muchos ya lo entregaron nadamás falto yo y quisiera saber si me porías ayudar para hacer una secuencia de leds, unos 8 leds, pero que sean 10 secuencias diferentes en el mismo codigo, estoy usando un pic16F84ay un oscilador de 4mhz, y el profesor quiere que le entreguemos tambien el codigo en lenguaje C.
Mi duda es como poner por ejemplo todas las secuencias de leds que tienes arriba en un solo código que funcione bien, sin necesidad de poner un switch, osea que todo lo haga la prgramación???
como le iria agregando los codigos de secuencias al codigo original por ejemplo el del coche fantastico, que va de izquierda a derecha, y como agregarle un codigo para qe despues de hacer esa secuencia unas 3 veces cambie a otra automaticamente por ejemplo del centro hacia los lados o de los lados hacia el centro.
Este es mi email por si tienes tiempo de ayudarme con este proyecto: slayer.skull@live.com.mx
ya lo tengo armado y tengo el pic y el grabador de pic solo me falta ese codigo con las 10 secuencias o más si se puede...
Muchas gracias y un saludo desde México.

Título: Re: Ejemplitos en C para 16F648A
Publicado por: jhonjz en 11 de Noviembre de 2013, 20:29:32

Hola amig@s. Aprovechando esta serie de ejemplos que han posteado y muy buenos, quisiera generar una duda respecto a hacer que un led parpadee, les comento la siguiente cuestión: he hecho varios ejemplos sobre esto, pero todos han sido de la misma forma, es decir, cuento por ejemplo con un pulsador conectado en RA0 y cuando lo presiono me genera una salida o serie de salidas en el puerto B para hacer que varios leds parpadeen durante cierto tiempo, pero esto es por cada pulso que le doy al botón. Ahora tengo la siguiente duda: ¿Cómo puedo hacer que un led o varios leds parpadeen cada vez que mantenga presionado un botón? es decir, que una vez que suelte el pulsador el led o los leds dejen de parpadear, quisera saber cómo puedo hacer esto. Gracias y sigan compartiendo tan buenos ejemplos.

Título: Re: Ejemplitos en C para 16F648A
Publicado por: camhost1 en 18 de Noviembre de 2013, 19:25:37

Cita de: jhonjz en 11 de Noviembre de 2013, 20:29:32

Hola amig@s. Aprovechando esta serie de ejemplos que han posteado y muy buenos, quisiera generar una duda respecto a hacer que un led parpadee, les comento la siguiente cuestión: he hecho varios ejemplos sobre esto, pero todos han sido de la misma forma, es decir, cuento por ejemplo con un pulsador conectado en RA0 y cuando lo presiono me genera una salida o serie de salidas en el puerto B para hacer que varios leds parpadeen durante cierto tiempo, pero esto es por cada pulso que le doy al botón. Ahora tengo la siguiente duda: ¿Cómo puedo hacer que un led o varios leds parpadeen cada vez que mantenga presionado un botón? es decir, que una vez que suelte el pulsador el led o los leds dejen de parpadear, quisera saber cómo puedo hacer esto. Gracias y sigan compartiendo tan buenos ejemplos.

con instrucciones de control, mientras que el pin x esta en alto, prenda leds, si no apague.

Título: Re: Ejemplitos en C para 16F648A
Publicado por: samayala2011 en 12 de Diciembre de 2013, 19:10:38

amigos por favor necesito de su ayuda, necesito un contador con dos display usando 2 pulsadores uno para que ascienda y el otro para que descienda. inicialmente debe comenzar en el numero 30 y si se presiona un botom debe bajar 1 digito y si se presiona otro botom debe subir un dijito. por favor ayudenme es para un proyecto en automatizacion industrial. con lcd ya lo hice pero el profesor me lo esta pidiendo con 2 display y un pic 16f84a. les agradezco de antemano su ayuda. mi correo ayala-samuel@hotmail.com

Título: Re: Ejemplitos en C para 16F648A
Publicado por: barincho en 30 de Julio de 2014, 18:47:34

buenas tardes, hace tiempo que estoy probando con lenguaje c, siempre saltan dudas o preguntas.
si me permiten les hago una consulta; yo diseñe un pcb en donde la RA4 (pic 16F84A) esta a "1" mediante una resistencia y la envio a cero atravez de un pulsador NA.
hasta ahi todo bien la placa con todos los componentes quedo perfecta. el problema se me genera en el programa, ya que el ccs, me tira errores. me explico en una parte del programa pregunto (if) si A4 es igual a 0, si uso = me tira error, si uso == lo acepta pero al correr el programa aplicando los estimulos (mplab) directamente lo pasa como si nada; quisiera saber como realizar dicha pregunta. que el programa espera hasta que yo pulse el NA para que el pin A4 de 5V pase a 0V, una vez leido el puerto siga con la ejecucion que yo desee
desde ya muchas gracias

Título: Re: Ejemplitos en C para 16F648A
Publicado por: barincho en 30 de Julio de 2014, 18:58:09

Título: problemas con 16f877a
Publicado por: juanfro en 15 de Septiembre de 2014, 19:32:08

tengo un problema con el16f877a, creo que es mi prorama, sucede que cuando lo simulo en proteus me ejecuta todo el programa normal, pero cuando grabo el programa en el pic y lo ejecuto en mi protoboard no sucede nada, ya comprobe el pic y el grabador haciendo otro programita simple y me ejecuta normal en mi protoboard.Les dejo mi programita haber si alguien me ayuda.
*************
el programa consiste en un teclado 3X4, un LCD 2x16, una memoria eeprom y el PIC16F877a
al ingresar una clave de 4 digitos, si es correcta, graba una serie de datos en la eeprom, al ingreso de cada digito te muestra en el display.utilizo la interrupcion de timer para originar un calendario , esto me sirve para que cada vez que ingrese(acceda la clave) se guarde la fecha y hora en la eeprom.

*****************
#include <16F877a.H>
#fuses XT, NOWDT, NOPROTECT, NOLVP
#use delay(clock = 4000000)
#use i2c(master,sda=PIN_C4,scl=PIN_C3)
#define use_portb_kbd TRUE
#define use_portd_lcd true
#include <lcd.c>
#include <kbd.c>
#include <stdlib.h>
#use RS232(BAUD=9600, XMIT=PIN_C6, RCV=PIN_C7, BITS=8)
#rom 0x2100={'0','2','1','8','9','0','0','1','2','0','2','4','1','9','5','0','2','8','4','0','3','7','3','0','4','6','2','0','5','5','1','0'}
int Segundos=0;
int Year=14,Mes=9,Dia=04,Hora=18,Minuto=55;
int yeari,mesi,diai,horai,minutoi,c=0,d=0;
INT8 dato;
#define BISIESTO(year)(year%4 == 0)
#define EEPROM_ADDRESS long int
//timer///
#int_TIMER1
void TIMER1_isr(void)//Función de interrupción por desbordamiento TMR1
{
output_toggle(PIN_A3);
segundos++;
if(Segundos == 60) {Minuto++; Segundos=0;
if(Minuto == 60) {Hora++; Minuto=0;
if(Hora == 24) {Dia++; Hora=0;
if ( (Dia == 29 && Mes==2 && !BISIESTO(Year))
|| (Dia == 30 && Mes==2)
|| (Dia == 31 && (Mes==4 || Mes==6 || Mes==9 || Mes==11 ))
|| (Dia == 32)
) {Mes++;Dia=0;}
if(Mes == 13) {Year++; Mes=0;}
}}}

set_timer1(0x0BDC);//carga del TMR1
}

void write_ext_eeprom(long int address,BYTE data) //Escribir en la eeprom
{
short int status;
i2c_start();
i2c_write(0xA0);
i2c_write(address>>8);
i2c_write(address);
i2c_write(data);
i2c_stop();
i2c_start();
status=i2c_write(0xa0);
while(status==1)
{
i2c_start();
status=i2c_write(0xa0);
}
}
BYTE read_ext_eeprom(long int address)
{
BYTE data;
i2c_start();
i2c_write(0xA);
i2c_write(address>>11);
i2c_write(address);
i2c_start();
i2c_write(0xa1);
data=i2c_read(0);
i2c_stop();
return(data);
}

#int_RDA
void RDA_isr(){
EEPROM_ADDRESS address=0;;
char keypress=' ';
keypress=' ';
if(kbhit()){
Keypress=getc();
switch (keypress){
case 'I':
WRITE_EXT_EEPROM(0,0);
address=0;
DATO=0;
while(DATO<=254){
address++;
DATO=READ_EXT_EEPROM(address);
printf("%u",dato);
}
break;

case 'O':
WRITE_EXT_EEPROM(0,0);
address=0;
lcd_gotoxy(1,1);
printf(lcd_putc,"BORRANDO EEPROM");
lcd_gotoxy(1,2);
printf(lcd_putc,"PLEASE WAIT... ");
puts("BORRANDO EEPROM");
while (d<=128){
d++;
while(c<=254){
WRITE_EXT_EEPROM(address,255);
address++;
c++;
}
c=0;
}
hora = hora+1;
lcd_gotoxy(1,1);
Printf(lcd_putc," ");
lcd_gotoxy(1,2);
Printf(lcd_putc,"INGRESE PASSWORD");
puts("EEPROM BORRADA");
break;
}
}
}
//***** Programa Principal *****//
void main()
{
char k;
int i,a=3;
char data[4],clave[31]; //matrices para guardar clave y datos
lcd_init();
kbd_init();
port_b_pullups(TRUE);
output_low(PIN_A0);
output_low(PIN_A2);//led Verde =off
output_low(PIN_A1);//led rojo=on

inicio: setup_timer_1(T1_INTERNAL|T1_DIV_BY_8);//Setup timer: Reloj interno, preescaler= 8
enable_interrupts(INT_TIMER1);//Habilito interrupción particular del TIMER1
enable_interrupts(GLOBAL);//Habilito interrupciones globales
enable_interrupts(INT_RDA);
set_timer1(0x0BDC);//Carga del TMR1
while(TRUE){

i=0;//posicion de la matriz
lcd_gotoxy(1,2);
Printf(lcd_putc,"INGRESE PASSWORD");//primer dato
while(i<=3)
{ //para cuatro datos
k=kbd_getc();//lee el teclado
if(k!=0)//si se ha pulsado alguna tecla
{
data=k;//se guarda en la posicion correspondiente
i++;

lcd_gotoxy(i+1,1);
printf(lcd_putc,"*");//siguiente dato
output_high(PIN_A0);
delay_ms(50);
Output_low(PIN_A0);
delay_ms(300);
}
}
for(i=0;i<=31;i++)
{
//pasa datos de eeprom a la matriz clave
clave=read_eeprom(i);
}
if((data[0]==clave[0])&&(data[1]==clave[1])&&(data[2]==clave[2])&&(data[3]==clave[3]))//clave 1
{
lcd_gotoxy(1,1);
printf(lcd_putc,"\fBIENVENIDO");//compara los datos con la clave
lcd_gotoxy(1,2);
printf(lcd_putc,"J. PRUDENCIO");

WRITE_EXT_EEPROM(a,101);
a++;
goto activa;
}
if((data[0]==clave[4])&&(data[1]==clave[5])&&(data[2]==clave[6])&&(data[3]==clave[7]))//Clave 2
//compara digito a digito los valores almacenados en la eeprom y la clave introducida
{
lcd_gotoxy(1,1);
printf(lcd_putc,"\fBIENVENIDO");
lcd_gotoxy(1,2);
printf(lcd_putc,"J. FIGUEROA");
WRITE_EXT_EEPROM(a,102);
a++;
goto activa;
}
if((data[0]==clave[8])&&(data[1]==clave[9])&&(data[2]==clave[10])&&(data[3]==clave[11])) // clave 3
{
lcd_gotoxy(1,1);
printf(lcd_putc,"\fBIENVENIDO");//compara los datos con la clave
lcd_gotoxy(1,2);
printf(lcd_putc,"J. TUESTA");
WRITE_EXT_EEPROM(a,103);
a++;
goto activa;
}
if((data[0]==clave[12])&&(data[1]==clave[13])&&(data[2]==clave[14])&&(data[3]==clave[15])) // clave 4
{
lcd_gotoxy(1,1);
printf(lcd_putc,"\fBIENVENIDO");//compara los datos con la clave
lcd_gotoxy(1,2);
printf(lcd_putc,"P. VENTURA");
WRITE_EXT_EEPROM(a,104);
a++;
goto activa;
}
if((data[0]==clave[16])&&(data[1]==clave[17])&&(data[2]==clave[18])&&(data[3]==clave[19])) // clave 5
{
lcd_gotoxy(1,1);
printf(lcd_putc,"\fBIENVENIDO");//compara los datos con la clave
lcd_gotoxy(1,2);
printf(lcd_putc,"R. AYALA");
WRITE_EXT_EEPROM(a,105);
a++;
WRITE_EXT_EEPROM(a,dia);
goto activa;
}
if((data[0]==clave[20])&&(data[1]==clave[21])&&(data[2]==clave[22])&&(data[3]==clave[23])) // clave 6
{
lcd_gotoxy(1,1);
printf(lcd_putc,"\fBIENVENIDO");//compara los datos con la clave
lcd_gotoxy(1,2);
printf(lcd_putc,"R. MOYA");
WRITE_EXT_EEPROM(a,106);
a++;
goto activa;
}
if((data[0]==clave[24])&&(data[1]==clave[25])&&(data[2]==clave[26])&&(data[3]==clave[27])) // clave 7
{
lcd_gotoxy(1,1);
printf(lcd_putc,"\fBIENVENIDO");//compara los datos con la clave
lcd_gotoxy(1,2);
printf(lcd_putc,"H. LEON");
WRITE_EXT_EEPROM(a,107);
a++;
goto activa;
}
if((data[0]==clave[28])&&(data[1]==clave[29])&&(data[2]==clave[30])&&(data[3]==clave[31])) // clave 8
{
lcd_gotoxy(1,1);
printf(lcd_putc,"\fBIENVENIDO");//compara los datos con la clave
lcd_gotoxy(1,2);
printf(lcd_putc,"W. GARCIA");
WRITE_EXT_EEPROM(a,108);
a++;
goto activa;
}
else{
lcd_gotoxy(1,1);
printf(lcd_putc,"\PASSWORD ERROR");//clave erronea
delay_ms(400);
output_low(PIN_A0);
delay_ms(100);
output_high(PIN_A0);
delay_ms(100);
output_low(PIN_A0);
delay_ms(100);
output_high(PIN_A0);
delay_ms(100);
output_low(PIN_A0);
}
lcd_gotoxy(1,1);
delay_ms(100);
printf(lcd_putc," ");
lcd_gotoxy(1,2);
printf(lcd_putc," ");

}
activa:
output_high(PIN_A0);
delay_ms(300);
output_low(PIN_A0);
delay_ms(50);
output_high(PIN_A0);
delay_ms(30);
output_low(PIN_A0);
delay_ms(200);
output_high(PIN_A1);//led rojo Off
output_high(PIN_A2); // led verde =on
delay_ms(2000);
output_low(PIN_A1);//cierra la cerradura con pulso al relé
output_low(PIN_A2);//led verde =off
diai=100 + dia;
WRITE_EXT_EEPROM(a,diai);
mesi = 100 + mes;
a++;
WRITE_EXT_EEPROM(a,mesi);
yeari = 100+year;
a++;
WRITE_EXT_EEPROM(a,yeari);
a++;
horai = 100+hora;
WRITE_EXT_EEPROM(a,horai);
a++;
minutoi=minuto + 100;
WRITE_EXT_EEPROM(a,Minutoi);
a++;
lcd_gotoxy(1,1);
printf(lcd_putc," ");
lcd_gotoxy(1,2);
printf(lcd_putc," ");
goto inicio;
}
*************************************

Título: sobre: el programita de hoy consiste en sacar por pantalla(lcd)
Publicado por: Berto en 14 de Junio de 2015, 12:56:50

Holas. Acabo de empezar a tratar con micros, por aora no e hecho ningun programa propio, me dedico a moldear el codigo ya escrito para ver los efectos y famicializarme con el, me ocurre lo mismo con proteus. No conocco las patillas tanto del 16f648a ni del LCD de buestro ejercicio.
Os agradeceria a cualquiera q me embieis el proyecto que contiene el circuito ya hecho en proteus de este ejercicio.
No se como va esto es el primer mensaje que meto, perdonarme y avisarme si no es necesario dar mi email, este es berto3soydd@hotmail.com.

¿Que significa: No usar smileys?.

Título: Re: Ejemplitos en C para 16F648A
Publicado por: KILLERJC en 14 de Junio de 2015, 16:18:57

Berto, la conexion va a depender exclusivamente del programa. Por que a los LCD 2x16 ( creo que tambien los de 4 lineas, los de 1 lineas seguro ) se pueden conectar con 4 u 8 pines de datos

http://img.webme.com/pic/p/picmind/pic_lcd.jpg
http://www.x-robotics.com/images/lcd4bits.gif

Donde conectas cada pin depende de tu programa. Si usas 8 bits de dato por ahi conviene usar un puerto completo, y si usas 4, medio puerto o el siperior o inferior, por que es mas facil de trabajar asi

Citar

No conocco las patillas tanto del 16f648a ni del LCD de buestro ejercicio.

Para justamente eso estan los datasheet de cada integrado, en google pones "PIC16F684A datasheet" y vas a encontrar un PDF con todo lo que interesa, modulos, pines, configuracion, caracteristicas electricas (maximo y minimos)
http://ww1.microchip.com/downloads/en/DeviceDoc/41202C.pdf

Por su parte.. si queres saber como funciona el LCD y sus pin, tenes que buscar su controladorm de los cuales el mas comun es el hd44780 (solo puse "LCD driver" en google )
Buscando "hd44780 datasheet" encontramos su datasheet. Aqui tenes los pines, tiempos a respetar, y lo que te interesa es la parte de la memorua y conecxionado con el integrado en la pag 32/33 tenes ambos conexionados de 4 y 8 bits
https://www.sparkfun.com/datasheets/LCD/HD44780.pdf

El pin R/W algunos lo usan otros no, eso depende del programa.

Título: Re: Ejemplitos en C para 16F648A
Publicado por: Berto en 15 de Junio de 2015, 17:43:31

Gracias por tu rapida atencion KILLERJC. Le e echado un vistazo a las paginas y busquedas que me as dado. Tu informacion es mui concreta a lo que buscaba. Aunque mui engorrosa devido a que esta en ingles. Malo para mi. El traductor que utilizo comete el (error) de traducirme los pines y no respeta los saltos de linea, pero muchas gracias.

Título: Re: Ejemplitos en C para 16F648A
Publicado por: KILLERJC en 15 de Junio de 2015, 17:58:18

Cita de: Berto en 15 de Junio de 2015, 17:43:31

Gracias por tu rapida atencion KILLERJC. Le e echado un vistazo a las paginas y busquedas que me as dado. Tu informacion es mui concreta a lo que buscaba. Aunque mui engorrosa devido a que esta en ingles. Malo para mi. El traductor que utilizo comete el (error) de traducirme los pines y no respeta los saltos de linea, pero muchas gracias.

El mundo de la electronica esta en ingles (algunos aleman y chino :P, pero mayormente ingles)... Te vas a tener que acostumbrar, ya que como ves traductores suelen cometer errores, aunque vi algunos datasheets en español, especialmente el del PIC16F84A (no tengo links)... Pero aun asi, no podes saber si realmente es lo que decia o no el documento original. Y tomarse el trabajo de traducir 400 hojas es de locos.

Sino podes buscar tutoriales por internet, el tema esta que no hay mejor informacion que la que proveen los fabricantes del IC.

Título: Re: Ejemplitos en C para 16F648A
Publicado por: Berto en 16 de Junio de 2015, 12:18:31

No te creas. En mi caso el problema no va ser demasiado el ingles, mi problema es que hace mucho que no escribo codigo, solo trabaje con un 8085 y ya tengo 40 años. El topico de que para programar hace falta saber ingles y matematicas es una ventaja pero no completamente cierto. Hice programas muy buenos para mi gusto entre 23 y 28 años, lo unico que me hacia falta saber en ingles es el significado de las sentencias y respecto a los calculos un ordenador siempre lo hace mejor que una persona. Lo que tienes que hacer es deducir idear, esto es lo que no sabe hacer el ordenador. A mi edad mi capacidad de idear no va a ser tan agil como cuando era mas joven. Lo cierto es que emvejecer le sienta mal a todo el mundo, incluso a mis actrices favoritas.

Saludos.

Título: Re: Ejemplitos en C para 16F648A
Publicado por: Josh01 en 01 de Julio de 2015, 15:07:20

Buenas Tardes, tengo la duda de si estos programas funcionan para el PIC 18F4550.

Saludos!

Título: Re: Ejemplitos en C para 16F648A
Publicado por: KILLERJC en 01 de Julio de 2015, 17:08:34

Cita de: Josh01 en 01 de Julio de 2015, 15:07:20

Buenas Tardes, tengo la duda de si estos programas funcionan para el PIC 18F4550.
Saludos!

Si va a funcionar con algunos cambios, por ejemplo la parte de la configuracion de los modulos es distinto, y tambien son los fuses.
A no ser que se modifique algun registro en particular y se usen solo las funciones del compilador no deberias tener problemas. Si ya usan algunos registros entonces vas a tener que buscar su "equivalente"

Tenes que recordar ademas que el PIC16F84 es un uC muy basico, no tiene casi nada, y por eso es ideal para aprender sobre los PICs, Los PIC18 ya cambia mucho en como se maneja, como esta distribuida la memoria asi que puede que te encuentres con algunos obstaculos.

Título: Re: Sobre supercontador 0a9999
Publicado por: Berto en 24 de Julio de 2015, 17:42:39

Hola vszener dime ¿que codificador deveria utilizar para un programa como este?

Título: Re: Sobre proyecto mensaje BETI
Publicado por: Berto en 24 de Julio de 2015, 18:05:38

Hola vszener.
No puedo utilizar siempre display de 7 segmentos B podria ser 8 pero nada sustituye a T. Yo probe con un con uno de 14seg para T pero no consegui nada. E vuelto a buscar el dataset pero no consigo una imagen concreta que indique el encendido de sus segmentos desde su pin. ¿Como lo hiciste tu?

Título: Re: Sobre supercontador 0a9999
Publicado por: KILLERJC en 24 de Julio de 2015, 20:45:59

Cita de: Berto en 24 de Julio de 2015, 17:42:39

Hola vszener dime ¿que codificador deveria utilizar para un programa como este?

Cita de: Berto en 24 de Julio de 2015, 18:05:38

Hola vszener.
No puedo utilizar siempre display de 7 segmentos B podria ser 8 pero nada sustituye a T. Yo probe con un con uno de 14seg para T pero no consegui nada. E vuelto a buscar el dataset pero no consigo una imagen concreta que indique el encendido de sus segmentos desde su pin. ¿Como lo hiciste tu?

No soy vzener pero podria responderte, el principal problema es que no se que es B, T ni nada por el estilo. Si puedieras dar una explicacion mejor seria posible ayudarte.

Título: Re: Ejemplitos en C para 16F648A
Publicado por: AleSergi en 24 de Julio de 2015, 20:57:10

poder.. se puede, es cuestión de imaginación, "el elefante, con paciencia y .... ... ... ... ...pobre hormiga! "
En estos casos ya no se puede emplear codificador alguno, va el puerto de 8bits completo, más los del "barrido" (estos si se pueden decodificar y ahorrar pines)

(http://www.twyman.org.uk/Fonts/7%20Seq-3D.jpg)

(http://1.bp.blogspot.com/-dwZu9jlJNYA/UaBMIXf6-EI/AAAAAAAAAcE/Qj_tsGv7uLE/s1600/alfanumericos.png)

Título: Re: Ejemplitos en C para 16F648A
Publicado por: KILLERJC en 24 de Julio de 2015, 21:06:53

xD Cuando decia B o T imagine otra cosa por que habia dicho:

Citar

. Yo probe con un con uno de 14seg para T pero no consegui nada

Y pense que T era un tiempo al igual que B.

PD: para Berto, no salgas de las letras mas comunes, sino te tenes que ir a un LCD, eso presta muchisima confusion, ejemplo X,H,K son todas iguales. la q puede ser malinterpretada como un 9, la V como una U, la Z con un 2, la S con un 5, en fin la persona que lo lea se va a querer matar cuando vea eso y no entienda nada. Los que veo viables sno:

a,b,c,d,e,f,i,j,l,n,o (pero no como 0 ), p, r , t, u, y

Título: Re: Ejemplitos en C para 16F648A
Publicado por: AleSergi en 24 de Julio de 2015, 21:20:01

ggrrrrr.. no me deja pegar un videito que habia subido con uno de esos carteles de fondo, molestando a un amigo motociclista.
el tiempo de barrido era de 3000us.

PD: pobre hormiga :mrgreen:

Título: Re: Sobre B y T
Publicado por: Berto en 25 de Julio de 2015, 10:43:49

Hola KILLERJ (el icono del mensaje deberia ser "confusion) Yo entre en su Tema de ejemplitos para C cada uno de sus ejemplos pinche en citar, dentro de los proyectos de vszener . tu nombre no aparecia por ninguna parte y aun a si los as recibido tu los dos.
Sobre B y T vszener dice utilizar display de 7 segmentos. A mi no me funciono. Ahora que lo vuelbo a mirar utiliza el 6 como b yo no e sabido poner T con uno de 16seg. Me gustaria un dataset grafico. Mas que el codigo.

Tengo problemas a la hora de encontrar el dataset de los componentes. Lo que mas me interesa-gusta los
graficos de estos con la asignacion de sus pines (en estos casos no me importa que esten en ingles). Cuales son
las paginas mas recomendables para ello.

Título: Re: Ejemplitos en C para 16F648A
Publicado por: Berto en 25 de Julio de 2015, 11:08:20

Si te gustan las motos da igual q seas una hormiga o un chimpanze AleSergi. Un dia d lluvia como hoy es mas molesto que tu. (sorry no encuentro el icono adecuado)

Título: Re: Sobre B y T
Publicado por: KILLERJC en 25 de Julio de 2015, 13:21:25

Cita de: Berto en 25 de Julio de 2015, 10:43:49

Hola KILLERJ (el icono del mensaje deberia ser "confusion) Yo entre en su Tema de ejemplitos para C cada uno de sus ejemplos pinche en citar, dentro de los proyectos de vszener . tu nombre no aparecia por ninguna parte y aun a si los as recibido tu los dos.
Sobre B y T vszener dice utilizar display de 7 segmentos. A mi no me funciono. Ahora que lo vuelbo a mirar utiliza el 6 como b yo no e sabido poner T con uno de 16seg. Me gustaria un dataset grafico. Mas que el codigo.

Tengo problemas a la hora de encontrar el dataset de los componentes. Lo que mas me interesa-gusta los
graficos de estos con la asignacion de sus pines (en estos casos no me importa que esten en ingles). Cuales son
las paginas mas recomendables para ello.

Es un foro, el foro esta abierto para todos, el post lo pueden ver todos no solo el autor, distinto es si hubieras mandado un mensaje privado a la persona.
El datasheet normalmente te indica cuales son los segmentos y los pines que corresponde a cada segmento. No necesitas mas que eso, si usas un display de 14 segmentos o 16, vas a necesitar 14 o 16 salidas. Y va a complicar el programa ya que vas a tener que hacer 2 array ( o 1 solo de 16bits ) con los valores de cada letra/numero y manejar al menos 2 puertos de 8 bits cada uno, ya que no podes unir los segmentos. O no "deberias" unirlos.

Con respecto al driver para los displays, podes buscar "driver 14 segment" en google y te van a aparecer algunos integrados para manejarlos, como este:
http://www.maximintegrated.com/en/app-notes/index.mvp/id/3211

Citar

Un dia d lluvia como hoy es mas molesto que tu.

A no ser que tenga buena confianza con otra persona, al menos yo no diria esas palabras. Ya que si no hay confianza se puede mal interpretar y tomarlo como una ofensa.
Pero puede que me este faltando una informacion, y que sean conocidos.

Título: Re: Sobre B y T
Publicado por: Berto en 25 de Julio de 2015, 14:34:22

Gracias KILLERJC Ahora mismo le hecho un vistazo. Entiendo lo que dices pero si yo en un terminal de 16-14segmentos solo me interesa la letra T solo necesito 4 terminales (mas los 2 de alimentacion( 1 en Proteus)) ¿puedo hacer esto. No?.

Respecto a la combersacion inadecuada no se borrarla hacerlo vosotros si os molesta. Me gustan mucho las motos y apenas hay concentraciones diurnas la
relacion amigo-hormiga-motero no es aceptable. No nos conocemos aun a si.

POS Si ahora e observado que en este block es donde empece a escribiros aunque yo pretendia hacerlo con vszener.

Título: Re: Ejemplitos en C para 16F648A
Publicado por: KILLERJC en 26 de Julio de 2015, 03:52:31

Citar

Entiendo lo que dices pero si yo en un terminal de 16-14segmentos solo me interesa la letra T solo necesito 4 terminales (mas los 2 de alimentacion( 1 en Proteus))

Claro, solo necesitarias 4 terminales + 1 comun. Pero eso es para la T, ahora si lo unico que pensas encender ahi es una T podes juntar todos los pines y directamente te quede para manejarlo de 1 pin. Pero no creo que lo uses unicamente para la T, sino que para numeros tal ves, si necesitas hacer los numeros vas a tener que que manejar los demas segmentos. Podrias tambien para simplificar unir los 2 leds vertical centrales y los 2 horizontal central, de esa forma te lleva 1 solo pin para encenderlos, pero todo eso te limita en lo que podes representar.

Ejemplo, queres representar de 0 a 9 y la T, unicamente, entonces tenes los 7 pines ( como si fuera un 7 segmento, hay que unir los del centro horizontal ) y ademas unis los pines vertical del centro.
Eso te ocuparia 8 bits ( 8 pines ) y podrias representar los numeros Y la T. Pero si queres hacer otra cosa tal ves no puedas y requieras de otro pin adicional.

Título: Re: Ejemplitos en C para 16F648A
Publicado por: Berto en 26 de Julio de 2015, 08:55:32

Buena idea. No se me habia ocurrido, pero ahora no estoy tratando con displays tengo un problema con Proteus mallor que con mi propio programa en si.
Lo dejare en CODIGO FUENTE Paso a Paso con Proteus, parece mas apropiado.

Título: Re:Ejemplitos en C para 16F648A
Publicado por: malelemto en 14 de Diciembre de 2015, 01:56:34

Hola amigo estoy tratando de armar tu circuito pero nose k tipos de display usaste ánodo común y como lo conectas si pudieras subir el proteus mil gracias saludos

Título: Re:Ejemplitos en C para 16F648A
Publicado por: KILLERJC en 14 de Diciembre de 2015, 05:31:24

Cita de: malelemto en 14 de Diciembre de 2015, 01:56:34

Hola amigo estoy tratando de armar tu circuito pero nose k tipos de display usaste ánodo común y como lo conectas si pudieras subir el proteus mil gracias saludos

Si pudieras dar el link a que circuito te estas refiriendo seria mas util, el hilo posee varios codigos de ejemplos

Título: Re:Ejemplitos en C para 16F648A
Publicado por: coronado88 en 31 de Diciembre de 2015, 16:43:13

buenas amigo tienen ya un foro abierto donde explica como crear funciones y como llamarlas

Título: Re:Ejemplitos en C para 16F648A
Publicado por: nuevo mundo en 01 de Marzo de 2016, 16:17:51

hola compañeros del foro me gustaria empesar un tema que nos puede ayudar a todos en nuestras casas veo que exite mucho talento en todo esto de los pic y por lo tanto me gustaria lebantar la mano para empezar a realizar una buen alarma con pic para el hogar la verdad en mi colonia estan los robos a todo lo que da an robado a mis dos besinos y nesesito instalar una para auyentar alos ladrones

Título: Re:RE: Ejemplitos en C para 16F648A
Publicado por: Tavo en 18 de Abril de 2017, 14:22:00

Cita de: vszener en 20 de Septiembre de 2005, 11:04:00

Desde este enlace os podeis descargar los ficheros del programa anterior: LCD & KEYPAD 3x4

Suerte!!! :wink:

Hola, necesito manejar un display 16x2 y un teclado 4x4 con un 16F876A.
Todos los ejemplos que encontré, como este, usan más de un port para poder manejar ambas cosas.
Como estoy muy justo con los pines del 16F876A, necesito poder controlar el lcd y el teclado con el port B como se puede ver en la imagen adjunta.
En la imagen se ve un teclado 3x4 porque no encuentro la librería para manejar uno 4x4.
Alguien me podrá dar una mano ?

Gracias desde ya.

Título: Re:Ejemplitos en C para 16F648A
Publicado por: KILLERJC en 18 de Abril de 2017, 17:01:44

Necesitas alguna otra cosa para poder expandir los puertos, no podes conectarlo de la forma que queres. No para un keypad 4x4, el 3x4 si porque te deja libre 1 pin que es el E del LCD.

O buscas como multiplexarlo de otra forma o invertis en un nuevo micro con mas pines y te solucionas la vida.

Título: Re:RE: Ejemplitos en C para 16F648A
Publicado por: je_electronic en 14 de Junio de 2017, 00:39:42

Hola buenas noches, requiero una ayuda sobre este tema de contador de 7 segmentos, estoy usando un pic18f4550 que realiza la cuenta del 0 al F con un display , pero como puedo hacer para que active un pin RC0 para el digito 0; Rc1 para el digito 1 asi hasta completar hasta el F, me seria de mucha ayuda, gracias

#INCLUDE <18F4550.H>

//#fuses NOMCLR,XTPLL,NOWDT,NOPROTECT,NOLVP,NODEBUG,USBDIV,PLL1,CPUDIV1,VREGEN,NOPBADEN
#fuses XT // XTPLL: Vamos a usar un cristal de 4.00Mhz.
#fuses CPUDIV1//USADO PARA 4MHZ, NO DIVIDE LA FRECUENCIA
#FUSES NOMCLR // NOMCLR: No vamos ha usar el PIN MCLR, el reset se hará por soft.
#FUSES PUT//ACTIVACACION DE BAJO VOLTAJE
#fuses NOWDT//No vamos a usar el perro guardian.
#fuses NOPROTECT //Memoria no protejida contra lecturas.
#fuses NOVREGEN // Habilita el regulador de 3.3 volts que usa el módulo USB, no lo usaremos por los momentos, se cambiará por NOVREGEN
#USE DELAY (CLOCK= 20000000)

int8 unid[11]={0x3f,0x6,0x5b,0x4f,0x66,0x6d,0x7d,0x7,0x7f,0x6f,0x77,0x39};
int i;

void main()
{
set_tris_b(0b00000000);
output_b(0b00000000);

while(true)
{
for(i=0;i<11;i++)
{
output_b(unid);
delay_ms(210);
output_b(0b00000000);
delay_ms(210);

}
}
}