Autor Tema: Ejemplitos en C para 16F648A  (Leído 736308 veces)

0 Usuarios y 1 Visitante están viendo este tema.

Desconectado vszener

  • Moderador Local
  • PIC24H
  • *****
  • Mensajes: 2395
RE: Ejemplitos en C para 16F648A
« Respuesta #75 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:
« Última modificación: 25 de Mayo de 2006, 10:45:00 por vszener »
· Nos vemos en los bares!!!!!
· Mi Blog: Aqueronte

Desconectado vszener

  • Moderador Local
  • PIC24H
  • *****
  • Mensajes: 2395
RE: Ejemplitos en C para 16F648A
« Respuesta #76 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
· Nos vemos en los bares!!!!!
· Mi Blog: Aqueronte

Desconectado vszener

  • Moderador Local
  • PIC24H
  • *****
  • Mensajes: 2395
RE: Ejemplitos en C para 16F648A
« Respuesta #77 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:
« Última modificación: 25 de Mayo de 2006, 10:46:17 por vszener »
· Nos vemos en los bares!!!!!
· Mi Blog: Aqueronte

Desconectado vszener

  • Moderador Local
  • PIC24H
  • *****
  • Mensajes: 2395
RE: Ejemplitos en C para 16F648A
« Respuesta #78 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
· Nos vemos en los bares!!!!!
· Mi Blog: Aqueronte

Desconectado vszener

  • Moderador Local
  • PIC24H
  • *****
  • Mensajes: 2395
RE: Ejemplitos en C para 16F648A
« Respuesta #79 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:
« Última modificación: 25 de Mayo de 2006, 10:47:22 por vszener »
· Nos vemos en los bares!!!!!
· Mi Blog: Aqueronte

Desconectado pocher

  • Moderador Local
  • DsPIC30
  • *****
  • Mensajes: 2569
RE: Ejemplitos en C para 16F648A
« Respuesta #80 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(;Giño{                  //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(;Giño{                  //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

Desconectado vszener

  • Moderador Local
  • PIC24H
  • *****
  • Mensajes: 2395
RE: Ejemplitos en C para 16F648A
« Respuesta #81 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
· Nos vemos en los bares!!!!!
· Mi Blog: Aqueronte

Desconectado vszener

  • Moderador Local
  • PIC24H
  • *****
  • Mensajes: 2395
RE: Ejemplitos en C para 16F648A
« Respuesta #82 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.....
· Nos vemos en los bares!!!!!
· Mi Blog: Aqueronte

Desconectado vszener

  • Moderador Local
  • PIC24H
  • *****
  • Mensajes: 2395
RE: Ejemplitos en C para 16F648A
« Respuesta #83 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:
« Última modificación: 25 de Mayo de 2006, 10:48:21 por vszener »
· Nos vemos en los bares!!!!!
· Mi Blog: Aqueronte

Desconectado vszener

  • Moderador Local
  • PIC24H
  • *****
  • Mensajes: 2395
RE: Ejemplitos en C para 16F648A
« Respuesta #84 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
· Nos vemos en los bares!!!!!
· Mi Blog: Aqueronte

Desconectado vszener

  • Moderador Local
  • PIC24H
  • *****
  • Mensajes: 2395
RE: Ejemplitos en C para 16F648A
« Respuesta #85 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:
« Última modificación: 25 de Mayo de 2006, 10:49:06 por vszener »
· Nos vemos en los bares!!!!!
· Mi Blog: Aqueronte

Desconectado RaDoN

  • Moderadores
  • PIC24H
  • *****
  • Mensajes: 1498
RE: Ejemplitos en C para 16F648A
« Respuesta #86 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
Si juegas contra el mejor, pierdes como los demás.

Desconectado nordestenica

  • PIC16
  • ***
  • Mensajes: 215
RE: Ejemplitos en C para 16F648A
« Respuesta #87 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

Desconectado vszener

  • Moderador Local
  • PIC24H
  • *****
  • Mensajes: 2395
RE: Ejemplitos en C para 16F648A
« Respuesta #88 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
· Nos vemos en los bares!!!!!
· Mi Blog: Aqueronte

Desconectado MGLSOFT

  • Moderadores
  • DsPIC33
  • *****
  • Mensajes: 7918
RE: Ejemplitos en C para 16F648A
« Respuesta #89 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 GiganteSonrisa GiganteSonrisa Gigante
Todos los dias aprendo algo nuevo, el ultimo día de mi vida aprenderé a morir....
Mi Abuelo.


 

anything