Autor Tema: ¿Ejemplo funcional para pic 18F452?  (Leído 4275 veces)

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

Desconectado lesen

  • PIC10
  • *
  • Mensajes: 7
¿Ejemplo funcional para pic 18F452?
« en: 10 de Enero de 2005, 16:05:00 »
Hola a todos,

Estoy usando el CSS pwc 3.212 y varios de los ejemplos que lleva incorporados para intentar mostrar mensajes en un LCD powertip 1602 F de 2x16 carácteres. Únicamente tengo conectados al pic un pulsador para el reset, la alimentación y el LCD según el pinout indicado en el driver lcd.c del própio CSS. El resto de pines del pic esta sin conectar.  El lcd se empeña en no mostrar ningun carácter tras compilar y cargar el programa.

¿Dispone alguien de ustedes de un ejemplo probado sobre un 18F452 que muestre carácteres por un lcd 2x16?

Saludos  

Desconectado Lager.

  • Moderadores
  • PIC18
  • *****
  • Mensajes: 477
RE: ¿Ejemplo funcional para pic 18F452?
« Respuesta #1 en: 10 de Enero de 2005, 22:24:00 »
Que onda pana lessen, date una vuelta por este post:
http://miarroba.com/foros/ver.php?foroid=46840&temaid=3122729

Reviza los ejemplos del maletin del pana Modulay. En este mismo post puse un ejemplo funcional para lcd y el modelo que buscas. Si simulas, asegurate de aumentar la frecuencia del reloj interno del lcd por ejemplo a 650khz.... para que lo veas en simulacion. Si quieres todo completo deja y le pregunto al pana Modulay si aun tiene espacio en su sitio web para subir el archivo completo con codigo y diseño en proteus.

Salu2

Desconectado JorgitoFRyOle

  • PIC12
  • **
  • Mensajes: 79
RE: ¿Ejemplo funcional para pic 18F452?
« Respuesta #2 en: 11 de Enero de 2005, 09:37:00 »
Buenas

Yo utilizo el mismo pic. El codigo de mi libreria (construido por mi) es el siguiente: lcd.h

No he sido capaz de subirlo, (Angelitoaprovecho de paso para ver si alguien me envia una pequeña explicacion para aprender a subir archivos porque siempre me da errorRebotado), te lo mando aki y lo copias.

