uControl
Enero 20, 2017, 06:44:39 *
Bienvenido(a), Visitante. Por favor, ingresa o regístrate.
¿Perdiste tu email de activación?

Ingresar con nombre de usuario, contraseña y duración de la sesión
 
   Inicio   Ayuda Buscar Ingresar Registrarse  
Páginas: [1]   Ir Abajo
  Imprimir  
Autor Tema: Librerías para SDCC para copiar y usar  (Leído 13695 veces)
0 Usuarios y 1 Visitante están viendo este tema.
Felixls
Moderador
PIC24F
******
Desconectado Desconectado

Sexo: Masculino
Mensajes: 3124



WWW
« : Septiembre 10, 2009, 02:27:08 »

Si intentaste usar SDCC con PIC de 14bits, como el 16F877 notarás una ausencia importante en el release de SDCC (actualmente en 2.9.2) que son las librerías para dispositivos y hasta la falta de funciones tan simples como obtener la longitud de un string!

Bueno, el propósito de este tema es el aporte de todas las liberías para SDCC que cada uno posea o conozca y quiera compartirlas con todos los integrantes de uControl.

Conversor A/D:
adc.h
Código:
#ifndef ADC_H

#define ADC_H



/* flag de interrupciones on/off */

#define INT_OFF   0x00

#define INT_ON   0x01



/* frequencia de oscillador */

#define FOSC_2   0x00

#define FOSC_4   0x04

#define FOSC_8   0x01

#define FOSC_16   0x05

#define FOSC_32   0x02

#define FOSC_64   0x06

#define FOSC_RC   0x07



/* configuracion de entradas y Vref(PCFG en ADCON1) */

#define A8_R0   0x00

#define A7_R1   0x01

#define A5_R0   0x02

#define A4_R1   0x03

#define A3_R0   0x04

#define A2_R1   0x05

#define A0_R0   0x06

#define A6_R2   0x08

#define A6_R0   0x09

#define A5_R1   0x0a

#define A4_R2   0x0b

#define A3_R2   0x0c

#define A2_R2   0x0d

#define A1_R0   0x0e

#define A1_R2   0x0f



void adc_init(unsigned char fosc, unsigned char pcfg, unsigned char config);

void adc_close(void);

unsigned int adc_read(unsigned char canal);

void adc_startread(unsigned char canal);



#endif

adc.c
Código:
#include <pic/pic16f877a.h>

#include "adc.h"

#include "delay.h"



void adc_init(unsigned char fosc, unsigned char pcfg, unsigned char config)

{

   ADCON0 = 0;

   ADCON0 = (fosc & 0x03) << 6;         // establecer frecuencia

   ADCON1 = (pcfg & 0x0F) | 0x080;      // establecer entradas

   if (fosc & 0x04)

      ADCS2 = 1;

   if (config & INT_ON)                 // establecer interrupciones

   {

      ADIF = 0;

      ADIE = 1;

      PEIE = 1;

   }

   ADON = 1;                            // habilitar módulo ADC

}



void adc_close(void)                    // deshabilitar módulo ADC

{

   ADON = 0;

   ADIE = 0;

}



unsigned int adc_read(unsigned char canal)

{

   unsigned int valor;



   ADCON0 &= 0xC7;                     // borrar anteriores selecciones

   ADCON0 |= (canal & 0x07) << 3;      // establecer canal seleccionado


   delay_ms(30);

   GO = 1;                             // iniciar conversión

   while (GO);                         // esperar que termine
  

   valor = ADRESH << 8 | ADRESL;       // leer valor

   return valor;

}



void adc_startread(unsigned char canal)

{

   ADCON0 &= 0xC7;                     // borrar anteriores selecciones

   ADCON0 |= (canal & 0x07) << 3;      // establecer canal seleccionado



   delay_us(30);

   GO = 1;               // iniciar conversión

}

Delay (retardos)

delay.h
Código:
#ifndef DELAY_H

#define DELAY_H



void delay_us ( char a );

void delay_ms(int ms);

#endif


delay.c
Código:
#include "delay.h"



// tiempo = (5a+1)µs a>=2   basado en micro a 20mhz

void delay_us ( char a )

