Autor Tema: tarejta servidora con teclado y LCD  (Leído 4331 veces)

0 Usuarios y 1 Visitante están viendo este tema.

Desconectado jdj

  • PIC10
  • *
  • Mensajes: 37
tarejta servidora con teclado y LCD
« en: 20 de Diciembre de 2004, 10:48:00 »
Hola a tod@s! Necesito ayuda urgente!!. Estoy realizando el proyecto de la regulación de ventilación de una granja.Ya había dejado mensajes en otros foros,y me pedían que controlara el regulador desde un PC, pero ahora me lo han pedido que aparte del regulador, diseñe una tarjeta servidora en la que pueda controlar los datos desde un teclado matricial 4x4 y que se visualicen en un LCD.
Pedía un poco de ayuda sobre la arquitectura de esa placa servidora y también sobre el programa en C que pueda hacer las siguientes funciones, a través del pic 16F873.Por ejemplo al pulsar el 1-> me aparezca la temperatura de la sala(que es controlada a través de un sensor).
Con el 2->temperatura de calefacción( otro sensor cerca de la placa de gorrines)
Con el 3-> Porcentaje as que está trabajando un ventilador.
Con el 4->Por ejemplo poder subir la temperatura de la sala, en grados, por lo tanto se cerrarán las ventanas de la sala, y si todavia no hace demasiado calor, se activa un sistema calefactor.
Con el 5-> Bajar la Tª de la sala, se abrirán ventanas y si es necesario se activarán unos ventiladores.
El regulador ya lo tengo diseñado, solo me falta esa tarjeta servidora con su programa correspondiente.La comunicación con el regulador será RS485, por lo tanto necesitaré colocar un Max485 en esa tarjeta servidora no??
Muchas gracias por su aportación, un saludo.

Desconectado jdj

  • PIC10
  • *
  • Mensajes: 37
RE: tarejta servidora con teclado y LCD
« Respuesta #1 en: 21 de Marzo de 2005, 04:40:00 »
Bueno ya tengo la tarjeta servidora diseñada.Solamente necesito ahora un programa en C que me controle lo pedido, a través del teclado matricial.me gustaría empezar por las librerias que tengo que utilizar para el LCD y el código en C para la cmunicación del teclado matricial y la LCD.
Muchas gracias
Saludos

Desconectado Nocturno

  • Administrador
  • DsPIC33
  • *******
  • Mensajes: 18310
    • MicroPIC
RE: tarejta servidora con teclado y LCD
« Respuesta #2 en: 21 de Marzo de 2005, 04:50:00 »
No dices qué compilador de C usarás, aunque supongo que estarás hablando de CCS.
En CCS tienes librerías tanto para teclado matricial (KBD.C) como para el LCD (LCD.C).
Incluso viene un sencillo ejemplo que usa ambas librerías, se llama EX_LCDKB.C

Lo pego a continuación:

Codigo:
/////////////////////////////////////////////////////////////////////////
////                           EX_LCDKB.C                            ////
////                                                                 ////
////  This program uses both the KBD.C and LCD.C drivers to allow    ////
////  keypad entry and LCD display.  All keys are echoed except *    ////
////  that will clear the display.  Either the kbd_getc or lcd_putc  ////
////  may be replaced with getc or putc to use just one device with  ////
////  the RS-232.                                                    ////
////                                                                 ////
////  Configure the CCS prototype card as follows:                   ////
////     Plug in both the LCD and KEYPAD.                            ////
////                                                                 ////
////  This example will work with the PCB, PCM and PCH compilers.    ////
////  The following conditional compilation lines are used to        ////
////  include a valid device for each compiler.  Change the device,  ////
////  clock and RS232 pins for your hardware if needed.              ////
/////////////////////////////////////////////////////////////////////////
////        (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.              ////
/////////////////////////////////////////////////////////////////////////


#if defined(__PCB__)
#include <16c56.h>
#fuses HS,NOWDT,NOPROTECT
#use delay(clock=20000000)

#elif defined(__PCM__)
#include <16F877.h>
#fuses HS,NOWDT,NOPROTECT,NOLVP
#use delay(clock=20000000)

#elif defined(__PCH__)
#include <18F452.h>
#fuses HS,NOWDT,NOPROTECT,NOLVP
#use delay(clock=20000000)
#endif

#include <lcd.c>
#include <kbd.c>


