LCD com 16f628a Funciona? *(Resolvido)

[eduardo_gsp_oliveira]

Primeiramente uma grande Saudação a todos aqui do forum

bom ja estou estudando pic algum tempo mas ainda tenho muitas duvidas
e em relação a LCD ja bati muito a cabeça pq a minha lib LCD.c não funcionava.

Agora ja consegui fazer a Lib funcionar mas não sei o pq ela só fuinciona com 16f877.

depois de muito suar a camisa consegui fazer funcionar com 16f628 mas qdo vou testar no proteus fica acumulando umas msgs de erro

"[PIC16 CORE] PC=0x004F. TRISB instruction is deprecated for PIC16628."
"[PIC16 CORE] PC=0x0062. TRISB instruction is deprecated for PIC16628."
apesar disso a imagem aparece porem tenho medo de testar no real e queimar algum componente

desde ja agradeço a todos

[eduardo_gsp_oliveira]

e ai ninguem responde pq a pergunta foi muito boba?
peço desculpa a todos do forum mas eu sou iniciante se alguem puder me ajudar fico muito grato

novamente obrigado

[RobL]

"[PIC16 CORE] PC=0x004F. TRISB instruction is deprecated for PIC16628."
"[PIC16 CORE] PC=0x0062. TRISB instruction is deprecated for PIC16628."

Essas mensagens devem ter aparecido, por que o assembler gerado pode ter usado TRIS, f ou w no lugar do registro TRISA, TRISB, etc.

Veja se seu chip está setado corretamente para o Proteus.

Antigamente para os pics 16C54 havia uma instrução TRIS, f /w.
Mas o estranho é que está informando que TRISB como instruction quando a antiga instrução é TRIS, f ou w.

Veja o que foi gerado no seu assembler e corrija para TRISB ou seja de W -> TRISB. Se não encontrar nada é algo do Proteus, ou alguma setagem para o seu chip está errada.

Quanto a estragar o seu LCD, se for um display clássico, penso que só vais conseguir estragar se ligar errado (hardware) ou se ultrapassar a tensão recomendada para ele, especialmente na parte relativa ao brilho.

[eduardo_gsp_oliveira]

ola Robl fico muito grato, sua explicação me deixou aliviado em relação ao LCD

Qto ao programa vou tentar "traduzir" de C para assembler e posto aqui quem sabe eu consigo resolver esse mistério

falando nisso alguem sabe se tem como fazer isso ?????

desde ja agradeço

[_blackmore_]

eduardo_gsp_oliveira

tive um problema semelhante ao teu ... e o meu caso foi um erro no circuito ... o biblioteca não utilizava então o pino 5 do LCD, mas no meu esquema o mesmo não estava aterrado, fazendo assim com que não conseguisse ver nada no LCD ... no meu caso aterrando o pino 5 funcionou tudo, verifica então se não falta alguma coisa por ae ... esquema e biblioteca.

abrax!

[eduardo_gsp_oliveira]

obrigado a todos pelas dicas
afim de tornar a resolução mais facil estou postande aqui a imagem do circuito montado no proteus contendo o erro que aparece



apesar do erro o LCD funciona, mas com o tempo as msg de erro se acumulam e o pc fica lento

aqui esta o programa

#include <16f628a.h>
#use delay (clock = 4000000)
#fuses INTRC_IO,NOWDT,PUT,NOBROWNOUT,NOMCLR,NOLVP

//colocar Lib do LCD
#define use_portb_lcd true //para poder usar o LCD na porta B * tem de vir primeiro
#include <lcd.c> //inclui Lib do LCD

main()
{
signed int conta;
lcd_init(); //inicializa o LCD e tem de ser nesse lugar
for (conta=10; conta>=0; conta--)
{
printf (lcd_putc,"\fcontagem regressiva - %u", conta);
delay_ms(300);
}
}


aqui esta a Lib

///////////////////////////////////////////////////////////////////////////
//// LCDD.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. ////
//// The following have special meaning: ////
//// \f Clear display ////
//// \n Go to start of second line ////
//// \b Move back one position ////
//// ////
//// 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 ////
//// ////
///////////////////////////////////////////////////////////////////////////
//// (C) Copyright 1996,2003 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. ////
///////////////////////////////////////////////////////////////////////////

// As defined in the following structure the pin connection is as follows:
// D0 enable
// D1 rs
// D2 rw
// D4 D4
// D5 D5
// D6 D6
// D7 D7
//
// LCD pins D0-D3 are not used and PIC D3 is not used.

//#define use_portb_lcd true

struct lcd_pin_map { // This structure is overlayed
BOOLEAN enable; // on to an I/O port to gain
BOOLEAN rs; // access to the LCD pins.
BOOLEAN rw; // The bits are allocated from
BOOLEAN unused; // low order up. ENABLE will
int data : 4; // be pin B0.
} lcd;



#if defined use_portb_lcd
#byte lcd = 0xF81 // This puts the entire structure
#else
#byte lcd = 0xF83 // This puts the entire structure
#endif


#if defined use_portb_lcd
#byte lcd = 6 // on to port B (at address 6)
#else
#byte lcd = 8 // on to port D (at address
#endif


