Hacer un barra de dezplanzamiento con una LCD

[Meta]

hola:

¿Alguien ha hecho esto alguna vez? A ver si alguien pone un ejemplo cómo se crea una barra de desplazamiento en un enseñan de entrada analógica con un 16F876 o similar. Con un 16F84A no se si se podrá hacer eso.

Hice uno con un autómata y un panel táctil, pero con un pic...

[Azicuetano]

Hola Meta!

Actualizaré un viejo post que tenía para que puedas ver como se pueden cargar caracteres en un LCD y como se pueden conseguir efectos curiosos 

-------------------------------------------------------------------------------------------------------

Que tal?

Lo prometido es deuda dicen por ahí, osea que, toma esto.

Código: [Seleccionar]

/////////////////////////////////////////////////////////////////////////
////                                                                 ////
////                        Azicuetano                               ////
////                                                                 ////
/////////////////////////////////////////////////////////////////////////

// AQUI VAN LOS INCLUDES !!!

#include <18F2550.h>
#include "flex_lcd.c"

#fuses XT,NOWDT,NOPROTECT,BROWNOUT,PUT,NOLVP, NOPBADEN
#use delay(clock=4000000)

// AQUI VAN LOS DEFINES !!!

#define  use_portb_lcd  TRUE
#DEFINE  UP             1
#DEFINE  DOWN           2
#DEFINE  MENU           3
#DEFINE  NO_PULSADA     4

// AQUI VAN LAS VARIABLES GLOBALES !!!

int      tecla_pulsada=NO_PULSADA;

// AQUI VAN LAS DECLARACIONES DE LAS FUNCIONES !!!

int   detecta_tecla(void);
void  cargar_caracter(void);

void cargar_caracter(void)
{
   int   n=0, indice=0;
  
   char   caracter_A[8] = {  0b11000000,
                             0b11000100,
                             0b11001010,
                             0b11010001,
                             0b11010001,
                             0b11011111,
                             0b11010001,
                             0b11010001};

   char   caracter_z[8] = {  0b11000000,
                             0b11000000,
                             0b11000000,
                             0b11011111,
                             0b11000010,
                             0b11000100,
                             0b11001000,
                             0b11011111};

   char   caracter_i[8] = {  0b11000000,
                             0b11000100,
                             0b11000000,
                             0b11001100,
                             0b11000100,
                             0b11000100,
                             0b11000100,
                             0b11001110};

   char   caracter_c[8] = {  0b11000000,
                             0b11000000,
                             0b11000000,
                             0b11001111,
                             0b11010000,
                             0b11010000,
                             0b11010000,
                             0b11001111};

   char   caracter_u[8] = {  0b11000000,
                             0b11000000,
                             0b11000000,
                             0b11010001,
                             0b11010001,
                             0b11010001,
                             0b11010001,
                             0b11001110};

   char   caracter_e[8] = {  0b11000000,
                             0b11000000,
                             0b11000000,
                             0b11001110,
                             0b11010001,
                             0b11011111,
                             0b11010000,
                             0b11001111};
 
   lcd_send_byte(0,0x40);                    // Enviamos esto para que nos empiece a
                                             // escribir en la primera dirección de la CGRAM
                                             // del display.

   printf(lcd_putc,"%c", caracter_A[0]);     // Caracter 1
   printf(lcd_putc,"%c", caracter_A[1]);
   printf(lcd_putc,"%c", caracter_A[2]);
   printf(lcd_putc,"%c", caracter_A[3]);
   printf(lcd_putc,"%c", caracter_A[4]);
   printf(lcd_putc,"%c", caracter_A[5]);
   printf(lcd_putc,"%c", caracter_A[6]);
   printf(lcd_putc,"%c", caracter_A[7]);

   printf(lcd_putc,"%c", caracter_z[0]);     // Caracter 2
   printf(lcd_putc,"%c", caracter_z[1]);
   printf(lcd_putc,"%c", caracter_z[2]);
   printf(lcd_putc,"%c", caracter_z[3]);
   printf(lcd_putc,"%c", caracter_z[4]);
   printf(lcd_putc,"%c", caracter_z[5]);
   printf(lcd_putc,"%c", caracter_z[6]);
   printf(lcd_putc,"%c", caracter_z[7]);

   printf(lcd_putc,"%c", caracter_i[0]);     // Caracter 3
   printf(lcd_putc,"%c", caracter_i[1]);
   printf(lcd_putc,"%c", caracter_i[2]);
   printf(lcd_putc,"%c", caracter_i[3]);
   printf(lcd_putc,"%c", caracter_i[4]);
   printf(lcd_putc,"%c", caracter_i[5]);
   printf(lcd_putc,"%c", caracter_i[6]);
   printf(lcd_putc,"%c", caracter_i[7]);

   printf(lcd_putc,"%c", caracter_c[0]);     // Caracter 4
   printf(lcd_putc,"%c", caracter_c[1]);
   printf(lcd_putc,"%c", caracter_c[2]);
   printf(lcd_putc,"%c", caracter_c[3]);
   printf(lcd_putc,"%c", caracter_c[4]);
   printf(lcd_putc,"%c", caracter_c[5]);
   printf(lcd_putc,"%c", caracter_c[6]);
   printf(lcd_putc,"%c", caracter_c[7]);

   printf(lcd_putc,"%c", caracter_u[0]);     // Caracter 5
   printf(lcd_putc,"%c", caracter_u[1]);
   printf(lcd_putc,"%c", caracter_u[2]);
   printf(lcd_putc,"%c", caracter_u[3]);
   printf(lcd_putc,"%c", caracter_u[4]);
   printf(lcd_putc,"%c", caracter_u[5]);
   printf(lcd_putc,"%c", caracter_u[6]);
   printf(lcd_putc,"%c", caracter_u[7]);

   printf(lcd_putc,"%c", caracter_e[0]);     // Caracter 6
   printf(lcd_putc,"%c", caracter_e[1]);
   printf(lcd_putc,"%c", caracter_e[2]);
   printf(lcd_putc,"%c", caracter_e[3]);
   printf(lcd_putc,"%c", caracter_e[4]);
   printf(lcd_putc,"%c", caracter_e[5]);
   printf(lcd_putc,"%c", caracter_e[6]);
   printf(lcd_putc,"%c", caracter_e[7]);  
}