{ a;

 _asm                 // a ya está cargado en el registro w

    sublw 1           //(1-a)

bucle:

    ADDLW 1

 btfss 0x03,0        //test si w=0 carry=1

    goto bucle

 _endasm;

}



void delay_ms(int ms)

{

    unsigned int j;

    unsigned int k = ms * 10;

    for (j=0; j<k; j++)

      delay_us (33);       //101µs

}


I2c (Esta versión es por software)
i2c.h
Código:
#ifndef I2C_H

#define I2C_H


#define SDA RC4
#define SCL RC3

#define TSDA TRISC4
#define TSCL TRISC3

void i2c_delay(void);
void i2c_clock(void);
void i2c_start(void);
void i2c_stop(void);
unsigned char i2c_write(unsigned char dat);
unsigned char i2c_read(void);
void i2c_ack();
void i2c_noack();


#endif

i2c.c
Código:
#include <pic/pic16f877a.h>


#include "i2c.h"
#include "delay.h"

void i2c_delay(void)
{
  delay_us(133);
}

void SDALow()
{
  TSDA = 0;
  SDA = 0;  
}

void SDAHigh()
{
  TSDA = 1;
}

void SCLLow()
{
  TSCL = 0;
  SCL = 0;
}

void SCLHigh()
{
  TSCL = 1;
  while(SCL==0);
}

void i2c_clock(void)
{
i2c_delay();

SCLHigh();     /* Start clock */

i2c_delay();    

SCLLow();      /* Clear SCL */

i2c_delay();    
}

void i2c_start(void)
{
if(SCL)
   SCLLow();   /* Clear SCL */

SDAHigh();        /* Set SDA */
SCLHigh();   /* Set SCL */

i2c_delay();

SDALow();        /* Clear SDA */

i2c_delay();

SCLLow();        /* Clear SCL */

i2c_delay();
}

void i2c_stop(void)
{
if(SCL)
   SCLLow(); /* Clear SCL */

SDALow(); /* Clear SDA */
SCLHigh(); /* Set SCL */

i2c_delay();

SDAHigh(); /* Set SDA */

i2c_delay();
}

unsigned char i2c_write(unsigned char dat)
{
unsigned char data_bit;
unsigned char i;

for(i=0;i<8;i++) /* For loop 8 time(send data 1 byte) */
{
data_bit = dat & 0x80; /* Filter MSB bit keep to data_bit */

    if (data_bit==0)
      SDALow();            /* Send data_bit to SDA */
    else
      SDAHigh();


dat = dat<<1;  
 SCLHigh();
 i2c_delay();
 SCLLow();
 i2c_delay();
}

SDAHigh();
SCLHigh();
i2c_delay();

data_bit = SDA;   /* Check acknowledge */
SCLLow();       /* Clear SCL */

i2c_delay();

return data_bit;  /* If send_bit = 0 i2c is valid */
}

unsigned char i2c_read(void)
{
unsigned char i, dat;

dat = 0x00;

  SDAHigh();
  
for(i=0;i<8;i++) /* For loop read data 1 byte */
{
SCLHigh(); /* Set SCL */

dat = dat<<1;

if (SDA)
dat = dat | 0x01; // if port pin = 1, set LSB (bit position)

else

dat = dat & 0xFE; // else port pin = ,clear LSB (bit position)


    SCLLow();
 i2c_delay();
    
}
return dat;
}

void i2c_ack()
{
SDALow(); /* Clear SDA */

i2c_delay();    

i2c_clock(); /* Call for send data to i2c bus */
}

void i2c_noack()
{
SDAHigh(); /* Set SDA */

i2c_delay();

i2c_clock(); /* Call for send data to i2c bus */
}

Lcd
Código:
#ifndef LCD_H

#define LCD_H

/*-------------------------------------------------------------------------------------------------

  LCD Library (44780 compatible).



  No usa el pin R/W, ya que normalmente se lo conecta a la masa del circuito.



  Fecha de creación: 8/04/2009

  Autor: Felixls

  Web: http://sergiols.blogspot.com

  Changelog:

  Fecha   Versión     Observaciones

  8/4/09  1.00        Versión inicial



  Frecuencia de reloj: 4MHZ

  Compilador: SDCC 2.9.1



  -------------------------------------------------------------------------------------------------*/