/******************************************************/
//         DEFINICION DE CONSTANTES                   //
//                                                    //
// LISTA DE COMANDOS DE LA PANTALLA LCD               //
//                                                    //
// Borra pantalla y coloca cursor posicion1 linea1    //
#define LCD_BORRAR 0x01                               //
// Coloca cursor posicion1 linea1                     //
#define LCD_PRINCIPIO 0x02                            //
// Establece la direccion del movimiento del cursor   //
// (I/D) y desplaza la visualizacion cada vez q se    //
// escribe un dato(S)                                 //
// Si I/D = 0 y S = 0                                 //
#define LCD_DECREM_NO_DESPLAZ 0x04                    //
// Si I/D = 0 y S = 1                                 //
#define LCD_DECREM_DESPLAZ 0x05                       //
// Si I/D = 1 y S = 0                                 //
#define LCD_INCREM_NO_DESPLAZ 0x06                    //
// Si I/D = 1 y S = 0                                 //
#define LCD_INCREM_DESPLAZ 0x07                       //
// Activa la pantalla(D = 1)                          //
#define LCD_ENCENDER_DISPLAY 0x0C                     //
// Desactiva la pantalla(D = 0)                       //
#define LCD_APAGAR_DISPLAY 0x08                       //
// Activa el cursor(C = 1) -> D = 1                   //
#define LCD_ENCENDER_CURSOR 0x0E                      //
// Desactiva el cursor(C = 0) -> D = 1                //
#define LCD_APAGAR_CURSOR 0x0C                        //
// Cursor en parpadeo(B = 1) -> C = 1 y D = 1         //
#define LCD_CURSOR_PARPADEO 0x0F                      //
// Cursor no parpadeo(B = 0) -> C = 1 y D = 1         //
#define LCD_CURSOR_NO_PARPADEO 0x0E                   //
// Mueve el cursor a la izquierda sin desplazar       //
// visualizacion                                      //
#define LCD_CURSOR_IZQ_NO_DESPLAZ 0x10                //
// Mueve el cursor a la izquierda y desplaza          //
// visualizacion                                      //
#define LCD_CURSOR_IZQ_DESPLAZ 0x18                   //
// Mueve el cursor a la derecha sin desplazar         //
// visualizacion                                      //
#define LCD_CURSOR_DCHA_NO_DESPLAZ 0x14               //
// Mueve el cursor a la derecha y desplaza            //
// visualizacion                                      //
#define LCD_CURSOR_DCHA_DESPLAZ 0x1C                  //
// Establece interfaz 8bits(DL = 1), 2 lineas(N = 1), //
// 5x7 pixels(F = 0)                                  //
#define LCD_CONFIGURAC 0x38                           //
// Generador caracteres usuario RAM                   //
#define LCD_CGRAM 0x40                                //
// Establece la direccion de la DDRAM                 //
#define LCD_DDRAM 0x80                                //
//                                                    //
// DIRECCIONES DE MEMORIA DE LINEAS                   //
//                                                    //
// Coloca cursor posicion1 linea1                     //
#define LCD_LINEA1 0x00                               //
// Coloca cursor posicion1 linea2                     //
#define LCD_LINEA2 0x40                               //
//                                                    //
// DEFINICION DE LINEAS DE CONTROL DE LA PANTALLA LCD //
//                                                    //
// Seleccion de modo (comandos o caracteres)          //
// 1-> Caracteres                                     //
// 0-> Comandos                                       //
#define LCD_RS PIN_E0                                 //
// Escritura o lectura                                //
// 1-> Lectura                                        //
// 0-> Escritura                                      //
#define LCD_RW PIN_E1                                 //
// Habilita o deshabiliata                            //
// 1-> Habilita LCD                                   //
// 0-> Deshabilita LCD                                //
#define LCD_EN PIN_E2                                 //
//                                                    //
// DEFINICION DE LINEAS DE DATOS DE LA PANTALLA LCD   //
#define LCD_DATOS PORTD //IMPORTANTE                  //
//                                                    //
// SELECCION DE MODO(INDICA SI ES DATO O COMANDO)     //
#define LCD_COMANDO 0                                 //
#define LCD_CARACTER 1                                //
//                                                    //
// CONSTANTES DEBIDO A CODIGO                         //
#define MAX_ESPERA 250                                //
#define CERO_ASCII 0x30                               //
#define MAX_TEXTO 16                                  //
//                                                    //
/******************************************************/
//          DEFINICION DE TIPOS                       //
//                                                    //
typedef char cadena[MAX_TEXTO];                       //
//                                                    //
/******************************************************/
//          DEFINICION DE VARIABLES                   //
//                                                    //
int lcd_cont;  //indica la posicion dentro del numero //
int cont_ocupado; //contador para evitar que se quede //
//                 colgado en la espera               //
/******************************************************/
//          FUNCIONES DE CONTROL                      //
//                                                    //
#inline                                               //
//----------------------------------------------------//
//                                                    //
// Indica si el controlador del LCD esta ocupado o no //
short LCD_ocupado()                                   //
{                                                     //
   int valor;                                         //
                                                      //
   cont_ocupado++;                                    //
                                                      //
   set_tris_d(0xFF);                                  //
   output_low(LCD_RS);                                //
   output_high(LCD_RW);                               //
   output_high(LCD_EN);                               //
   delay_cycles(1);                                   //
   valor = bit_test(LCD_DATOS,7);                     //
   output_low(LCD_EN);                                //
   delay_cycles(1);                                   //
                                                      //
   return(valor);                                     //
}                                                     //
//                                                    //
//----------------------------------------------------//
//                                                    //
// Controla la espera mientras el LCD esta ocupado    //
void LCD_espera()                                     //
{                                                     //
   cont_ocupado = 0;                                  //
                                                      //
   do                                                 //
   {                                                  //
      cont_ocupado++;                                 //
   }                                                  //
   while ((LCD_ocupado())&(cont_ocupado<MAX_ESPERA)); //
}                                                     //
//                                                    //
//----------------------------------------------------//
//                                                    //
// Envia un dato o un comando al controlador del LCD  //
//  modo: indica si es un dato o un comando           //
//  valor: dato o comando a enviar                    //
void LCD_enviar(BOOLEAN modo, BYTE valor)             //
{                                                     //
   LCD_espera();                                      //
   set_tris_d(0x00); //ponemos el puertoD como salida //
                     //      IMPORTANTISIMO AKI       //
   if (modo)                                          //
      output_high(LCD_RS);                            //
   else                                               //
      output_low(LCD_RS);                             //
   delay_cycles(1);                                   //
                                                      //
   output_low(LCD_RW); //ponemos en modo escritura    //
   LCD_DATOS = valor;                                 //
   output_high(LCD_EN);                               //
   delay_cycles(1);                                   //
   output_low(LCD_EN);                                //
   delay_cycles(1);                                   //
}                                                     //
//                                                    //
//----------------------------------------------------//
//                                                    //
// Muestra una cadena de caracteres en el LCD         //
//  valor: cadena de caracteres a mostrar             //
void LCD_texto(char *valor)                           //
{                                                     //
   int i = 0;                                         //
                                                      //
   while (valor != 0)                              //
   {                                                  //
      LCD_enviar(LCD_CARACTER,valor);              //
      i++;                                            //
   }                                                  //
}                                                     //
//                                                    //
//----------------------------------------------------//
//                                                    //
// Muestra un numero entero en el LCD                 //
//  valor: valor del numero a mostrar                 //
void LCD_entero(int valor)                            //
{                                                     //
   long aux;                                          //
   int lcd_string[6];   //6=maximo num de digitos de  //
                        // entero                     //
                                                      //
   aux = valor; //para guardar la variable valor      //
   lcd_cont = 0;                                      //
                                                      //
   if (valor == 0)                                    //
   {                                                  //
      lcd_string[0] = CERO_ASCII;   //equivale al sim-//
                           // bolo 0 en codigo ascii  //
      lcd_cont = 1;                                   //
   }                                                  //
   else                                               //
   {                                                  //
      while (valor > 0)                               //
      {                                               //
         lcd_string[lcd_cont]=CERO_ASCII+(valor % 10);//
         // al sumarle CERO_ASCII (0x30) al valor que //
         // resulta de resto al dividir el valor por  //
         // 10 se corresponde con el simbolo de valor //
         // igual a resto en codigo ascii             //
         valor = valor / 10;  //nos quedamos con el   //
                              //cociente              //
         lcd_cont++;                                  //
      }                                               //
   }                                                  //
                                                      //
   for( ; lcd_cont > 0; lcd_cont--)                   //
      LCD_enviar(LCD_CARACTER,lcd_string[lcd_cont-1]);//
                                                      //
}                                                     //
//                                                    //
//----------------------------------------------------//
//                                                    //
// Coloca el cursor en las coordenadas deseadas       //
//  x = columna (1-16)                                //
//  y = columna (1-2)                                 //
void LCD_posicion(int x, int y)                       //
{                                                     //
   int direccion;                                     //
                                                      //
   if (y != 1)    //segun el valor de y coloca la     //
                  // correspondiente direccion        //
      direccion = LCD_LINEA2;                         //
   else                                               //
      direccion = LCD_LINEA1;                         //
   direccion = direccion + (x-1); //xq pos(1,1) se    //
      // corresponde con la direccion 00 y la pos(7,1)//
      // se corresponde con la direccion 06           //
   LCD_enviar(LCD_COMANDO,LCD_DDRAM | direccion);     //
      // direccion los ultimos 7bits                  //
}                                                     //
//                                                    //
//----------------------------------------------------//
//                                                    //
// Inicializar los puertos A y B y los bits de control//
void LCD_preparar()                                   //
{                                                     //
   set_tris_e(0xF8); // pone los 3bits de control como//
                     // salidas                       //
   set_tris_d(0x00); // pone el puertoB como salida   //
                                                      //
   output_low(LCD_EN); // inicializa a 0 los bits de  //
                       // control                     //
   output_low(LCD_RW);                                //
   output_low(LCD_RS);                                //
   delay_ms(20);                                      //
}                                                     //
//                                                    //
//----------------------------------------------------//
//                                                    //
// Borra la pantalla del LCD                          //
void LCD_borrar()                                     //
{                                                     //
   LCD_enviar(LCD_COMANDO,LCD_BORRAR);                //
}                                                     //
//                                                    //
//----------------------------------------------------//
//                                                    //
// Enciende el LCD                                    //
void LCD_encender_display()                           //
{                                                     //
   LCD_enviar(LCD_COMANDO,LCD_ENCENDER_DISPLAY);      //
}                                                     //
//                                                    //
//----------------------------------------------------//
//                                                    //
// Apaga el LCD                                       //
void LCD_apagar_display()                             //
{                                                     //
   LCD_enviar(LCD_COMANDO,LCD_APAGAR_DISPLAY);        //
}                                                     //
//                                                    //
//----------------------------------------------------//
//                                                    //
//Iniciar el lcd con las caracteristicas propias del  //
// modelo y en la funcion deseada                     //
void LCD_inicio()                                     //
{                                                     //
   int i;                                             //
                                                      //
   LCD_preparar();                                    //
                                                      //
   for(i=0; i<3; i++)                                 //
   {                                                  //
      LCD_enviar(LCD_COMANDO,LCD_CONFIGURAC);         //
      delay_ms(5);                                    //
   }                                                  //
   LCD_encender_display();                            //
   LCD_borrar();                                      //
   LCD_enviar(LCD_COMANDO,LCD_INCREM_NO_DESPLAZ);     //
}                                                     //
//                                                    //
//----------------------------------------------------//