void main() {
   char k;

   lcd_init();
   kbd_init();

   lcd_putc("fReady...
");

   while (TRUE) {
      k=kbd_getc();
      if(k!=0)
        if(k=="*")
          lcd_putc("f");
        else
          lcd_putc(k);
   }
}

Desconectado jdj

  • PIC10
  • *
  • Mensajes: 37
RE: tarejta servidora con teclado y LCD
« Respuesta #3 en: 22 de Marzo de 2005, 03:36:00 »
Hola nocturno66!! En realidad solo me piden el código, no lo tendré que compilar ninada de eso.
Dónde puedo encontrar el LCD.C y el KBD.C?
A parte, con ese programilla que me has mandao tendría la comunicación entre ambos??entre el teclado y la LCD?
Muchas gracias por tu aportación, seguro que me será mas fácil hacer esto con alguien que entiende del tema. Seguro que me van saliendo más problemillas.......
Un saludo JORGE

Desconectado Nocturno

  • Administrador
  • DsPIC33
  • *******
  • Mensajes: 18310
    • MicroPIC
RE: tarejta servidora con teclado y LCD
« Respuesta #4 en: 22 de Marzo de 2005, 03:38:00 »
No te entiendo, ¿que te piden el código sin compilar?, ¿y cómo sabrás que funciona?.
Reconozco que soy un desastre, pero soy incapaz de programar tres líneas sin probar.

Los dos ficheros que mencionas vienen incluidos cuando instalas CCS.

Desconectado jdj

  • PIC10
  • *
  • Mensajes: 37
RE: tarejta servidora con teclado y LCD
« Respuesta #5 en: 22 de Marzo de 2005, 03:54:00 »
Si, parece mentira pero es cierto. Por otra parte mejor para mi.
Me piden lo básico para el control de la regulación de la granja.
O sea que el código del LCD.C y el KBD.C no lo puedo sacar???????? yo esque había encontrado algunas cosillas por los foros pero no se si con eso valdrá aqui mando algo y me dices:
// LCD para 2 líneas (2*16)
// Rutina de CCS original lcd.c retocada con los bits de control en:
// PORTB: RB0=RS,RB1=RW,RB2=E RB4=D4,RB5=D5,RB6=D6,RB7=D7

//*************************************************************************

#define use_portb_lcd true

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

#byte lcd = 6

#define set_tris_lcd(x) set_tris_b(x)


#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};

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_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 "
" : lcd_gotoxy(1,2); break;
case "" : 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);
lcd.rs=1;
value = lcd_read_byte();
lcd.rs=0;
return(value);
}


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);
}

Desconectado Nocturno

  • Administrador
  • DsPIC33
  • *******
  • Mensajes: 18310
    • MicroPIC
RE: tarejta servidora con teclado y LCD
« Respuesta #6 en: 22 de Marzo de 2005, 04:02:00 »
Ese que tú has puesto podría servir, aunque te pego a continuación los ficheros originales de CCS:
Codigo:

///////////////////////////////////////////////////////////////////////////
////                             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                            ////
////                      
  Go to start of second line               ////
////                        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.

// Un-comment the following define to use port B
// #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(__PCH__)
#if defined use_portb_lcd
   #byte lcd = 0xF81                   // This puts the entire structure
#else
   #byte lcd = 0xF83                   // This puts the entire structure
#endif
#else
#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 8)
#endif
#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);
}


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 "
"   : lcd_gotoxy(1,2);        break;
     case ""   : 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);
}



///////////////////////////////////////////////////////////////////////////
////                             KBDD.C                                ////
////                  Generic keypad scan driver                       ////
////                                                                   ////
////  kbd_init()   Must be called before any other function.           ////
////                                                                   ////
////  c = kbd_getc(c)  Will return a key value if pressed or /0 if not ////
////                   This function should be called frequently so as ////
////                   not to miss a key press.                        ////
////                                                                   ////
///////////////////////////////////////////////////////////////////////////
////        (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.                               ////
///////////////////////////////////////////////////////////////////////////

////////////////// The following defines the keypad layout on port D

// Un-comment the following define to use port B
// #define use_portb_kbd TRUE

// Make sure the port used has pull-up resistors (or the LCD) on
// the column pins


#if defined(__PCH__)
#if defined use_portb_kbd
   #byte kbd = 0xF81                   // This puts the entire structure
#else
   #byte kbd = 0xF83                   // This puts the entire structure