/*  PORTB:4  ----->  LCD bit 4           */

/*  PORTB:5  ----->  LCD bit 5           */

/*  PORTB:6  ----->  LCD bit 6           */

/*  PORTB:7  ----->  LCD bit 7           */

/*  PORTB:1  ----->  LCD RS              */

/*  PORTB:3  ----->  LCD E               */



#define LCD_DATA                PORTB // Puerto de datos

#define LCD_DATA_TRIS           TRISB // Control del puerto de datos

#define LCD_RS                  RB2   // Modo

#define LCD_ENABLE              RB3   // Habilitación/deshab. en envíos de datos al lcd.



#define LCD_CLEAR                0x01 // Clear Display

#define LCD_HOME                 0x02 // Cursor a Home

#define LCD_NORMAL               0x06 // Cursor en modo incrementar.

#define LCD_REV                  0x04 // Normal-reverse

#define LCD_SCROLL               0x07 // Usa scroll

#define LCD_SCROLL_REV           0x05 // Reverse

#define LCD_D8_BIT               0x38 // 8 bit 2 lineas ( 5x7 font )

#define LCD_D4_BIT_CONF          0x20 // 4 bit

#define LCD_D4_BIT               0x28 // 4 bit 2 lineas ( 5x7 font )

#define LCD_RESET                0x30 // Reset

#define LCD_DIS_ON               0x0C // Display on modo 2 lineas

#define LCD_DIS_OFF              0x08 // Display off

#define LCD_LINE1                0x80 // Linea 1 posicion 1

#define LCD_LINE2                0xC0 // Linea 2 posicion 1

#define LCD_CURSOR_ON            0x0E // Cursor on

#define LCD_CURSOR_OFF           0x0C // Cursor off

#define LCD_BLINK_ON             0x0F // Cursor blink

#define LCD_CURSOR_DER           0x14 // Mover cursor derecha

#define LCD_CURSOR_IZQ           0x10 // Mover cursor izquierda

#define LCD_DISPLAY__DER         0x1C // Scroll display derecha

#define LCD_DISPLAY__IZQ         0x18 // Scroll display izquierda

#define LCD_CHARMODE             0x01

#define LCD_COMMANDMODE          0x00



#include "delay.h"



void lcd_init (void);

void lcd_send( char mode, char dato );

void lcd_message ( char * mess );



void lcd_send_quartet( char mode, char dato );

void lcd_send( char mode, char dato );

void lcd_init (void);

void lcd_message ( char * mess );

char lcd_hexa(char a);



void lcd_showint(unsigned int value);
void lcd_showintright(unsigned int value, int index);

#endif


Código:
//-------------------------------------------------------------------------------------------------

// LCD.C

//

// Autor: Felixls

// Web: http://sergiols.blogspot.com

//

// Rutinas para el manejo de un display Hitachi 44780 compatible.

//-------------------------------------------------------------------------------------------------



#include <pic/pic16f877a.h>

#include "lcd.h"



void lcd_init (void);

void lcd_send( char mode, char dato );

void lcd_message ( char * mess );



void lcd_send_quartet( char mode, char dato )

{

    LCD_RS = mode;



    PORTB = dato  | (PORTB & 0x0f) ;



    LCD_ENABLE = 1;

    _asm                              // delay de 4µs

    nop

    nop

    nop

    nop

     _endasm;

    LCD_ENABLE = 0;



}

void lcd_send( char mode, char dato )

{

    unsigned int j;

    char dat = dato;



    LCD_RS = mode;



    dat = dato & 0xf0;

    PORTB = dat | (PORTB & 0x0f) ;



    LCD_ENABLE = 1;

    _asm                              // delay de 4µs

    nop

    nop

    nop

    nop

     _endasm;

    LCD_ENABLE = 0;



    dat = ((dato<<4)& 0xf0);

    PORTB = dat | (PORTB & 0x0f) ;



    LCD_ENABLE = 1;

    _asm                              // delay de 4µs

    nop

    nop

    nop

    nop

     _endasm;

    LCD_ENABLE = 0;



    for (j=0; j<30; j++)             // delay de 41µs

    {

       _asm

       nop

       _endasm;

    }

}