#if defined use_portb_lcd
#define set_tris_lcd(x) set_tris_b(x)
#else
#define set_tris_lcd(x) set_tris_d(x)
#endif


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


BYTE const LCD_INIT_STRING[4] = {0x20 | (lcd_type << 2), 0xc, 1, 6};
// These bytes need to be sent to the LCD
// to start it up.


// The following are used for setting
// the I/O port direction register.

struct lcd_pin_map const LCD_WRITE = {0,0,0,0,0}; // For write mode all pins are out
struct lcd_pin_map const LCD_READ = {0,0,0,0,15}; // For read mode data pins are in



BYTE lcd_read_byte() {
BYTE low,high;

set_tris_lcd(LCD_READ);
lcd.rw = 1;
delay_cycles(1);
lcd.enable = 1;
delay_cycles(1);
high = lcd.data;
lcd.enable = 0;
delay_cycles(1);
lcd.enable = 1;
delay_us(1);
low = lcd.data;
lcd.enable = 0;
set_tris_LCD(LCD_WRITE);
return( (high<<4) | low);
}


void lcd_send_nibble( BYTE n ) {
lcd.data = n;
delay_cycles(1);
lcd.enable = 1;
delay_us(2);
lcd.enable = 0;
}


void lcd_send_byte( BYTE address, BYTE n ) {

lcd.rs = 0;
while ( bit_test(lcd_read_byte(),7) ) ;
lcd.rs = address;
delay_cycles(1);
lcd.rw = 0;
delay_cycles(1);
lcd.enable = 0;
lcd_send_nibble(n >> 4);
lcd_send_nibble(n & 0xf);
}


void lcd_init() {
BYTE i;
set_tris_LCD(LCD_WRITE);
lcd.rs = 0;
lcd.rw = 0;
lcd.enable = 0;
delay_ms(15);
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;

if(y!=1)
address=lcd_line_two;
else
address=0;
address+=x-1;
lcd_send_byte(0,0x80|address);
}

void lcd_putc( char c) {
switch (c) {
case '\f' : lcd_send_byte(0,1);
delay_ms(2);
break;
case '\n' : lcd_gotoxy(1,2); break;
case '\b' : lcd_send_byte(0,0x10); 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) ); // wait until busy flag is low
lcd.rs=1;
value = lcd_read_byte();
lcd.rs=0;
return(value);
}

[roquetti]

Eduardo, não teria que dizer no seu programa se a configuração que você vai usar o LCD é por 4 ou 8 pinos?
Abraços
Paulo Roquetti

[eduardo_gsp_oliveira]

Eduardo, não teria que dizer no seu programa se a configuração que você vai usar o LCD é por 4 ou 8 pinos?
Abraços
Paulo Roquetti

Essa é uma boa dica, mais quando eu usei o 16F877 não precisei definir isso
e funcionou ótimamente

andei tb olhando os exemplos de LCD que vem com ccs e nenhum deles precisou definir isso
mas se casao vc saiba como definir isso, da um toque para mim

abraços

[roquetti]

sua lib não está escrito isto?:

#if defined use_portb_lcd
#byte lcd = 6 // on to port B (at address 6)
#else
#byte lcd = 8 // on to port D (at address
#endif


o 16F628 não tem PORTD.


#if defined use_portb_lcd
#define set_tris_lcd(x) set_tris_b(x)
#else
#define set_tris_lcd(x) set_tris_d(x)
#endif


trisd?


outra coisa é o RW se não for usar tem que estar aterrado

[eduardo_gsp_oliveira]

Então quando eu uso com o 16f877 e naum defino nada pq de default é porta D
mais qdo eu vou usar o 16f628 eu tenho de definir no começo do programa que a porta do lcd é port B

por isso que na lib ta escrito

#if defined use_portb_lcd
#byte lcd = 6 // on to port B (at address 6)
#else
#byte lcd = 8 // on to port D (at address
#endif

#if defined use_portb_lcd
#define set_tris_lcd(x) set_tris_b(x)
#else
#define set_tris_lcd(x) set_tris_d(x)
#endif

como eu coloquei no começo do programa
#define use_portb_lcd true
não pode ser esse o problema certo?

[roquetti]

Então quando eu uso com o 16f877 e naum defino nada pq de default é porta D
mais qdo eu vou usar o 16f628 eu tenho de definir no começo do programa que a porta do lcd é port B

por isso que na lib ta escrito

#if defined use_portb_lcd
#byte lcd = 6 // on to port B (at address 6)
#else
#byte lcd = 8 // on to port D (at address
#endif

#if defined use_portb_lcd
#define set_tris_lcd(x) set_tris_b(x)
#else
#define set_tris_lcd(x) set_tris_d(x)
#endif

como eu coloquei no começo do programa
#define use_portb_lcd true
não pode ser esse o problema certo?

ué! tá assim:

//#define use_portb_lcd true

não tá habilitado

[Gilsom]

E sua Biblioteca eu compilei com esta do CCS 4.88 e funcionou perfeito.Teste ai

