Ejemplitos en C para 16F648A

[jeremylf]

Se que esto esta dedicado a los 16F648A pero si te sirve de algo hice algo con el DS1307 usando un PIC18F2550 q spongo puede ser facilmente adaptado al otro PIC.

Driver DS1307:

////////////////////////////////////////////////////////////////////////////////
///                               DS1307.C                                   ///
///                     Driver for Real Time Clock                           ///
///                                                                          ///
/// ds1307_init() - Enable oscillator without clearing the seconds register -///
///                 used when PIC loses power and DS1307 run from 3V BAT     ///
///               - Disable squarewave output                                ///
///                                                                          ///
/// ds1307_set_date_time(day,mth,year,dow,hour,min,sec)  Set the date/time   ///
///                                                                          ///
/// ds1307_get_date(day,mth,year,dow)               Get the date             ///
///                                                                          ///
/// ds1307_get_time(hr,min,sec)                     Get the time             ///
///                                                                          ///
////////////////////////////////////////////////////////////////////////////////

#ifndef RTC_SDA
   #define RTC_SDA  PIN_C1 //4
   #define RTC_SCL  PIN_C0 //3
#endif

#use i2c(master, sda=RTC_SDA, scl=RTC_SCL)

BYTE bin2bcd(BYTE binary_value);
BYTE bcd2bin(BYTE bcd_value);

void ds1307_init(void)
{
   BYTE seconds = 0;

   i2c_start();
   i2c_write(0xD0);      // WR to RTC
   i2c_write(0x00);      // REG 0
   i2c_start();
   i2c_write(0xD1);      // RD from RTC
   seconds = bcd2bin(i2c_read(0)); // Read current "seconds" in DS1307
   i2c_stop();
   seconds &= 0x7F;

   delay_us(3);

   i2c_start();
   i2c_write(0xD0);      // WR to RTC
   i2c_write(0x00);      // REG 0
   i2c_write(bin2bcd(seconds));     // Start oscillator with current "seconds value
   i2c_start();
   i2c_write(0xD0);      // WR to RTC
   i2c_write(0x07);      // Control Register
   i2c_write(0x80);     // Disable squarewave output pin
   i2c_stop();

}

void ds1307_set_date_time(BYTE day, BYTE mth, BYTE year, BYTE dow, BYTE hr, BYTE min, BYTE sec)
{
  sec &= 0x7F;
  hr &= 0x3F;

  i2c_start();
  i2c_write(0xD0);            // I2C write address
  i2c_write(0x00);            // Start at REG 0 - Seconds
  i2c_write(bin2bcd(sec));      // REG 0
  i2c_write(bin2bcd(min));      // REG 1
  i2c_write(bin2bcd(hr));      // REG 2
  i2c_write(bin2bcd(dow));      // REG 3
  i2c_write(bin2bcd(day));      // REG 4
  i2c_write(bin2bcd(mth));      // REG 5
  i2c_write(bin2bcd(year));      // REG 6
  i2c_write(0x80);            // REG 7 - Disable squarewave output pin
  i2c_stop();
}

void ds1307_get_date(BYTE &day, BYTE &mth, BYTE &year, BYTE &dow)
{
  i2c_start();
  i2c_write(0xD0);
  i2c_write(0x03);            // Start at REG 3 - Day of week
  i2c_start();
  i2c_write(0xD1);
  dow  = bcd2bin(i2c_read() & 0x7f);   // REG 3
  day  = bcd2bin(i2c_read() & 0x3f);   // REG 4
  mth  = bcd2bin(i2c_read() & 0x1f);   // REG 5
  year = bcd2bin(i2c_read(0));            // REG 6
  i2c_stop();
}

void ds1307_get_time(BYTE &hr, BYTE &min, BYTE &sec)
{
  i2c_start();
  i2c_write(0xD0);
  i2c_write(0x00);            // Start at REG 0 - Seconds
  i2c_start();
  i2c_write(0xD1);
  sec = bcd2bin(i2c_read() & 0x7f);
  min = bcd2bin(i2c_read() & 0x7f);
  hr  = bcd2bin(i2c_read(0) & 0x3f);
  i2c_stop();

}

BYTE bin2bcd(BYTE binary_value)
{
  BYTE temp;
  BYTE retval;

  temp = binary_value;
  retval = 0;

  while(1)
  {
    // Get the tens digit by doing multiple subtraction
    // of 10 from the binary value.
    if(temp >= 10)
    {
      temp -= 10;
      retval += 0x10;
    }
    else // Get the ones digit by adding the remainder.
    {
      retval += temp;
      break;
    }
  }

  return(retval);
}