void lcd_init (void)

{

  LCD_DATA_TRIS &= 0x03;

//LCD_DATA = 0x00;



  delay_ms(15);



  lcd_send_quartet(LCD_COMMANDMODE, LCD_RESET);

  delay_ms(5);

  lcd_send_quartet(LCD_COMMANDMODE, LCD_RESET);

  delay_us(25);

  lcd_send_quartet(LCD_COMMANDMODE, LCD_RESET);

  delay_us(25);

  lcd_send_quartet(LCD_COMMANDMODE, LCD_D4_BIT_CONF);

  delay_us(25);



  lcd_send(LCD_COMMANDMODE, LCD_D4_BIT);

  delay_us(25);



  lcd_send(LCD_COMMANDMODE, LCD_CLEAR);

  delay_ms(2);

  lcd_send(LCD_COMMANDMODE, LCD_CURSOR_OFF);

  delay_ms(2);

  lcd_send(LCD_COMMANDMODE, LCD_NORMAL);

  delay_us(10);



  lcd_send(LCD_COMMANDMODE, LCD_DIS_ON);

  delay_us(10);

}



void lcd_message ( char * mess )

{

  while ( *mess )

  {

    lcd_send(LCD_CHARMODE, *mess ) ;

    mess++ ;

  }

}



char lcd_hexa(char a)

{

    if (a >9)

         a+=55;

    else

        a+=48;



    return a;

}


Memorias 24LC256
24xx256.h
Código:
#ifndef M24xx512_H

#define M24xx512_H


#include "i2c.h"

#define EEPROMS_ID 0xA0 /* Microchip 24xx256 */

unsigned char EEPROM_get(unsigned int addr);
void EEPROM_set(unsigned int addr, unsigned char val);


#endif

24xx256.c
Código:
#include "m24xx256.h"

unsigned char EEPROM_get(unsigned int addr)
{
unsigned char dat;

i2c_start();            /* Start i2c bus */

i2c_write(EEPROMS_ID);   /* Connect to EEPROM */
i2c_write(addr&0xF0); /* Request RAM address (Hight byte) */
i2c_write(addr&0x0F); /* Request RAM address (Low byte) */

i2c_start(); /* Start i2c bus */

i2c_write(EEPROMS_ID+1);/* Connect to EEPROM for Read */
dat = i2c_read(); /* Receive data */

i2c_noack();

i2c_stop(); /* Stop i2c bus */

   return dat;
}

void EEPROM_set(unsigned int addr, unsigned char val)
{
i2c_start();

i2c_write(EEPROMS_ID);   /* Connect to EEPROM */
i2c_write(addr&0xF0); /* Request RAM address (Hight byte) */
i2c_write(addr&0x0F); /* Request RAM address (Low byte) */

i2c_write(val); /* Write sec on RAM specified address */

i2c_stop();           /* Stop i2c bus */
}

« Última modificación: Diciembre 03, 2009, 04:19:00 por Felixls » En línea
Felixls
Moderador
PIC24F
******
Desconectado Desconectado

Sexo: Masculino
Mensajes: 3124



WWW
« Respuesta #1 : Septiembre 10, 2009, 02:27:29 »

Puerto serie
serie.h
Código:
#ifndef SERIE_H

#define SERIE_H



#define TEMPS 1000



void init_serie(void);

void putchar(char);

void puthex(char);

void puth(char);

void putint(int);

void print(char*);

char getchar(void);

char lirecar(void);

char leccar(void);

void print_uint(unsigned int value);


#endif


serie.c
Código:
/* Test to get Serial working.

   This version is to use hardware UART.  */

// This program is free software; you can redistribute it and/or modify

//   it under the terms of the GNU General Public License as published by

//   the Free Software Foundation; either version 2 of the License, or

//   (at your option) any later version.

//

//   This program is distributed in the hope that it will be useful,

//   but WITHOUT ANY WARRANTY; without even the implied warranty of

//   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

//   GNU General Public License for more details.

//