//##############################################################################
//#
//#   Función encargada de detectar la tecla pulsada.
//#
//#   Nos devolverá:
//#
//#   TECLA_UP    -> SI PULSAMOS LA TECLA SUPERIOR
//#   TECLA_MENU  -> SI PULSAMOS LA TECLA CENTRAL
//#   TECLA_DOWN  -> SI PULSAMOS LA TECLA INFERIOR
//#
//##############################################################################

int detecta_tecla(void)
{
   if(input(PIN_A5)==0)
   {
      delay_ms(30);
      tecla_pulsada=DOWN;
      return(tecla_pulsada);
   }

   if(input(PIN_A3)==0)
   {
      delay_ms(30);
      tecla_pulsada=UP;
      return(tecla_pulsada);
   }

   if(input(PIN_A4)==0)
   {
      delay_ms(30);
      tecla_pulsada=MENU;
      return(tecla_pulsada);
   }

   tecla_pulsada=NO_PULSADA;
   return(tecla_pulsada);
}

/////////////////////////////////////////////////////////////////////////////
//
//    MAIN: PROGRAMA PRINCIPAL
//
/////////////////////////////////////////////////////////////////////////////

void main(void)
{
   set_tris_a(0b11111111);
   set_tris_b(0b00000000);

   port_b_pullups(FALSE);

   lcd_init();                               //inicializa lcd
   delay_ms(50);

   printf(lcd_putc,"\f FORO TODOPIC ;)");    //muestra por pantalla el mensaje
   delay_ms(2000);
  
   tecla_pulsada=detecta_tecla();
  
   cargar_caracter();

   printf(lcd_putc,"\f->");
  
   while(1)
  {
      tecla_pulsada=detecta_tecla();

      if(tecla_pulsada==MENU)
      {
         delay_ms(50);
         printf(lcd_putc," ");
         lcd_gotoxy(0,1);
         printf(lcd_putc,"     %c%c%c%c%c%c",0,1,2,3,4,5);
      }
   }
}


Si tienes alguna duda pregunta que te responderé encantado. Con un poco de imaginación se pueden hacer cosas tan chulas como esta (como mi camara es una chufa se ve muy mal, pero, en realidad el efecto es muy nítido):

Un saludo desde Alicante.

[Meta]

¿No será tuyo ese display? Pues la verdad que si se consigue efectos increíbles, más lo que he visto por ahí, este sorprende que controlas hasta la velocidad de desplazamiento. Por lo que veo sólo utilizan PIC18F2550, y los 16F84A y 16F876, ¿no sirven para hacer eso?

Gracias por el código, lo guardo, pero hay un pero. Sólo se hacer las cosas en asm ya que este libro que tengo no enseña otro lenguaje. ¿es muy difícil de hacer el mismo resultado?

[Cryn]