[/code]///////////////////////////////////////////////////////////////////////////////
//// 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. ////
//// The following have special meaning: ////
//// \f Clear display ////
//// \n Go to start of second line ////
//// \b Move back one position ////
//// ////
//// 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 ////
//// ////
//// 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 port. 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_DATA0 ////
//// LCD_DATA1 ////
//// LCD_DATA2 ////
//// LCD_DATA3 ////
//// LCD_DATA4 ////
//// ////
//// Example of pin access: ////
//// #define LCD_ENABLE_PIN PIN_E0 ////
//// #define LCD_RS_PIN PIN_E1 ////
//// #define LCD_RW_PIN PIN_E2 ////
//// #define LCD_DATA0 PIN_D4 ////
//// #define LCD_DATA1 PIN_D5 ////
//// #define LCD_DATA2 PIN_D6 ////
//// #define LCD_DATA3 PIN_D7 ////
//// ////
///////////////////////////////////////////////////////////////////////////////
//// (C) Copyright 1996,2009 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. ////
///////////////////////////////////////////////////////////////////////////

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

#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

#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

#ifndef LCD_DATA_PORT
#if defined(__PCB__)
#define LCD_DATA_PORT 0x06 //portb
#define set_tris_lcd(x) set_tris_b(x)
#elif defined(__PCM__)
#define LCD_DATA_PORT getenv("SFR:PORTB") //portd
#elif defined(__PCH__)
#define LCD_DATA_PORT getenv("SFR:PORTB") //portd
#elif defined(__PCD__)
#define LCD_DATA_PORT getenv("SFR:PORTB") //portd
#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

#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

BYTE const LCD_INIT_STRING[4] = {0x20 | (lcd_type << 2), 0xc, 1, 6};
// These bytes need to be sent to the LCD
// to start it up.


BYTE lcd_read_nibble(void);

BYTE lcd_read_byte(void)
{
BYTE low,high;

#if defined(__PCB__)
set_tris_lcd(LCD_INPUT_MAP);
#else
#if (defined(LCD_DATA0) && defined(LCD_DATA1) && defined(LCD_DATA2) && defined(LCD_DATA3))
output_float(LCD_DATA0);
output_float(LCD_DATA1);
output_float(LCD_DATA2);
output_float(LCD_DATA3);
#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_INPUT_MAP);
#else
#if (defined(LCD_DATA0) && defined(LCD_DATA1) && defined(LCD_DATA2) && defined(LCD_DATA3))
output_drive(LCD_DATA0);
output_drive(LCD_DATA1);
output_drive(LCD_DATA2);
output_drive(LCD_DATA3);
#else
lcdtris.data = 0x0;
#endif
#endif

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

BYTE lcd_read_nibble(void)
{
#if (defined(LCD_DATA0) && defined(LCD_DATA1) && defined(LCD_DATA2) && defined(LCD_DATA3))
BYTE n = 0x00;

/* Read the data port */
n |= input(LCD_DATA0);
n |= input(LCD_DATA1) << 1;
n |= input(LCD_DATA2) << 2;
n |= input(LCD_DATA3) << 3;

return(n);
#else
return(lcd.data);
#endif
}

void lcd_send_nibble(BYTE n)
{
#if (defined(LCD_DATA0) && defined(LCD_DATA1) && defined(LCD_DATA2) && defined(LCD_DATA3))
/* Write to the data port */
output_bit(LCD_DATA0, BIT_TEST(n, 0));
output_bit(LCD_DATA1, BIT_TEST(n, 1));
output_bit(LCD_DATA2, BIT_TEST(n, 2));
output_bit(LCD_DATA3, 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(BYTE address, BYTE n)
{
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);
}

void lcd_init(void)
{
BYTE i;

#if defined(__PCB__)
set_tris_lcd(LCD_OUTPUT_MAP);
#else
#if (defined(LCD_DATA0) && defined(LCD_DATA1) && defined(LCD_DATA2) && defined(LCD_DATA3))
output_drive(LCD_DATA0);
output_drive(LCD_DATA1);
output_drive(LCD_DATA2);
output_drive(LCD_DATA3);
#else
lcdtris.data = 0x0;
#endif
lcd_enable_tris();
lcd_rs_tris();
lcd_rw_tris();
#endif

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

delay_ms(15);
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;

if(y!=1)
address=LCD_LINE_TWO;
else
address=0;

address+=x-1;
lcd_send_byte(0,0x80|address);
}

void lcd_putc(char c)
{
switch (c)
{
case '\f' : lcd_send_byte(0,1);
delay_ms(2);
break;

case '\n' : lcd_gotoxy(1,2); break;

case '\b' : lcd_send_byte(0,0x10); 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) ); // wait until busy flag is low
lcd_output_rs(1);
value = lcd_read_byte();
lcd_output_rs(0);

return(value);
}

[eduardo_gsp_oliveira]

ola
obrigado a todos pelas dicas
e obrigado Gilson, realmente com a lib que vc me mandou tudo funcionou perfeitamente
vou agora testar com outros PICs mas ja vou mudar o nome do topico para resolvido

novamente obrigado a todos