//   You should have received a copy of the GNU General Public License

//   along with this program; if not, write to the Free Software

//   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA



#include <pic/pic16f877a.h>

#include "delay.h"

#include "serie.h"


// Configuré pour:  9600 Bauds 8 bits sans parité 1bit de stop

void init_serie(void)

{

  // Configuration UARTtransmission serie

// SPBRG - Baud Rate Generator Register



// SPBRG = 25; // 4MHz => 9600 baud (BRGH = 1)

SPBRG = 129; // 20MHz => 9600 baud (BRGH = 1)



// BRGH - High Baud Rate Select Bit

BRGH = 1; // (1 = high speed)

// SYNC - USART Mode select Bit

SYNC = 0; // (0 = asynchrone)

// TRISC - Tri-state Data Direction Register for port C

// RC6 - 6eme broche du port C - utilise pour Transmission serie

// RC7 - 7eme broche du port C - utilise pour Reception serie

TRISC6 = 0; // 0 = broche en sortie)

TRISC7 = 1; // 1 = broche en entree)

// SPEN - Serial Port Enable Bit

  SPEN = 1; // 1 = l port serie valide

// TXIE - USART Transmit Interupt Enable Bit

TXIE = 0; // 1 = interruption transmission valide

// RCIE - USART Receive Interupt Enable Bit

RCIE = 0; // 1 = interruption reception valide

// TX9 - 9-bit Transmit Enable Bit

TX9 = 0; // 0 = 8-bit transmis)

// RX9 - 9-bit Receive Enable Bit

RX9 = 0; // 0 = 8-bit reception)

// CREN - Continuous Receive Enable Bit

CREN = 1; // 1 = reception valide

// TXEN - Transmit Enable Bit

TXEN = 1; // (1 = transmission valide

}



// *******************EMISSION

void putchar(char c)

{

  // envía una serie de caracteres en el enlace

while(!TXIF); //TXIF=1=> TXREG vide

TXREG = c;// Char TXREG en el lugar - se inicia la transmisión

}



//mostrar una cadena

void print(char *t)

{

  // texto completo de la atención / 0

  while (*t)

  {

    putchar(*t); // Data to transmit

    t++;

  }

}



void puthex(char nb)

{

  // un byte se convierte en 2 caracteres ASCII

  char n;

  n=(nb>>4)&0x0f;

  puth(n);

  n=nb&0x0f;

  puth(n);

}



void puth(char a)

{

  // convierte un medio de bytes en caracteres ASCII 1

  if (a >9)

    a+=55;

  else

    a+=48;

  putchar(a);

}



void putint(int num)

{

  // convierte un entero (16 bits) en 4 caracteres ASCII

  puthex(num>>8);

  puthex(num & 0xff);

}



// ************************RECEPTION

char getchar(void)

{

  char a=0;

  while (!a)

    a=leccar();//expectativa de que el pleno RCREG

  return a;

}



char lirecar(void)

{

  // variante de la no definición de tiempo de bloqueo getchar

  int compt=0;

  char a=0;

  while ((!a) && (compt!=TEMPS))

  {

    //Espera RCREG carácter completo o no después de la ruptura

    compt++;

    a=leccar();

  }

  return a;

}



char leccar(void)

 {

   //lee un carácter si se dispone otra cosa devuelve 0

  if (OERR)

  {

    //error de recepción

CREN=0; //se pone a 0 de CREN

CREN =1; //reactivation de la réception CREN=1

}

  if (RCIF)

    return RCREG;// carácter recibido

  else

    return 0;

}



char geth(void)

{

  char hex;

hex=getchar();



if ((hex>0x29) && (hex<0x3a))

    hex =hex & 0x0f;

else

  {

if (((hex>0x40) && (hex<0x47))||((hex>0x60) && (hex<0x67)))

      hex=(hex+0x09) &0x0f;

else

      hex =0xff;

}

return hex;

}



char gethex(void)

{

  char hex;

  hex=geth()<<4;

  hex|=geth();

  return hex;

}



char getd(void)

{

  char dec;

dec=getchar();

if ((dec>0x29) && (dec<0x3a))

    dec&= 0x0f;

else

    dec =0xff;

return dec;

}