// Input range - 00 to 99.
BYTE bcd2bin(BYTE bcd_value)
{
  BYTE temp;

  temp = bcd_value;
  // Shifting upper digit right by 1 is same as multiplying by 8.
  temp >>= 1;
  // Isolate the bits for the upper digit.
  temp &= 0x78;

  // Now return: (Tens * + (Tens * 2) + Ones

  return(temp + (temp >> 2) + (bcd_value & 0x0f));
}

Programa en C:

#include <18F2550.h>
#fuses HS,MCLR,NOWDT,NOPROTECT,NOPUT,NOBROWNOUT,NOPBADEN,NOLVP,NOCPD,NODEBUG,NOWRT,NOVREGEN
#use delay(clock=12000000)
#use rs232(baud=9600, xmit=PIN_C6, rcv=PIN_C7)

//Antes de incluir la libreria del ds1307, tiens q poner q pines vas a usar para la conexionde este al pic (VIA I2C):
#define RTC_SDA  PIN_C1
#define RTC_SCL  PIN_C0

//Ahora si lo incluyes:
#include <ds1307.c>
 
//Variables necesarias para el ds1307, almacenamiento de lo q cojes.
  BYTE sec;
  BYTE min;
  BYTE hrs;
  BYTE day;
  BYTE month;
  BYTE yr;
  BYTE dow;

void main()
{   
  ds1307_init();     //inicializo ds1307.

  ds1307_set_date_time(15,6,5,2,15,20,55);     //fija dia, mes, año, dow, hora, minutosy segundos como quiera.
 
  while(1)
  {
    delay_ms(1000);    //Espero CASI un segundo.

    ds1307_get_date(day,month,yr,dow);    //Cojo dia, mes, año y dia de la semana actuales y los almaceno en esas variables.
    ds1307_get_time(hrs,min,sec);                  //Lo mismo pero cogiendo las horas, minutos y segundos.
     
    printf("\f\%02d/\%02d/\%02d\r\n",day,month,yr);    //lo mando al rs232.
    printf("\%02d:\%02d:\%02d", hrs,min,sec);
  }
}

La compatibilizacion sera solo cambiando el Include y los fusibles me supongo y claro el cristal q uses. Ah y la definicion del pic q uses parala conexion I2C con el Ds1307 tb.

Espero te sirva.


Un saludo

PD: Lo del teclado ya ingeniatelas 

[vszener]

Buenas!!! El ejemplito número 33 es lo que tú deseas pero con un DS1302, pero vamos, el amigo jeremylf ha dejado la libreria para el dispositivo que quieres, no se te hará muy dificil la adaptación.


Suerte!!!

[aitopes]

//   Conexiones:      B0 -> E                     
//               B1 -> RS     
//               B4 -> D4       
//               B5 -> D5           
//               B6 -> D6   
//               B7 -> D7                 

Dos años mas tarde, un caido de la rama tiene una duda con ese código:

Estoy migrando algunos programas que tengo en BASIC (en realidad, reescribiendolos) a CCS, y me pasa por ejemplo, que la conexion del display LCD al puerto del PIC no respeta el orden establecido en LCD.C.

Concretamente: En lugar de

B0 -> E                     
B1 -> RS     
B4 -> D4       
B5 -> D5           
B6 -> D6   
B7 -> D7                 

yo tengo el hard (una placa que hice hace como 5 meses) conectado asi:

B2 -> E                     
B3 -> RS     
B4 -> D4       
B5 -> D5           
B6 -> D6   
B7 -> D7

¿Puedo indicarle esto al compilador sin modificar LCD.C ?

Gracias, y perdon por la preguntonta, pero he buscado largo rato por el foro y no he encontrado la respuesta.

Saludos!

[aitopes]

Hola otra vez!

Creo que no se puede. Pero encontre el foro de CCS, en ingles, y ahi hay un hilo muy interesante sobre LCD.

http://www.ccsinfo.com/forum/viewtopic.php?t=24661

Ahi van a encontrar esta libreria:

Flexible driver for a 16x2 LCD:
This is an adaptation of the CCS LCD driver. This isn't intended to replace the CCS driver or Mark's driver. It's just another option
that I decided to put out there.

Advantages:
1. This driver allows you to simply specify the LCD pins at the top of the file. This would be useful if your board doesn't fit the CCS driver, and you don't want to spend the time to figure out how to modify the CCS driver.

