Responder al tema

Mensaje

[QUOTE="luizforever, post: 914743, member: 197770"]
Hola amigos del foro, una ayuda por favor ya que es para un proyecto importante.
No sé porque al compilar este programa me bota varios errores.
Al principio pensé que le faltaba algo, luego observé que había una librería de LCD(//flex_lcd.c) la cual la cambie por la original, pero igual me sigue botando error y no se cual será el problema.
¿Serían tan amables de ayudarme en este problema? Les sería muy agradecido.
OJO, un detalle,  ese programa no es mio, lo encontré en un libro en la empresa donde laboro actualmente.

Gracias

Programa del proyecto, analizador de redes:
[code]#include <16f877a.h>

#device adc=10

#fuses HS,NOWDT,PUT,NODEBUG,PROTECT,BROWNOUT,NOLVP

#use delay(clock=20M)

#use fast_io(A)

#use fast_io(B)

#use fast_io(C)

#use fast_io(D)

#use fast_io(E)

#byte porta=0x05

#byte portb=0x06

#byte portc=0x07

#byte portd=0x08

#byte porte=0x09

#bit t1if = getenv("BIT:TMR1IF")

#bit t2if = getenv("BIT:TMR2IF")

#bit sV1 =  portb.5

#bit sV2 =  portb.6

#bit sV3 =  portb.7

#bit sI1 =  portb.0

#bit sI2 =  portc.1

#bit sI3 =  portc.2

#bit pFuncion = portc.3

#define VAL_T0 256-195      // para interrupcion aprox de 10ms

#include <math.h>

#include "flex_lcd.h"

#include "funciones_fas.c"

// variable para mostrar en pantalla

static int1 f_mostrar;

// declaracion de funciones

void mostrar_tension();

void mostrar_corriente();

void mostrar_fase();

void mostrar_factor();

// temporizacion cada 10 milisegundos
#INT_TIMER0

void timer0_isr()

{

static int cntT0;

set_timer0(VAL_T0);
   
   if(++cntT0>=40){

cntT0=0;

f_mostrar=1;

}

void main()

{

// CONFIGURACION ADC

setup_adc_ports(AN0_AN1_AN2_AN4_AN5_AN6_AN7_VSS_VREF);

setup_adc(ADC_CLOCK_DIV_32);

set_adc_channel(0);

// CONFIGURACION PUERTOS E/S

set_tris_a(0b11101111);

set_tris_b(0b11100001);

set_tris_c(0b00001110);

set_tris_d(0);

set_tris_e(0b111);
   
  
   porta=0;

portb=0;

portc=0;

portd=0;

porte=0;

// CONFIGURACION TIMERS

setup_timer_0(RTCC_INTERNAL|RTCC_DIV_256);

setup_timer_1(T1_INTERNAL|T1_DIV_BY_1);

setup_timer_2(T2_DIV_BY_4,64,10);         // 520useg

enable_interrupts(INT_TIMER0);

enable_interrupts(GLOBAL);

// INICIA LCD

lcd_init();
   
   senal_ini();

lcd_putc("\fRichard Quillas");

//delay_ms(2000);
   
   lcd_putc("\f  FASIMETRO");

lcd_putc("\n  TRIFASICO");

//delay_ms(2000);

//LAZO INFINITO

while(TRUE)

{

mostrar_fase();

mostrar_factor();

mostrar_tension();

mostrar_corriente();

}

}      
   
   
   
// ================================================================

// FUNCIONES PARA MOSTRAR VALORES

void mostrar_tension()

{

long va,vb,vc;
   
   lcd_putc("\fV1=     V2=  ");

lcd_putc("\nV3=    ");

do{

if(f_mostrar)

{

f_mostrar=0;

va=medirSenal(0)*1.73;

vb=medirSenal(1)*1.73;

vc=medirSenal(2)*1.73;

lcd_gotoxy(4,1);

printf(lcd_putc,"%3Lu",va);

lcd_gotoxy(12,1);

printf(lcd_putc,"%3Lu",vb);

lcd_gotoxy(4,2);

printf(lcd_putc,"%3Lu",vc);    
     
      }

}while((pFuncion)==1);

delay_ms(20);

while(pFuncion==0);

delay_ms(20);

}

void mostrar_Corriente()

{

float ia,ib,ic;
   
   lcd_putc("\fI1=     I2=  ");

lcd_putc("\nI3=    ");

f_mostrar=1;

do{

if(f_mostrar)

{

f_mostrar=0;

ia=medirSenal(4)*0.1173;      // 120/1023

ib=medirSenal(5)*0.1173;

ic=medirSenal(6)*0.1173;

lcd_gotoxy(4,1);

printf(lcd_putc,"%.1f",ia);

lcd_gotoxy(12,1);

printf(lcd_putc,"%.1f",ib);

lcd_gotoxy(4,2);

printf(lcd_putc,"%.1f",ic);     
    
      }

}while((pFuncion)==1);

delay_ms(20);

while(pFuncion==0);

delay_ms(20);

}

void mostrar_fase()

{

float time;
   
   lcd_putc("\fa1=     a2=  ");

lcd_putc("\na3=    ");

f_mostrar=1;

do{

if(f_mostrar==1)

{

f_mostrar=0;

time=medirDesfase(sv1,si1);

calcula_angulo(time);

lcd_gotoxy(4,1);

printf(lcd_putc,"%.1f ",angulo);

time=medirDesfase(sv2,si2);

calcula_angulo(time);

lcd_gotoxy(12,1);

printf(lcd_putc,"%.1f ",angulo);

time=medirDesfase(sv3,si3);

calcula_angulo(time);

lcd_gotoxy(4,2);

printf(lcd_putc,"%.1f ",angulo);   
     
      }

}while((pFuncion)==1);

delay_ms(20);

while(pFuncion==0);

delay_ms(20);

}
  
void mostrar_factor()

{

float time;

lcd_putc("\ff1=     f2=  ");

lcd_putc("\nf3=    ");

f_mostrar=1;

do{

if(f_mostrar)

{

f_mostrar=0;

time=medirDesfase(sv1,si1);

calcula_angulo(time);

lcd_gotoxy(4,1);

printf(lcd_putc,"%.2f ",factor);

time=medirDesfase(sv2,si2);

calcula_angulo(time);

lcd_gotoxy(12,1);

printf(lcd_putc,"%.2f ",factor);

time=medirDesfase(sv3,si3);

calcula_angulo(time);

lcd_gotoxy(4,2);

printf(lcd_putc,"%.2f ",factor); 
   
      }

}while((pFuncion)==1);

delay_ms(20);

while(pFuncion==0);

delay_ms(20);

}[/code]
Librería para la pantalla LCD (// flex_lcd.c)
[code]// flex_lcd.c

///////////////////////////////////////////////////////////////////////////
////                             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         ////
////                                                                   ////
// These pins are for the Microchip PicDem2-Plus board,
// which is what I used to test the driver.  Change these
// pins to fit your own board.

#define LCD_DB4   PIN_C7
#define LCD_DB5   PIN_C6
#define LCD_DB6   PIN_C5
#define LCD_DB7   PIN_C4

#define LCD_RS    PIN_B3
//#define LCD_RW    PIN_A5
#define LCD_E     PIN_B2

// If you only want a 6-pin interface to your LCD, then
// connect the R/W pin on the LCD to ground, and comment
// out the following line.

//#define USE_LCD_RW   1

//========================================

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

int8 const LCD_INIT_STRING[4] =
{
 0x20 | (lcd_type << 2), // Func set: 4-bit, 2 lines, 5x8 dots
 0xc,                    // Display on
 1,                      // Clear display
 6                       // Increment cursor
 };

//-------------------------------------
void lcd_send_nibble(int8 nibble)
{
// Note:  !! converts an integer expression
// to a boolean (1 or 0).
 output_low(LCD_DB4);
 output_low(LCD_DB5);
 output_low(LCD_DB6);
 output_low(LCD_DB7);
 
 if(bit_test(nibble,0)) output_high(LCD_DB4);
 if(bit_test(nibble,1)) output_high(LCD_DB5);
 if(bit_test(nibble,2)) output_high(LCD_DB6);
 if(bit_test(nibble,3)) output_high(LCD_DB7);
/* 
 output_bit(LCD_DB4, !!(nibble & 1));
 output_bit(LCD_DB5, !!(nibble & 2));
 output_bit(LCD_DB6, !!(nibble & 4));
 output_bit(LCD_DB7, !!(nibble & 8));
*/
 delay_cycles(1);
 output_high(LCD_E);
 delay_us(2);
 output_low(LCD_E);   
}

//-----------------------------------    
// This sub-routine is only called by lcd_read_byte().
// It's not a stand-alone routine.  For example, the
// R/W signal is set high by lcd_read_byte() before
// this routine is called.

#ifdef USE_LCD_RW
int8 lcd_read_nibble(void)
{
int8 retval;
// Create bit variables so that we can easily set
// individual bits in the retval variable.
#bit retval_0 = retval.0
#bit retval_1 = retval.1
#bit retval_2 = retval.2
#bit retval_3 = retval.3

retval = 0;

output_high(LCD_E);
delay_cycles(1);

retval_0 = input(LCD_DB4);
retval_1 = input(LCD_DB5);
retval_2 = input(LCD_DB6);
retval_3 = input(LCD_DB7);

output_low(LCD_E);

return(retval);
}
#endif

//---------------------------------------
// Read a byte from the LCD and return it.

#ifdef USE_LCD_RW
int8 lcd_read_byte(void)
{
int8 low;
int8 high;

output_high(LCD_RW);
delay_cycles(1);

high = lcd_read_nibble();

low = lcd_read_nibble();

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

//----------------------------------------  
// Send a byte to the LCD.
void lcd_send_byte(int8 address, int8 n)
{
output_low(LCD_RS);

#ifdef USE_LCD_RW
while(bit_test(lcd_read_byte(),7)) ;
#else
delay_us(60);
#endif

if(address)
   output_high(LCD_RS);
else
   output_low(LCD_RS);

delay_cycles(1);

#ifdef USE_LCD_RW
output_low(LCD_RW);
delay_cycles(1);
#endif

output_low(LCD_E);

lcd_send_nibble(n >> 4);
lcd_send_nibble(n & 0xf);  
}

//----------------------------------------------------
//---------pone cursor on o off-----------------------
void lcd_cursor(int on_off)
{
   if(on_off==on){lcd_send_byte(0,0xf);}     // 0x0e es cursor on sin parapadeo
   else {lcd_send_byte(0,0xc);}              // 0x0f cursor on con parpadeo
                                             // 0x0c cursor off
}

//------------------------------------------------------------------------------
//                  INICIALIZACION DE LCD
//------------------------------------------------------------------------------
void lcd_init(void)
{
int8 i;

output_low(LCD_RS);

#ifdef USE_LCD_RW
output_low(LCD_RW);
#endif

output_low(LCD_E);

delay_ms(15);

for(i=0 ;i < 3; i++)
   {
    lcd_send_nibble(0x03);
    delay_ms(5);
   }

lcd_send_nibble(0x02);

for(i=0; i < sizeof(LCD_INIT_STRING); i++)
   {
    lcd_send_byte(0, LCD_INIT_STRING[i]);

// If the R/W signal is not used, then
    // the busy bit can't be polled.  One of
    // the init commands takes longer than
    // the hard-coded delay of 60 us, so in
    // that case, lets just do a 5 ms delay
    // after all four of them.
    #ifndef USE_LCD_RW
    delay_ms(5);
    #endif
   }

}

// FIN INICIALIZACION   
//----------------------------------------------------------------------------

void lcd_gotoxy(int8 x, int8 y)
{
int8 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);
      delay_us(500);
      break;

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

case '\b':
       lcd_send_byte(0,0x10);
       break;

default:
       lcd_send_byte(1,c);
       break;
   }
}

//---------------------------------------
//   LEYENDO EL LCD
//---------------------------------------
#ifdef USE_LCD_RW

char lcd_getc(int8 x, int8 y)
{
   char value;

lcd_gotoxy(x,y);

// Wait until busy flag is low.
   while(bit_test(lcd_read_byte(),7));

output_high(LCD_RS);
   value = lcd_read_byte();
   output_low(lcd_RS);

return(value);
}
#endif
//----------------------------------------

void lcd_setcursor_vb(short visible, short blink) { 
  lcd_send_byte(0, 0xC|(visible<<1)|blink); 
}[/code]
[/QUOTE]

Verificación