Autor Tema: Pantalla LCD 16x2 no muestra nada en PIC16F876  (Leído 4300 veces)

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

Desconectado fabianbambam

  • PIC10
  • *
  • Mensajes: 15
Pantalla LCD 16x2 no muestra nada en PIC16F876
« en: 15 de Junio de 2016, 13:06:26 »
Buenas compañeros, soy nuevo en el foro y espero me disculpen si llego a usar mal las normas que se manejen.

Estoy utilizando un PIC16F876-20/SP y ya tengo el programa hecho, en proteus arranca perfectamente pero al montarlo en
la tabla de prueba/protoboard no me muestra nada, solo los cuadros NEGROS en la linea superior, sé que esto significa que la pantalla está en buenas condiciones pero sin embargo no entiendo porque no está enseñando nada. No sé si el problema está en la conexion del PIC o a nivel del código por la Libreria lcd.c :5]

Adjuntare el codigo, trabajo 5 entradas ADC para medir VOLTAJE, CORRIENTE y ESTADO DE BATERIA y no las he montado todavia por cuestiones de seguridad para con el PIC y evitar problemas mayores.

He hecho las conexiones de acuerdo a lo que he visto en internet, sin embargo trabajo con un controlador HD44780a00 y
La identifacion es simple y creo que es asi:
1. VSS(GND) 2. VDD
3. VO(GND)   4. RS
5. RW(GND)  6. E
7. D0             8. D1
9. D2           10. D3
11. D4         12. D5
13. D6         14. D7


Código: [Seleccionar]
#include <16f876.h>
#device adc=10
#fuses hs,nowdt,noprotect,put,brownout,nolvp,nocpd,nowrt
#use delay(clock=20M)
#define lcd_rs_pin pin_b0
#define lcd_rw_pin pin_b1
#define lcd_enable_pin pin_b2
#define lcd_data4 pin_b4
#define lcd_data5 pin_b5
#define lcd_data6 pin_b6
#define lcd_data7 pin_b7
#include <lcd.c>


void main()
{
   int16 adcv1;
   float v1;
   int16 adcv2;
   float v2;
   int16 adcc1;
   float c1;
   int16 adcc2;
   float c2;
   int16 adcc3;
   float c3;
   setup_adc_ports(ALL_ANALOG);
   setup_adc(adc_clock_internal);
   lcd_init();
   while(true)
   {  lcd_init();
      set_adc_channel(0);
      delay_us(20);
      lcd_gotoxy(1,1);
      adcv1=read_adc();
      v1=adcv1*4.89*0.06*0.1;
      delay_us(50);
      // tiempo de esperar para cambiar de canal
      set_adc_channel(1);
      delay_us(50);
      adcv2=read_adc();
      v2=adcv2*4.89*0.06*0.1;
      delay_us(50);
     
      start:
      // tiempo de espera para cambiar canal
      set_adc_channel(2);
      delay_us(50);
      adcc1=read_adc();
      c1=(adcc1*4.89*0.01164)/5.49;
      delay_us(50);
      if(c1<=3.9)
 {
            printf(lcd_putc,"%1.1fV %1.1fA BAT",v1,c1);
         }
         else
            printf(lcd_putc,"%1.1fV OVER BAT",v1);
     
      // tiempo de espera para cambiar canal
      set_adc_channel(3);
      delay_us(50);
      adcc2=read_adc();
      c2=(adcc2*4.89*0.01164)/5.49;
      delay_us(50);
      // Tiempo de espera para cambiar canal de lectura adc
      set_adc_channel(4);
      delay_us(50);
      adcc3=read_adc();
      c3=adcc3;
      if (c2<=2.9)
      {
      printf(lcd_putc,"\n%1.1fV %1.1fA",v2,c2);
      }
      else
      {
      printf(lcd_putc,"\n%1.1fV OVER",v2);
      output_high(pin_c0);
      delay_ms(100);
      }
      if (c3<=371 && c3<=380)
      {
      lcd_gotoxy(12,2);
      lcd_putc("0%");
      }
      else if (c3>=381 && c3<=389)
      {
      lcd_gotoxy(12,2);
      lcd_putc("25%");
      }
         else if(c3>=390 && c3<=398)
         {
         lcd_gotoxy(12,2);
         lcd_putc("50%");
         }
            else if(c3>=399 && c3<=408)
            {
            lcd_gotoxy(12,2);
            lcd_putc("75%");
            }
               else if(c3>=409)
               {
               lcd_gotoxy(12,2);
               lcd_putc("100%");
               }
   }
}