2. You can put the LCD pins on several different ports. Also, the data bus pins don't have to be in numerical order or on the same port.


Disadvantages or Limitations:
1. This driver requires CCS "standard i/o" mode (The default mode of the compiler). If you want to use fast i/o mode, then use the CCS
driver or Mark's driver ( http://www.ccsinfo.com/forum/viewtopic.php?t=20182 )

2. This driver uses about 50% more ROM than the CCS driver. That's because it does individual pin i/o rather than byte-wide i/o,
and because it uses standard i/o mode.

Espero les sirva.

[MGLSOFT]

Tal cual, no se puede sin declarar los pines tal como los tenes vos...
Te pongo un ejemplo de la libreria que yo utilizo, con Tunning acorde a mi pinout, veras que uso pines de dos puertos diferentes, y no aumenta el codigo como dice el de la pagina de CCS...
Yo uso Standard_IO, proba de utilizarla con los otros modos a ver como va...

Código: [Seleccionar]

///////////////////////////////////////////////////////////////////////////
////                         LCD Controlador.C                         ////
////                 Driver para manejar el display LCD                ////
////                                                                   ////
////  lcd_init()   Debe ser llamada antes que ninguna funcion.         ////
////                                                                   ////
////  lcd_putc(c)  Escribe el caracter C en la proxima posicion        ////
////               de la linea actual del LCD.                         ////
////               Las siguientes son modificadores especiales:        ////
////                      \f  Borra el display                         ////
////                      \n  Va al principio de la segunda linea      ////
////                      \b  Se desplaza atras una posicion           ////
////                                                                   ////
////  lcd_gotoxy(x,y) Elige la posicion a escribir en el display       ////
////                    LCD (arriba a la izquierda es 1,1)             ////
////                                                                   ////
////  lcd_getc(x,y)   Devuelve el caracteren la posicion x,y del LCD   ////
////                                                                   ////
////  desplazar_display(x,y) Mueve el contenido escrito en el display  ////
////                          la cantidad de espacios x, en el sentido ////
////                          indicado por y (0=Izquierda, 1=Derecha)  ////
////                                                                   ////
///////////////////////////////////////////////////////////////////////////


// Las dos siguientes estructuras estan dirigidas a poder usar el display en:
//     A0  rs
//     A1  enable
//     A2  rw        hasta aqui es la estructura de los comandos

struct lcd_pin_map_a
{
   BOOLEAN rs;
   BOOLEAN enable;
   BOOLEAN rw;
   BOOLEAN Latch;
   BOOLEAN ShiftIn;
   BOOLEAN ClockIn;
} lcd_Command;

//     B2  D4
//     B3  D5
//     B4  D6
//     B5  D7        y aqui es la de datos, lineas que son entradas o salidas.

struct lcd_pin_map_b
{
   BOOLEAN ClockOut;
   BOOLEAN ShiftOut;
   int     data : 4;
   BOOLEAN Unused;
   BOOLEAN Unused2;
} lcd_Data;


// esto situa la estructura entera
#if defined(__PCH__)                //Si es un PIC18
   #byte lcd_Data = 0xF81                 // en port B (direccion 0xF81)
   #byte lcd_Command = 0xF80              // en port A (direccion 0xF80)
#else                               //Si es un PIC16
   #byte lcd_Data = 6                     // en port B (direccion 6)
   #byte lcd_Command = 5                  // en port A (direccion 5)