Varias
utilities.h
Código:
#ifndef UTILITIES_H
#define UTILITIES_H

char *padr(char *d, char *s, int c);
int strlen (char * str);
char * strcpy (
char * d,
char * s);

void uitoa(unsigned int value, char* string, int radix);

void itoa(int value, char* string, int radix);

#endif

utilities.c
Código:
#include "utilities.h"

char *padr(char *d, char *s, int c)
{
  register char * d1 = d;
  register int i;
 
  i = c - strlen(s);
 
  while (i)
  {
    *d1++ = 32;
    i--;
  }
 
  strcpy(d1, s);
 
  return d;
}

int strlen (char * str)
{
  register int i = 0 ;

    while (*str++)i++;

  return i;
}

char * strcpy (
char * d,
char * s)
{
    register char * d1 = d;

    while (*d1++ = *s++) ;

    return d;
}

/*-------------------------------------------------------------------------
 integer to string conversion

 Written by:   Bela Torok, 1999
               bela.torok@kssg.ch
 usage:

 uitoa(unsigned int value, char* string, int radix)
 itoa(int value, char* string, int radix)

 value  ->  Number to be converted
 string ->  Result
 radix  ->  Base of value (e.g.: 2 for binary, 10 for decimal, 16 for hex)
---------------------------------------------------------------------------*/

#define NUMBER_OF_DIGITS 16   /* space for NUMBER_OF_DIGITS + '\0' */

void uitoa(unsigned int value, char* string, int radix)
{
unsigned char index, i;

  index = NUMBER_OF_DIGITS;
  i = 0;

  do {
    string[--index] = '0' + (value % radix);
    if ( string[index] > '9') string[index] += 'A' - ':';   /* continue with A, B,.. */
    value /= radix;
  } while (value != 0);

  do {
    string[i++] = string[index++];
  } while ( index < NUMBER_OF_DIGITS );

  string[i] = 0; /* string terminator */
}

void itoa(int value, char* string, int radix)
{
  if (value < 0 && radix == 10) {
    *string++ = '-';
    uitoa(-value, string, radix);
  }
  else {
    uitoa(value, string, radix);
  }
}
En línea
mfpuente
PIC10F
*
Desconectado Desconectado

Sexo: Masculino
Mensajes: 62



WWW
« Respuesta #2 : Septiembre 10, 2009, 04:13:53 »

Muchas gracias!!, son de mucha utilidad!
En línea

Ariel
Global Moderator
dsPIC
***
Desconectado Desconectado

Sexo: Masculino
Mensajes: 10751



WWW
« Respuesta #3 : Septiembre 26, 2009, 05:55:27 »

Fantástico. Pero fantástico de verdad!!!!

¿No seria interesante hacer una lista de lo que se necesita, e ir armado en un hilo (o en el wiki) el código de las librerias que vamos desarrollando? La verdad es que esta muy bueno el compilador, pero esto es lo que le falta. Ejemplosy librerias.

Felicitaciones por la idea!
En línea

Si cualquier habilidad que aprende un niño será obsoleta antes de que la use, entonces, ¿qué es lo que tiene que aprender? La respuesta es obvia:
La única habilidad competitiva a largo plazo es la habilidad para aprender
“. Seymour Papert
Ariel
Global Moderator
dsPIC
***
Desconectado Desconectado

Sexo: Masculino
Mensajes: 10751



WWW
« Respuesta #4 : Septiembre 26, 2009, 06:42:29 »

Hola Felixls!

Una duda (aclarando que de ASM no tengo ni sospechas)....cuando haces:

  LCD_ENABLE = 1;
    _asm                              // delay de 4µs
    nop
    nop
    nop
    nop
     _endasm;
    LCD_ENABLE = 0;


y usas un cristal de 20 MHz o un PIC18F4550 a más velocidad (en realidad, a cualquier velocidad que no sean 4MHz), la duracion del delay se acorta.....y mucho. Es posible que el LCD no se inicie bien o que no responda correctamente a los comandos, no te parece?

Habria que hacer algo mas complejo pero mas "hardware independiente".  rolleyes