Desconectado luismh

  • PIC16
  • ***
  • Mensajes: 149
Re:Pantalla LCD 16x2 no muestra nada en PIC16F876
« Respuesta #1 en: 15 de Junio de 2016, 14:07:23 »
Ese problema suele ser por una mala inicialización del LCD

Desconectado fabianbambam

  • PIC10
  • *
  • Mensajes: 15
Re:Pantalla LCD 16x2 no muestra nada en PIC16F876
« Respuesta #2 en: 15 de Junio de 2016, 14:17:15 »
Hice el código utilizando el CCS Compiler y utilice el comando lcd_init(); dentro del void main() y también dentro de la funcion while(true) será ese el problema?

Desconectado luismh

  • PIC16
  • ***
  • Mensajes: 149
Re:Pantalla LCD 16x2 no muestra nada en PIC16F876
« Respuesta #3 en: 15 de Junio de 2016, 15:41:55 »
Sacá la función lcd_init() fuera del while(true). La inicialización solo debe realizarse una vez.

Desconectado AcoranTf

  • Colaborador
  • PIC24H
  • *****
  • Mensajes: 1093
Re:Pantalla LCD 16x2 no muestra nada en PIC16F876
« Respuesta #4 en: 15 de Junio de 2016, 17:22:57 »
Una pregunta, por curiosidad ¿donde esta definida la funcion <lcd_init()>?

Saludos.
« Última modificación: 15 de Junio de 2016, 18:07:52 por AcoranTf »

Desconectado fabianbambam

  • PIC10
  • *
  • Mensajes: 15
Re:Pantalla LCD 16x2 no muestra nada en PIC16F876
« Respuesta #5 en: 16 de Junio de 2016, 12:06:46 »
Les comento que probé quitando la función lcd_init() quitando del void main(), luego quitandola del while (true) sin exito y cambie del puerto B al puerto C y nada, tal vez esté conectando mal el lcd(?)
así conecto cada pata:

1. GND
2. VCC
3. VO - GND
4. RS - C0
5. R/W - GND
6. E - C2
11. DB4 - C3
12. DB5 - C4
13. DB6 - C5
14. DB7 - C6

Cabe destacar que estoy trabajando con el modo a 4 bits.

Desconectado fabianbambam

  • PIC10
  • *
  • Mensajes: 15