#endif
#else
#if defined use_portb_kbd
   #byte kbd = 6                  // on to port B (at address 6)
#else
   #byte kbd = 8                 // on to port D (at address 8)
#endif
#endif

#if defined use_portb_kbd
   #define set_tris_kbd(x) set_tris_b(x)
#else
   #define set_tris_kbd(x) set_tris_d(x)
#endif



//Keypad connection:   (for example column 0 is B2)
//                Bx:

#ifdef blue_keypad  ///////////////////////////////////// For the blue keypad
#define COL0 (1 << 2)
#define COL1 (1 << 3)
#define COL2 (1 << 6)

#define ROW0 (1 << 4)
#define ROW1 (1 << 7)
#define ROW2 (1 << 1)
#define ROW3 (1 << 5)

#else ////////////////////////////////////////////////// For the black keypad
#define COL0 (1 << 5)
#define COL1 (1 << 6)
#define COL2 (1 << 7)

#define ROW0 (1 << 1)
#define ROW1 (1 << 2)
#define ROW2 (1 << 3)
#define ROW3 (1 << 4)

#endif

#define ALL_ROWS (ROW0|ROW1|ROW2|ROW3)
#define ALL_PINS (ALL_ROWS|COL0|COL1|COL2)

// Keypad layout:
char const KEYS[4][3] = {{"1","2","3"},
                         {"4","5","6"},
                         {"7","8","9"},
                         {"*","0","#"}};

#define KBD_DEBOUNCE_FACTOR 33    // Set this number to apx n/333 where
                                  // n is the number of times you expect
                                  // to call kbd_getc each second


void kbd_init() {
}

char kbd_getc( ) {
   static BYTE kbd_call_count;
   static short int kbd_down;
   static char last_key;
   static BYTE col;

   BYTE kchar;
   BYTE row;

   kchar="";
   if(++kbd_call_count>KBD_DEBOUNCE_FACTOR) {
       switch (col) {
         case 0   : set_tris_kbd(ALL_PINS&~COL0);
                    kbd=~COL0&ALL_PINS;
                    break;
         case 1   : set_tris_kbd(ALL_PINS&~COL1);
                    kbd=~COL1&ALL_PINS;
                    break;
         case 2   : set_tris_kbd(ALL_PINS&~COL2);
                    kbd=~COL2&ALL_PINS;
                    break;
       }

       if(kbd_down) {
         if((kbd & (ALL_ROWS))==(ALL_ROWS)) {
           kbd_down=FALSE;
           kchar=last_key;
           last_key="";
         }
       } else {
          if((kbd & (ALL_ROWS))!=(ALL_ROWS)) {
             if((kbd & ROW0)==0)
               row=0;
             else if((kbd & ROW1)==0)
               row=1;
             else if((kbd & ROW2)==0)
               row=2;
             else if((kbd & ROW3)==0)
               row=3;
             last_key =KEYS[row][col];
             kbd_down = TRUE;
          } else {
             ++col;
             if(col==3)
               col=0;
          }
       }
      kbd_call_count=0;
   }
  set_tris_kbd(ALL_PINS);
  return(kchar);
}




Desconectado jdj

  • PIC10
  • *
  • Mensajes: 37
RE: tarejta servidora con teclado y LCD
« Respuesta #7 en: 22 de Marzo de 2005, 04:29:00 »
Es decir que en el progrma principal incluyo esos dos programillas y con eso ya tengo configuradas tanto la LCD como el teclado no??
Bueno, pues teniendo ya configuradodas esas dos cosas, me meteré con el control general, que eso si que tiene tela..........
Si me puedes ir ayundando en lo que puedas le estaré enormemente agradecido.Por ejemplo, quiero que pulsando la tecla 1-> me aparezca la temperatura ambiente de la sala (medida através de un sensor colgado).
Con el 2->temperatura de calefacción( otro sensor cerca de la placa de gorrines) Con el 3-> Porcentaje al que está trabajando un ventilador.
Con el 4->Por ejemplo poder subir la temperatura de la sala, en grados, por lo tanto se cerrarán las ventanas de la sala,controladas mediante un motorcillo de 0-10voltios,que realizará el giro necesario en relación de la tensión y si todavia no hace demasiado calor, se activa un sistema calefactor.
Con el 5-> Bajar la Tª de la sala, se abrirán ventanas y si es necesario se activarán unos ventiladores.

Había pensado asi por encima plantearlo de la siguiente manera:

a) Tª>Tª deseada: SI,vaya a b), NO, vaya a c)
b) Abrir ventanas y se activa ventilador: ir a a)
c)Tª<Tª deseada:SI, vaya a d) NO, vaya a a)
d)Cerrar ventanas, activar sistema calefactor:ir a a)

pero en realidad no se ni por donde empezar con el código del programa.
la electroválvula irá controlada con un relé,el motor-ventilador irá controlado mediante un optoacoplador ( S21MD3V) y un triac.
Igual viendo los esquemas es mas facil comprender lo que quiero hacer........

Desconectado Nocturno

  • Administrador
  • DsPIC33
  • *******
  • Mensajes: 18310
    • MicroPIC
RE: tarejta servidora con teclado y LCD
« Respuesta #8 en: 22 de Marzo de 2005, 04:36:00 »
Pero no tienes que pegar el código completo; sólo hacer los "includes" correspondientes.

Tanto para tener claro eso, como para poder hincarle el diente a tu programa, te recomiendo que empieces a trabajar sobre la base del ejemlo EX_LCDKB.C que te pegué antes.

Desconectado jdj

  • PIC10
  • *
  • Mensajes: 37
RE: tarejta servidora con teclado y LCD
« Respuesta #9 en: 13 de Abril de 2005, 02:45:00 »

Hola nocturno66!!!!! gracias por tu aportaciones, pero que cambios tendría que hacer en la configuración de la LCD, porque tengo conectado la LCD con el micro así:
DB0-->RB0
DB1-->RB1
.            .  
.            .
.            .
.            .
DB7-->RB7
RS-->RA0
R/W-->RA1
E-->RA2


Estaría bien??????????


Desconectado tornar

  • PIC18
  • ****
  • Mensajes: 342
RE: tarejta servidora con teclado y LCD
« Respuesta #10 en: 13 de Abril de 2005, 03:40:00 »
hola jdj, podrias utilizar la libreria de C modificada que doy en este hilo, recuerda añadirle la parte final, que es igual que la libreria sin modificar de CCS, como digo en el post siguiente.

http://miarroba.com/foros/ver.php?foroid=46840&temaid=3534377

Un saludo.

Desconectado jdj

  • PIC10
  • *
  • Mensajes: 37
RE: tarejta servidora con teclado y LCD
« Respuesta #11 en: 13 de Abril de 2005, 03:51:00 »
Encontré esto, estaría bien????????""

********************************************
"* DESCRIPCION:una LCD de 2x16 se visualiza *
"* una opcion de menu y con un boton se va *
"* cambiando el valor de esa opcion *
"********************************************

" La conexion del LCD con el microcontrolador Pic debe ser:
" LCD PIC
" D0 PortB.0
" D1 PortB.1
" D2 PortB.2
" D3 PortB.3
" D4 PortB.4
" D5 PortB.5
" D6 PortB.6
" D7 PortB.7

" RS PortA.0
" E PortA.2
" RW PortA.1
" Vdd 5 V
" Vss Masa
" Vo 10K potenciometro

"ATENCION: LOS INTERRUPTORES RA0, RA1 Y RA2 DEBEN ESTAR EN POSICION 1
"ATENCION: SI SE PRUEBA EL PROGRAMA EN UN MICROPIC TRAINER.

" DEFINICIONESPARA EL LCD **********************

DEFINE LCD_DREG PORTB "Defino el puerto de datos
" DEFINE LCD_DBIT 0 "BIT de comienzo en bus de 4 bits, no aplicado aquí
DEFINE LCD_RSREG PORTA "Ajusto puerto para el Regiter Select
DEFINE LCD_RSBIT 0 "Defino el bit del puerto A para RS
DEFINE LCD_EREG PORTA "Defino el puerto de ENABLE
DEFINE LCD_EBIT 2 "Defino el bit del puerto A que controla Enable
DEFINE LCD_RWREG PORTA "Defino el puerto para control RW
DEFINE LCD_RWBIT 1 "Defino el bit del puerto A que controla RW
DEFINE LCD_BITS 8 "Defino el tamaño del bus de datos, bus de 8 bits
DEFINE LCD_LINES 2 "Defino el numero de lineas del display
DEFINE LCD_COMMANDUS 2000 "Defino el tiempo de retaardo de comando en microseg.
DEFINE LCD_DATAUS 50 "Defino el tiempo de retardo de dato en microsegundos