claro que uno de esos micros que mencionas sirven para tu proposito, las unicas desventajas del 84 es la cantidad de pines que puede ser desventajoso para algunos proyectos, y lo peor de ese micro es su memoria de programa que es muy poca (en si este micro tiene muy pocos modulos internamente, solo tienen un timer por citar algo, no tiene USART, tampoco tiene conversor A/D, por lo cual no se podria usar para un proyecto como este que mencionas, etc), el 876 va mejor en pines y en memoria ademas que si no em equivoco este si tiene conversor A/D, pero siempre dependerá del tipo de proyecto, osea pines a usar y tamaño del programa que te saldra, etc.

todo microcontrolador es bueno pero a la hora de decidir sobre algo mas serio (digamos un trabajo grande, con muchos perifericos, y muchas rutinas en tu programa), seguramente necesitaras un micro mas potente como el 18f2550 u otro con algunas caracteristicas especiales (usb digamos, que lo tiene este 2550, A/D o alguna otra)

Para comenzar tus micros te sirven, hacer unas pruebas y talvez mas, y ya veras si cambias por uno de mas memoria u otra cosa; para ver mejores datos de qeu tiene un micro, memoria, timers, ccp,eeprom,etc, puedes ver en la pag de microchip o buscar sus hojas de datos tb en la pag de microchip.

espero haberte ayudado con eso, y si no se entendio, pues solo le hechas la escritura
un saludo

[Meta]

Muy bien explicado, gracias.

De momento aprendo con el 16F84A ya que tengo este libro y hay más información y ejemplos. Eso si, todo en asm.

El 18F2550 parece que es un poco farragozo programarlo en asm que es el único lenguaje que se usar para programar micros. He visto las estadísticas y es muy amplio, tiene 4 reloj frente 1 del 16F84A. ¿Tantos hace falta?

Bueno, buen detalles en tus explicaciones.

En 16F84A está claro que está limitado, ya que si quiero 16 salidas directamente de un PIC, pues a este tendría que poner un IC codificador de 4 entradas y 8 salidas a mi gusto.

[Nocturno]

Si te sirve de algo, también hice algún efecto con un LCD. En este caso con un dsPIC y C30.

Lo puedes ver aquí: Quadrature Encoder Interface

[Meta]

Muy curioso, parece complicado de hacer. Gracias.

[Azicuetano]

Hola Meta.

Con cualquier micro puedes hacer este efecto. No necesitas que el micro tenga mucha velocidad ni nada de nada. Lo único que tenemos que hacer es ir grabando los caracteres que queremos representar en la memoria del display y acto seguido pintarlos en la pantalla.

Sobre como hacerlo en asm no te puedo decir mucho (hace ya tiempo que me pasé al C) pero me suena que he visto en el foro programillas hechos en asm y que también cargaban caracteres en la memoria de los displays.

Si utilizas el buscador no creo que tengas muchos problemas en encontrarlos.

Si te sirve de algo, también hice algún efecto con un LCD. En este caso con un dsPIC y C30.

Se te quedó muy bien 


Un saludo desde Alicante.

[Meta]

Menos mal. Ahora estoy más tranquilo.

mmmmmmmm, yo aprendiendo asm a lo bestia y la gente con C. Se nota que se trabaja más rápido con el C.

A ver si algún día implantan el C# que me gusta más...

[reiniertl]

Creo que tendrás que morder el C puro, porque eso de la Programación Orientada a Objetos no es algo para este pequeño mundo. Pero el C no duele, de hecho el ASM para uC RISC sí que es muy doloroso. Todo ello sin mencionar el problema de la portabilidad de código y otros factores que con C te permitirán moverte de una plataforma de micros a otra sin mucha tragedia.

Así que no te asustes con lo del C, pásate ahora que estás comenzando, que en el foro hay bastante para aprender al respecto y literatura también aparece bastante.

Saludos
Reinier

[Cryn]

claro que con un 16f84a puedes manejar un lcd, pero ojo que este micro no tiene conversor A/D (y creo que en la imagen y en la descripcion de menta se ve un dispositivo analogico), claro que con un 16f84a puedes desplegar palabras, hacer esos efectos, creandote caracteres, un LCD Hitachi si no me equivoco acepta hasta 8 caracteres diseñados por ti, y bueno muchas otras cosas mas, pero considerar los modulos qeu tienen el micro para talvez utilizar integrados externos para adaptar ciertos componentes, como un A/D por ejemplo (tendrias q utilizar un conversor externo, y pasarlo al micro)

aca algo para comenzar: http://www.todopic.com.ar/foros/index.php?topic=14552.0
tb hay un poco sobre ensamblador

y si qeuires mas seguro qeu con el buscador encuentras algo mas

un saludo