El tema es que tiene que ser en ASM, o usar algun #IF, por que en C cualquier cosa que hagamos el tiempo va a ser mayor que 4 nops .......  Grin
En línea

Si cualquier habilidad que aprende un niño será obsoleta antes de que la use, entonces, ¿qué es lo que tiene que aprender? La respuesta es obvia:
La única habilidad competitiva a largo plazo es la habilidad para aprender
“. Seymour Papert
Felixls
Moderador
PIC24F
******
Desconectado Desconectado

Sexo: Masculino
Mensajes: 3124



WWW
« Respuesta #5 : Septiembre 26, 2009, 08:32:00 »

Hola Felixls!

Una duda (aclarando que de ASM no tengo ni sospechas)....cuando haces:

  LCD_ENABLE = 1;
    _asm                              // delay de 4µs
    nop
    nop
    nop
    nop
     _endasm;
    LCD_ENABLE = 0;


y usas un cristal de 20 MHz o un PIC18F4550 a más velocidad (en realidad, a cualquier velocidad que no sean 4MHz), la duracion del delay se acorta.....y mucho. Es posible que el LCD no se inicie bien o que no responda correctamente a los comandos, no te parece?

Habria que hacer algo mas complejo pero mas "hardware independiente".  rolleyes

El tema es que tiene que ser en ASM, o usar algun #IF, por que en C cualquier cosa que hagamos el tiempo va a ser mayor que 4 nops .......  Grin
La teoría dice que 4 nops con un micro a 20mhz  duran menos, pero, esos tiempos según mis pruebas funcionan bien con un cristal de 4mhz y con uno de 20mhz (de hecho este código es parte del cargador de baterías que funciona con un 16f877 a 20mhz).

Deberíamos pensar en algo más configurable aunque no se me ocurre por ahora como....
En línea
Suky
**----- ^^ ------**
Moderador
dsPIC
******
Desconectado Desconectado

Sexo: Masculino
Mensajes: 5442


Con Qt...


WWW
« Respuesta #6 : Septiembre 26, 2009, 09:50:59 »

Si  no recuerdo mal en el datasheet del LCD indica un pulso de enable mayor a 500ns, y por ejemplo en el código mostrado a 20MHz el Pin Enable esta en 1 aprox. 1us.


Saludos!
En línea

el_vpi
Moderador
PIC18F
******
Desconectado Desconectado

Mensajes: 1344



« Respuesta #7 : Septiembre 26, 2009, 10:01:35 »

Felixls, espectacular  rolleyes2 creo que es lo que estaba faltando como para poder empezar a mudarnos al SDCC.
Me quedo una duda en la libreria de la memoria cuando pones:

   i2c_write(addr&0xF0);    /* Request RAM address (Hight byte) */
   i2c_write(addr&0x0F);    /* Request RAM address (Low byte) */

es como que quitas los 4 bits de arriba o de abajo pero siempre del LSByte

si haces (*(&addr)) para el low address (byte menos sig)
si haces (*(&addr+1)) para el high address (byte mas sig)

creo que andaria, no ?
En línea
mentes
PIC10F
*
Desconectado Desconectado

Mensajes: 1


« Respuesta #8 : Septiembre 30, 2010, 04:47:52 »

Hola, ¿Podría alguien poner ejemplos del uso de las librerías?

Estoy intentando utilizar la de LCD, y he conseguido después de unos cuantos intentos inicializarlo a 4 bit y sin RW, pero no consigo escribir. Por si tuviera algo que ver, estoy utilizando un 16F84A.

He probado cosas como esta, pero escribe de todo menos "Hola".

Código:
void main() {

char *m_ptr = "Hola";

lcd_init();

        lcd_message(m_ptr);
}
« Última modificación: Septiembre 30, 2010, 04:57:17 por mentes » En línea
Páginas: [1]   Ir Arriba
  Imprimir  
 
Ir a:  

Impulsado por MySQL Impulsado por PHP Powered by SMF 1.1.21 | SMF © 2011, Simple Machines
SMFAds for Free Forums
XHTML 1.0 válido! CSS válido!
Página creada en 0.049 segundos con 26 consultas. (Pretty URLs adds 0.008s, 2q)