" FIN DEFINICIONES LCD *************************

" VARIABLES **********************

i VAR WORD

" FIN VARIABLES ******************

i=1200
TRISA.3=1

Pause 1000 " Espero 1 segundos para inicializar LCD
GoSub ver

bucle:
Pause 250
IF PORTA.3=1 Then
i=i*2
IF i>=34000 Then i=1200
GoSub ver
EndIF


GoTo bucle " Repito un bucle infinito


ver:
LCDOut $fe, 1 " Borro el display
LCDOut "Velocidad" " Visualizo velocidad
LCDOut $fe,$C0 " Pongo cursor al principio de la segunda linea
LCDOut DEC i
Return

Desconectado jdj

  • PIC10
  • *
  • Mensajes: 37
RE: tarejta servidora con teclado y LCD
« Respuesta #12 en: 13 de Abril de 2005, 03:58:00 »
Ahora me gustaría me terme a fondo con la programación del control de la sala de la granja. Me gustaría saber si alguien tenía un poco de idea en que programilla puedo utilizar en C para llevar a cabo estas operaciones.
El regulador es comercial que ya lleva su programa metido, pero ahora quiero controlarlo desde una tarjeta diseñada que lleva una LCD, un teclado matricial , su micro PIC16F873 y un max485 para comunicarme con el regulador, a ver si puedo sacar algo.
Por ejemplo, quiero que pulsando la tecla 1-> me aparezca la temperatura ambiente de la sala (medida através de un sensor colgado).
Con el 2->temperatura de calefacción( otro sensor cerca de la placa de gorrines) Con el 3-> Porcentaje al que está trabajando un ventilador.
Con el 4->Por ejemplo poder subir la temperatura de la sala, en grados, por lo tanto se cerrarán las ventanas de la sala,controladas mediante un motorcillo de 0-10voltios,que realizará el giro necesario en relación de la tensión y si todavia no hace demasiado calor, se activa un sistema calefactor.
Con el 5-> Bajar la Tª de la sala, se abrirán ventanas y si es necesario se activarán unos ventiladores.

Había pensado asi por encima plantearlo de la siguiente manera:

a) Tª>Tª deseada: SI,vaya a b), NO, vaya a c)
b) Abrir ventanas y se activa ventilador: ir a a)
c)Tª<Tª deseada:SI, vaya a d) NO, vaya a a)
d)Cerrar ventanas, activar sistema calefactor:ir a a)

pero en realidad no se ni por donde empezar con el código del programa.
la electroválvula irá controlada con un relé,el motor-ventilador irá controlado mediante un optoacoplador ( S21MD3V) y un triac.
Igual viendo los esquemas es mas facil comprender lo que quiero hacer........

Desconectado J1M

  • Moderadores
  • PIC24H
  • *****
  • Mensajes: 1960
RE: tarejta servidora con teclado y LCD
« Respuesta #13 en: 13 de Abril de 2005, 07:14:00 »
has dicho
"a) Tª>Tª deseada: SI,vaya a b), NO, vaya a c)
b) Abrir ventanas y se activa ventilador: ir a a)
c)Tª<Tª deseada:SI, vaya a d) NO, vaya a a)
d)Cerrar ventanas, activar sistema calefactor:ir a a)"


ummmm eso no va a funcionar demasiado bien, yo de tí en vez de temperatura deseada me movia entre dos margenes de temperatura... o hacia el control con un PID.. si no te kieres complicar demasiado pon.

Tdeseada maxima
Tdeseada minima

así el control será mas preciso y mas suave (habrá mas casos claro está Giño) ... pq imagina q estas en el caso A.. y saltas al b ... per estando en el b .. a los 2 segundos te vas al A otra vez... y otros 2 segundos otra vez al B ... etc... como ves no es demasiado optimo. y sobretodo puedes sobrecargar el sistema.. si te mueves entre esos rangos, a no ser q varíe muy bruscamente la temperatura en la sala no tendras muchos problemas

saludos! Giño

Desconectado jdj

  • PIC10
  • *
  • Mensajes: 37
RE: tarejta servidora con teclado y LCD
« Respuesta #14 en: 20 de Abril de 2005, 10:16:00 »
Hola J1M!!! Pues igual tienes razón en eso que dices.
No tendrás algún ejemplillo de controlar algo de esto a trave´s de un teclado matricial????

Muchas gracias, un saludo


 

anything