#endif

   #define set_tris_lcd_Data(x) set_tris_b(x)

   #define set_tris_lcd_Command(x) set_tris_a(x)

   #define Izquierda 0
   #define Derecha   1

   #define lcd_type 2           // 0=5x7, 1=5x10, 2=2 lines
   #define lcd_line_two 0x40    // Direccion LCD RAM de la segunda linea
   // Otras definiciones para usar en lcd_send_byte
   #define LCD_CLEAR  0x01
   #define LCD_HOME   0x02

   #define LCD_DISPLAY_OFF       0x08
   #define LCD_DISPLAY_ON        0x0C
   #define LCD_Caracter_BLINK    0x0D
   #define LCD_CURSOR_ON         0x0E
   #define LCD_CURSOR_BLINK      0x0F

   #define LCD_CURSOR_SHIFT_RIGHT  0x10
   #define LCD_CURSOR_SHIFT_LEFT   0x14
   #define LCD_DISPLAY_SHIFT_RIGHT 0x18
   #define LCD_DISPLAY_SHIFT_LEFT  0x1C

   BYTE const LCD_INIT_STRING[4]={0x20|(lcd_type<<2),LCD_DISPLAY_ON,LCD_CLEAR,6};
   // Esto es enviado al LCD para inicializarlo bien     //


   // Lo siguiente es usado para setear la direcion de los registros I/O.

   // Seteo del puerto A:
   struct lcd_pin_map_a const LCD_WRITE_a = {0,0,0,0,1,0}; // Para modo escritura todos
   //los bits deben ser salidas menos ShiftIn, que es entrada, por eso se pone en 1 .-

   // Seteo del puerto B:
   struct lcd_pin_map_b const LCD_WRITE_b = {0,0,0,0,0}; // Para modo escritura todos
   //los bits de datos deben ser salidas .-
   struct lcd_pin_map_b const LCD_READ_b = {0,0,15,0,0}; // Para modo lectura todos
   //los bits de datos deben ser entradas , por eso se ponen en 1 .-


/* aqui comienzan las funciones del display LCD */
//#separate
   BYTE lcd_read_byte()
   {
      BYTE low,high;
      set_tris_lcd_Data(LCD_READ_b);
      lcd_Command.rw = 1;
      delay_us(1);
      lcd_Command.enable = 1;
      delay_us(1);
      high = lcd_Data.data;
      lcd_Command.enable = 0;
      delay_us(1);
      lcd_Command.enable = 1;
      delay_us(1);
      low = lcd_Data.data;
      lcd_Command.enable = 0;
      set_tris_lcd_Data(LCD_WRITE_b);
      return( (high<<4) | low);
   }
//#separate
   void lcd_send_nibble( BYTE n )
   {
      lcd_Data.data = n;
      delay_us(1);
      lcd_Command.enable = 1;
      delay_us(1);
      lcd_Command.enable = 0;
   }

   void lcd_send_byte( BYTE address, BYTE n )
   {
      lcd_Command.rs = 0;
      //delay_us (600);//trabaja sin la siguiente linea...
      while ( bit_test(lcd_read_byte(),7) ) ;
      lcd_Command.rs = address;
      delay_us(1);
      lcd_Command.rw = 0;
      delay_us(1);
      lcd_Command.enable = 0;
      lcd_send_nibble(n >> 4);
      lcd_send_nibble(n & 0xf);
   }


   void lcd_init()
   {
      BYTE i;
      set_tris_lcd_Command(LCD_WRITE_a);
      set_tris_lcd_Data(LCD_WRITE_b);
      lcd_Command.rs = 0;
      lcd_Command.rw = 0;
      lcd_Command.enable = 0;
      delay_ms(50);
      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;
    // Solo permite el rango (1, 1) a (16, 2)
    if (x == 0 || x > 16 || y == 0 || y > 2)
        return;

      if(y!=1)
         address=lcd_line_two;
      else
         address=0;
      address+=x-1;
      //envia el comando de posicion del cursor
      lcd_send_byte(0,0x80|address);
   }

   void lcd_putc( char c)
   {
      switch (c) {
         case '\f'   : lcd_send_byte(0,LCD_CLEAR);
         delay_ms(2);
         break;
         case '\n'   : lcd_gotoxy(1,2);        break;
         case '\b'   : lcd_send_byte(0,LCD_CURSOR_SHIFT_RIGHT);  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) );
      // espera mientras el flag Busy esta en bajo
      lcd_Command.rs=1;
      value = lcd_read_byte();
      lcd_Command.rs=0;
      return(value);
   }

   void desplazar_display(int posiciones, boolean sentido)
   {
  // Primer parámetro: Numero de desplazamientos
// Segundo parámetro: Sentido del desplazamiento (TRUE=Derecha, FALSE=Izquierda)
      int i,aux;
      if (sentido) aux=LCD_DISPLAY_SHIFT_RIGHT;   // Desplazamiento a la derecha
      else  aux=LCD_DISPLAY_SHIFT_LEFT;

      for (i=1; i<=posiciones; i++)
      {
         lcd_send_byte(0,aux);
      }
   }
Ojo!! esta libreria utiliza el Pin R/W del display, adaptando las velocidades de funcionamiento segun la temperatura y velocidad de respuesta del LCD, es lo mas aconsejable...
Esta testeada a frecuencias de reloj desde 3,6864 Mhz hasta 20 Mhz, funciona con todas las frecuencias de reloj, el tunning anda OK!!!