Re:Pantalla LCD 16x2 no muestra nada en PIC16F876
« Respuesta #6 en: 16 de Junio de 2016, 12:12:02 »
Código: [Seleccionar]
   setup_adc(adc_clock_internal);
   lcd_init();
   while(true)
   {  lcd_init();
      set_adc_channel(0);
      delay_us(20);

En la zona del while(true) es donde declare la funcion lcd_init() dos veces.

Antes la habia declarado solo en el void main() pero en la simulacion la LCD sólo escribia y no borraba de acuerdo a los cambios en la lecutra ADC, luego la escribí dentro del while(true) y efectivamente funcionó en la simulación  pero ahora se está presentando este problema que no se ve en el físico, espero sea algo del programa como libreria o algun defecto que tenga en el codigo a la hora de inicializar, tal vez aplicar retardos pero no lo se :(


Desconectado luismh

  • PIC16
  • ***
  • Mensajes: 149
Re:Pantalla LCD 16x2 no muestra nada en PIC16F876
« Respuesta #7 en: 16 de Junio de 2016, 12:27:28 »
El LCD se inicializa solo una vez, por lo que la función lcd_init(); no debe ir en el lazo infinito..

No te fies 100% de la simulación, lo mejor es probar en un circuito real.. La naturaleza tiene esa mala costumbre de tener en cuenta todo lo que el simulador no puede.

Podrías postear el código de la función lcd_init()? Tal vez ahí podemos detectar algún problema

Desconectado fabianbambam

  • PIC10
  • *
  • Mensajes: 15
Re:Pantalla LCD 16x2 no muestra nada en PIC16F876
« Respuesta #8 en: 16 de Junio de 2016, 13:08:33 »
Adjunto el codigo y tambien fotos sobre la LCD con la que estoy trabajando, me basé en la identificacion de pines que consegui en internet y tambien en que los pines traen la numeracion de inicio y el final.
Código: [Seleccionar]
///////////////////////////////////////////////////////////////////////////////
////                             LCD.C                                     ////
////                 Driver for common LCD modules                         ////
////                                                                       ////
////  lcd_init()   Must be called before any other function.               ////
////                                                                       ////
////  lcd_putc(c)  Will display c on the next position of the LCD.         ////
////                 \a  Set cursor position to upper left                 ////
////                 \f  Clear display, set cursor to upper left           ////
////                 \n  Go to start of second line                        ////
////                 \b  Move back one position                            ////
////              If LCD_EXTENDED_NEWLINE is defined, the \n character     ////
////              will erase all remanining characters on the current      ////
////              line, and move the cursor to the beginning of the next   ////
////              line.                                                    ////
////              If LCD_EXTENDED_NEWLINE is defined, the \r character     ////
////              will move the cursor to the start of the current         ////
////              line.                                                    ////
////                                                                       ////
////  lcd_gotoxy(x,y) Set write position on LCD (upper left is 1,1)        ////
////                                                                       ////
////  lcd_getc(x,y)   Returns character at position x,y on LCD             ////
////                                                                       ////
////  lcd_cursor_on(int1 on)   Turn the cursor on (on=TRUE) or off         ////
////              (on=FALSE).                                              ////
////                                                                       ////
////  lcd_set_cgram_char(w, *p)   Write a custom character to the CGRAM.   ////
////                                                                       ////
////                                                                       ////
////  CONFIGURATION                                                        ////
////  The LCD can be configured in one of two ways: a.) port access or     ////
////  b.) pin access.  Port access requires the entire 7 bit interface     ////
////  connected to one GPIO port, and the data bits (D4:D7 of the LCD)     ////
////  connected to sequential pins on the GPIO.  Pin access                ////
////  has no requirements, all 7 bits of the control interface can         ////
////  can be connected to any GPIO using several ports.                    ////
////                                                                       ////
////  To use port access, #define LCD_DATA_PORT to the SFR location of     ////
////  of the GPIO port that holds the interface, -AND- edit LCD_PIN_MAP    ////
////  of this file to configure the pin order.  If you are using a         ////
////  baseline PIC (PCB), then LCD_OUTPUT_MAP and LCD_INPUT_MAP also must  ////
////  be defined.                                                          ////
////                                                                       ////
////  Example of port access:                                              ////
////     #define LCD_DATA_PORT getenv("SFR:PORTD")                         ////
////                                                                       ////
////  To use pin access, the following pins must be defined:               ////
////     LCD_ENABLE_PIN                                                    ////
////     LCD_RS_PIN                                                        ////
////     LCD_RW_PIN                                                        ////
////     LCD_DATA4                                                         ////
////     LCD_DATA5                                                         ////
////     LCD_DATA6                                                         ////
////     LCD_DATA7                                                         ////
////                                                                       ////
////  Example of pin access:                                               ////
////     #define LCD_ENABLE_PIN  PIN_E0                                    ////
////     #define LCD_RS_PIN      PIN_E1                                    ////
////     #define LCD_RW_PIN      PIN_E2                                    ////
////     #define LCD_DATA4       PIN_D4                                    ////
////     #define LCD_DATA5       PIN_D5                                    ////
////     #define LCD_DATA6       PIN_D6                                    ////
////     #define LCD_DATA7       PIN_D7                                    ////
////                                                                       ////
///////////////////////////////////////////////////////////////////////////////
////        (C) Copyright 1996,2010 Custom Computer Services           ////
//// This source code may only be used by licensed users of the CCS C  ////
//// compiler.  This source code may only be distributed to other      ////
//// licensed users of the CCS C compiler.  No other use, reproduction ////
//// or distribution is permitted without written permission.          ////
//// Derivative programs created using this software in object code    ////
//// form are not restricted in any way.                               ////
///////////////////////////////////////////////////////////////////////////

#ifndef __LCD_C__
#define __LCD_C__

// define the pinout.
// only required if port access is being used.
typedef struct 
{                            // This structure is overlayed
   int1 enable;           // on to an I/O port to gain
   int1 rs;               // access to the LCD pins.
   int1 rw;               // The bits are allocated from
   int1 unused;           // low order up.  ENABLE will
   unsigned int     data : 4;         // be LSB pin of that port.
  #if defined(__PCD__)       // The port used will be LCD_DATA_PORT.
   unsigned int    reserved: 8;
  #endif
} LCD_PIN_MAP;

// this is to improve compatability with previous LCD drivers that accepted
// a define labeled 'use_portb_lcd' that configured the LCD onto port B.
#if ((defined(use_portb_lcd)) && (use_portb_lcd==TRUE))
 #define LCD_DATA_PORT getenv("SFR:PORTB")
#endif

#if defined(__PCB__)
   // these definitions only need to be modified for baseline PICs.
   // all other PICs use LCD_PIN_MAP or individual LCD_xxx pin definitions.
/*                                    EN, RS,   RW,   UNUSED,  DATA  */
 const LCD_PIN_MAP LCD_OUTPUT_MAP =  {0,  0,    0,    0,       0};
 const LCD_PIN_MAP LCD_INPUT_MAP =   {0,  0,    0,    0,       0xF};
#endif

////////////////////// END CONFIGURATION ///////////////////////////////////

#ifndef LCD_ENABLE_PIN
   #define lcd_output_enable(x) lcdlat.enable=x
   #define lcd_enable_tris()   lcdtris.enable=0
#else
   #define lcd_output_enable(x) output_bit(LCD_ENABLE_PIN, x)
   #define lcd_enable_tris()  output_drive(LCD_ENABLE_PIN)
#endif

#ifndef LCD_RS_PIN
   #define lcd_output_rs(x) lcdlat.rs=x
   #define lcd_rs_tris()   lcdtris.rs=0
#else
   #define lcd_output_rs(x) output_bit(LCD_RS_PIN, x)
   #define lcd_rs_tris()  output_drive(LCD_RS_PIN)
#endif

#ifndef LCD_RW_PIN
   #define lcd_output_rw(x) lcdlat.rw=x
   #define lcd_rw_tris()   lcdtris.rw=0
#else
   #define lcd_output_rw(x) output_bit(LCD_RW_PIN, x)
   #define lcd_rw_tris()  output_drive(LCD_RW_PIN)
#endif

// original version of this library incorrectly labeled LCD_DATA0 as LCD_DATA4,
// LCD_DATA1 as LCD_DATA5, and so on.  this block of code makes the driver
// compatible with any code written for the original library
#if (defined(LCD_DATA0) && defined(LCD_DATA1) && defined(LCD_DATA2) && defined(LCD_DATA3) && !defined(LCD_DATA4) && !defined(LCD_DATA5) && !defined(LCD_DATA6) && !defined(LCD_DATA7))
   #define  LCD_DATA4    LCD_DATA0
   #define  LCD_DATA5    LCD_DATA1
   #define  LCD_DATA6    LCD_DATA2
   #define  LCD_DATA7    LCD_DATA3
#endif

#ifndef LCD_DATA4
#ifndef LCD_DATA_PORT
   #if defined(__PCB__)
      #define LCD_DATA_PORT      0x06     //portb
      #define set_tris_lcd(x)   set_tris_b(x)
   #else
     #if defined(PIN_D0)
      #define LCD_DATA_PORT      getenv("SFR:PORTD")     //portd
     #else
      #define LCD_DATA_PORT      getenv("SFR:PORTB")     //portb
     #endif
   #endif   
#endif

#if defined(__PCB__)
   LCD_PIN_MAP lcd, lcdlat;
   #byte lcd = LCD_DATA_PORT
   #byte lcdlat = LCD_DATA_PORT
#elif defined(__PCM__)
   LCD_PIN_MAP lcd, lcdlat, lcdtris;
   #byte lcd = LCD_DATA_PORT
   #byte lcdlat = LCD_DATA_PORT
   #byte lcdtris = LCD_DATA_PORT+0x80
#elif defined(__PCH__)
   LCD_PIN_MAP lcd, lcdlat, lcdtris;
   #byte lcd = LCD_DATA_PORT
   #byte lcdlat = LCD_DATA_PORT+9
   #byte lcdtris = LCD_DATA_PORT+0x12
#elif defined(__PCD__)
   LCD_PIN_MAP lcd, lcdlat, lcdtris;
   #word lcd = LCD_DATA_PORT
   #word lcdlat = LCD_DATA_PORT+2
   #word lcdtris = LCD_DATA_PORT-0x02
#endif
#endif   //LCD_DATA4 not defined

#ifndef LCD_TYPE
   #define LCD_TYPE 2           // 0=5x7, 1=5x10, 2=2 lines
#endif

#ifndef LCD_LINE_TWO
   #define LCD_LINE_TWO 0x40    // LCD RAM address for the second line
#endif

#ifndef LCD_LINE_LENGTH
   #define LCD_LINE_LENGTH 20
#endif

unsigned int8 lcd_read_nibble(void);

unsigned int8 lcd_read_byte(void)
{
   unsigned int8 low,high;

 #if defined(__PCB__)
   set_tris_lcd(LCD_INPUT_MAP);
 #else
  #if (defined(LCD_DATA4) && defined(LCD_DATA5) && defined(LCD_DATA6) && defined(LCD_DATA7))
   output_float(LCD_DATA4);
   output_float(LCD_DATA5);
   output_float(LCD_DATA6);
   output_float(LCD_DATA7);
  #else
   lcdtris.data = 0xF;
  #endif
 #endif
       
   lcd_output_rw(1);
   delay_cycles(1);
   lcd_output_enable(1);
   delay_cycles(1);
   high = lcd_read_nibble();
     
   lcd_output_enable(0);
   delay_cycles(1);
   lcd_output_enable(1);
   delay_us(1);
   low = lcd_read_nibble();
     
   lcd_output_enable(0);

 #if defined(__PCB__)
   set_tris_lcd(LCD_OUTPUT_MAP);
 #else
  #if (defined(LCD_DATA4) && defined(LCD_DATA5) && defined(LCD_DATA6) && defined(LCD_DATA7))
   output_drive(LCD_DATA4);
   output_drive(LCD_DATA5);
   output_drive(LCD_DATA6);
   output_drive(LCD_DATA7);
  #else
   lcdtris.data = 0x0;
  #endif
 #endif

   return( (high<<4) | low);
}

unsigned int8 lcd_read_nibble(void)
{
  #if (defined(LCD_DATA4) && defined(LCD_DATA5) && defined(LCD_DATA6) && defined(LCD_DATA7))
   unsigned int8 n = 0x00;

   /* Read the data port */
   n |= input(LCD_DATA4);
   n |= input(LCD_DATA5) << 1;
   n |= input(LCD_DATA6) << 2;
   n |= input(LCD_DATA7) << 3;
   
   return(n);
  #else
   return(lcd.data);
  #endif
}

void lcd_send_nibble(unsigned int8 n)
{
  #if (defined(LCD_DATA4) && defined(LCD_DATA5) && defined(LCD_DATA6) && defined(LCD_DATA7))
   /* Write to the data port */
   output_bit(LCD_DATA4, bit_test(n, 0));
   output_bit(LCD_DATA5, bit_test(n, 1));
   output_bit(LCD_DATA6, bit_test(n, 2));
   output_bit(LCD_DATA7, bit_test(n, 3));
  #else     
   lcdlat.data = n;
  #endif
     
   delay_cycles(1);
   lcd_output_enable(1);
   delay_us(2);
   lcd_output_enable(0);
}

void lcd_send_byte(unsigned int8 address, unsigned int8 n)
{
  #if defined(__PCB__)
   set_tris_lcd(LCD_OUTPUT_MAP);
  #else
   lcd_enable_tris();
   lcd_rs_tris();
   lcd_rw_tris();
  #endif

   lcd_output_rs(0);
   while ( bit_test(lcd_read_byte(),7) ) ;
   lcd_output_rs(address);
   delay_cycles(1);
   lcd_output_rw(0);
   delay_cycles(1);
   lcd_output_enable(0);
   lcd_send_nibble(n >> 4);
   lcd_send_nibble(n & 0xf);
}

#if defined(LCD_EXTENDED_NEWLINE)
unsigned int8 g_LcdX, g_LcdY;
#endif

void lcd_init(void)
{
   unsigned int8 i;
   unsigned int8 LCD_INIT_STRING[4] = {0x20 | (LCD_TYPE << 2), 0xc, 1, 6};
                             // These bytes need to be sent to the LCD
                             // to start it up.
   

   lcd_output_enable(0);
   lcd_output_rs(0);
   lcd_output_rw(0);

 #if defined(__PCB__)
   set_tris_lcd(LCD_OUTPUT_MAP);
 #else
  #if (defined(LCD_DATA4) && defined(LCD_DATA5) && defined(LCD_DATA6) && defined(LCD_DATA7))
   output_drive(LCD_DATA4);
   output_drive(LCD_DATA5);
   output_drive(LCD_DATA6);
   output_drive(LCD_DATA7);
  #else
   lcdtris.data = 0x0;
  #endif
   lcd_enable_tris();
   lcd_rs_tris();
   lcd_rw_tris();
 #endif
   
   delay_ms(15);
   for(i=1;i<=3;++i)
   {
       lcd_send_nibble(3);
       delay_ms(5);
   }
   
   lcd_send_nibble(2);
   delay_ms(5);
   for(i=0;i<=3;++i)
      lcd_send_byte(0,LCD_INIT_STRING[i]);

  #if defined(LCD_EXTENDED_NEWLINE)
   g_LcdX = 0;
   g_LcdY = 0;
  #endif
}

void lcd_gotoxy(unsigned int8 x, unsigned int8 y)
{
   unsigned int8 address;
   
   if(y!=1)
      address=LCD_LINE_TWO;
   else
      address=0;
     
   address+=x-1;
   lcd_send_byte(0,0x80|address);

  #if defined(LCD_EXTENDED_NEWLINE)
   g_LcdX = x - 1;
   g_LcdY = y - 1;
  #endif
}

void lcd_putc(char c)
{
   switch (c)
   {
      case '\a'   :  lcd_gotoxy(1,1);     break;

      case '\f'   :  lcd_send_byte(0,1);
                     delay_ms(2);
                    #if defined(LCD_EXTENDED_NEWLINE)
                     g_LcdX = 0;
                     g_LcdY = 0;
                    #endif
                     break;

     #if defined(LCD_EXTENDED_NEWLINE)
      case '\r'   :  lcd_gotoxy(1, g_LcdY+1);   break;
      case '\n'   :
         while (g_LcdX++ < LCD_LINE_LENGTH)
         {
            lcd_send_byte(1, ' ');
         }
         lcd_gotoxy(1, g_LcdY+2);
         break;
     #else
      case '\n'   : lcd_gotoxy(1,2);        break;
     #endif
     
      case '\b'   : lcd_send_byte(0,0x10);  break;
     
     #if defined(LCD_EXTENDED_NEWLINE)
      default     :
         if (g_LcdX < LCD_LINE_LENGTH)
         {
            lcd_send_byte(1, c);
            g_LcdX++;
         }
         break;
     #else
      default     : lcd_send_byte(1,c);     break;
     #endif
   }
}
 
char lcd_getc(unsigned int8 x, unsigned int8 y)
{
   char value;

   lcd_gotoxy(x,y);
   while ( bit_test(lcd_read_byte(),7) ); // wait until busy flag is low
   lcd_output_rs(1);
   value = lcd_read_byte();
   lcd_output_rs(0);
   
   return(value);
}

// write a custom character to the ram
// which is 0-7 and specifies which character array we are modifying.
// ptr points to an array of 8 bytes, where each byte is the next row of
//    pixels.  only bits 0-4 are used.  the last row is the cursor row, and
//    usually you will want to leave this byte 0x00.
void lcd_set_cgram_char(unsigned int8 which, unsigned int8 *ptr)
{
   unsigned int i;

   which <<= 3;
   which &= 0x38;

   lcd_send_byte(0, 0x40 | which);  //set cgram address

   for(i=0; i<8; i++)
   {
      lcd_send_byte(1, *ptr++);
   }
 
   #if defined(LCD_EXTENDED_NEWLINE)
    lcd_gotoxy(g_LcdX+1, g_LcdY+1);  //set ddram address
   #endif
}

void lcd_cursor_on(int1 on)
{
   if (on)
   {
      lcd_send_byte(0,0x0F);           //turn LCD cursor ON
   }
   else
   {
      lcd_send_byte(0,0x0C);           //turn LCD cursor OFF
   }
}

#endif

Desconectado fabianbambam

  • PIC10
  • *
  • Mensajes: 15
Re:Pantalla LCD 16x2 no muestra nada en PIC16F876
« Respuesta #9 en: 16 de Junio de 2016, 13:12:04 »
Aqui se encuentra la identificacion de pines que consegui en internet

Desconectado fabianbambam

  • PIC10
  • *
  • Mensajes: 15
Re:Pantalla LCD 16x2 no muestra nada en PIC16F876
« Respuesta #10 en: 19 de Junio de 2016, 12:58:39 »
Logré resolver el problema, utilice la librería flex_lcd.c y además cambié la conexión del pin 5. R/W,  lo tenía conectado según muchos diagramas que vi en internet pero decidí probrarlo en el pin al que yo lo conectaba en la programación y simulación en proteus y funcionó perfecto, en la programación inicialicé dentro del void main().

Solamente tiene el detalle de que en la zona donde muestro el porcentaje de 0-100%, el porcentaje al llegar al 0% despues de variarse el valor, se muestra de la siguiente forma: 0%% y de momento tendré que buscar otra solución a ese asunto, adjunto una imagen con la muestra del LCD en funcionamiento, gracias por su apoyo.  :-/ :lol: :mrgreen:


 

anything