Si prefieres que te envie el archivo, dame tu email

Creo que es entendible, si tienes alguna duda ya sabes a traves de donde puedes localizarme

Suerte, 1saludo

Desconectado lesen

  • PIC10
  • *
  • Mensajes: 7
RE: ¿Ejemplo funcional para pic 18F452?
« Respuesta #3 en: 20 de Enero de 2005, 04:48:00 »
Gracias jorgito por tu ayuda,

Al fin conseguí que funcionase con los drivers lcd.c del propio CSS. Me copio tu libreria para probar.

Saludos

Desconectado pocher

  • Moderador Local
  • DsPIC30
  • *****
  • Mensajes: 2568
RE: ¿Ejemplo funcional para pic 18F452?
« Respuesta #4 en: 20 de Enero de 2005, 05:58:00 »
jorgito los de mi@ hace tiempo que bloquearon la subida de archivos, incluso si mandas un archivo por un privado, el receptor lee que el mensaje recibido tiene archivo pero el archivo no está por ningún sitio.

Un saludo

Desconectado zerovlc

  • PIC10
  • *
  • Mensajes: 28
Re: ¿Ejemplo funcional para pic 18F452?
« Respuesta #5 en: 24 de Junio de 2009, 09:25:36 »
hola buenas, yo tb tengo ese mismo display y con la libreria que viene en css no he podido hacerlo funcionar modifique los tiempos de retardos, utilizo otro pic pero uso el puerto b y 4 bits he probado incluso hacer mi programa en asm y sigue sin funcionar solo me aparece la primera linea en negro que modificaciones habeis hecho para que funcione la libreria???


 

anything