[Nocturno]

Y si no lo consigues con la de Marcos, inténtalo con la Flex-LCD. Está publicada en alguna parte del foro y en la zona de descargas de mi página.

Si lo consigues con la de Marcos, indícalo, para que no se ponga celoso 

[RedPic]

Yo tengo disponible una versión de la Flex-LCD así como algún programa de ejemplo.

[aitopes]

Hola muchachos! (aunque algunos ya no son taaaaan muchachos... )

Gracias por toda la info. Anoche descubri la flex, y tambien estuve mirando lo que posteo MGLSOFT.
Ya habia metido mano a LCD.C para que me funcionara (me encanta lo rapido que le voy tomando la mano a esto), pero me parecia que iba a encontrar algo parecido al BASIC para no tener que "ajustar" LCD.C en cada proyecto (bueno...eso mas o menos es lo que hace flex..).

Por supuesto, esta "incomodidad" redunda en programas mas chicos. Por ejemplo, un secuenciador de luces programables que programe en BASIC y en CCS resulta mucho mas corto en CCS, es mas, si tengo que fabricar algun otro, podre usar un 16F627A en lugar de un 16F628A. No hay diferencia de $$$, pero si no consigo uno, puedo usar el otro sin problemas.

Lo del LCD esta finiquitado. Ahora voy a reconvertir mis rutinas BASIC para leer los sensores 1-wire. Vi que hay bibliotecas hechas en CCS, pero les tengo cariño a las mias por que las hice desde cero en BASIC.

Gracias por todo!
Me voy a prender fuego para el asadito....

[MGLSOFT]

Ya esta el asado???

[cerebro]

buenas...............como se aprende con estos ejemplitos!!!!!!   aca subo uno basado en el cartel que se mueve por un lcd pero viendo que la frase no pasaba a la segunda fila si no se completaba.......... lo modifique para pasar a la segunda fila mientras se mostraba por la primera como una marquesina(no es la gran cosa pero algo es algo)..... un saludo y vamos a seguir practicando para poder postear ejemplos mas copados... saludos

[RedPic]

Hola muchachos! (aunque algunos ya no son taaaaan muchachos... )

Eso no lo dirás por mi ¿verdad? Ja, ja, ja 

Muy bien Cerebro por tu aporte. Poco a poco entre todos hacemos grande este Foro. 

[cerebro]

hola maestros!! eeeeeeee surgio una consulta revisando el problemita de "Escribir & leer eeprom externa 24LC256 y mostrarla por lcd"
en cuanto a los fuses  colocaron #fuses HS.....(eso no es para un oscilador de alta velocidad? de 8 a 20 Mhz) y sin embargo utilizamos
un oscilador de 4 Mhz ...... nuevamente gracias  un abrazo. Esta pensando en postear algo relacionado al WDT estaria bueno o lo dejamos nomas?

[vszener]

Exacto, pero si te vas a la revisión de dicho programa, notarás que ya está solucionado con el fuse correcto en XT.

Con respecto al WDT, simplemente en cualquier programa de estos, ponerle la instrucción e ir refrescandolo cada cierto tiempo.


Suerte!!!

[cerebro]

holaaaa amigos del foro!  gran vszener gracias por responder la consulta ( aunque sea media tonta jejejejeje ) es que todavia soy muy novato...... bueno haber si se entiende lo que queria hacer con el WDT........ en el ejemplito que quiero compartir es el siguiente: mostramos por lcd la marquesina anterior pero la diferencia está en que cada vez que mostramos por lcd tiramos un numero al azar y con una probabilidad de que llegue a una condicion de error sin salida, entonces ahi desborda el WDT y resetea el micro para salir del cuelgue...... he aqui la cuestion problematica cada vez que se resetea el micro la fnc rand() y srand() tiran la misma secuencia (supongo que el reloj tmb se resetea y  de ahi saca las constantes para calcular los numeros al azar )..... probe mil y una maneras pero no logre resultados satisfactorios...... sera que dios no juega a los dados despues de todo jajajaja   un saludo  cerebro.
---falta mucho mucho para alcanzar el nivel de un ejemplo de vszener! 

[vszener]

Buenas!!! La función srand() es la semilla para generar los números aleatorios y ahí es donde creo que está la clave, no me acuerdo muy bien como iba la historia ya que hace tiempo que no lo uso, cuando vuelva a casa miro el manual del CCS y te contesto con más datos.


Suerte!!!