AVR: aversive_10-03-12/modules/devices/ihm/lcd/lcd.c Source File

00001 /*  
00002  *  Copyright Droids Corporation, Microb Technology, Eirbot (2005)
00003  * 
00004  *  This program is free software; you can redistribute it and/or modify
00005  *  it under the terms of the GNU General Public License as published by
00006  *  the Free Software Foundation; either version 2 of the License, or
00007  *  (at your option) any later version.
00008  *
00009  *  This program is distributed in the hope that it will be useful,
00010  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
00011  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00012  *  GNU General Public License for more details.
00013  *
00014  *  You should have received a copy of the GNU General Public License
00015  *  along with this program; if not, write to the Free Software
00016  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00017  *
00018  *  Revision : $Id: lcd.c,v 1.7 2008-01-08 20:05:03 zer0 Exp $
00019  *
00020  */
00021 
00022 /* Droids-corp, Eirbot, Microb Technology 2005 - Zer0
00023  * Implementation for LCD
00024  */
00025 
00038 #include <stdio.h>
00039 
00040 #include <aversive/pgmspace.h>
00041 #include <aversive.h>
00042 #include <aversive/wait.h>
00043 
00044 #include <lcd.h>
00045 #include <lcd_protocol.h>
00046 
00047 
00048 //#define lcd_e_delay()   asm volatile("nop")  /* delay 500ns with 4Mhz */
00049 #define e_delay() _delay_loop_1(1) // ok ca ?
00050 
00051 
00052 /**********************************************************/
00053 /*
00054 ** port level functions
00055 */
00056 
00057 // DDR en sortie
00058 static inline void port_set_out(void)
00059 {
00060   uint8_t flags;
00061 
00062   IRQ_LOCK(flags);  // if there is some other stuff on the same port
00063   DDR(LCD_PORT) |= LCD_DATA_MASK;
00064   IRQ_UNLOCK(flags);
00065 }
00066 
00067 // DDR en entree
00068 static inline void port_set_in(void)
00069 {
00070   uint8_t flags;
00071 
00072   IRQ_LOCK(flags);
00073   DDR(LCD_PORT) &= ~(LCD_DATA_MASK);
00074   IRQ_UNLOCK(flags);
00075 }
00076 
00077 
00078 /* toggle Enable Pin */
00079 static inline void e_toggle(void)
00080 {
00081   sbi(LCD_E_PORT, LCD_E_BIT);
00082   e_delay();
00083   cbi(LCD_E_PORT, LCD_E_BIT);
00084 }
00085 
00086 /**********************************************************/
00087 /*
00088 ** byte level functions
00089 */
00090 static inline void lcd_write(uint8_t data,uint8_t rs) 
00091 {
00092   register uint8_t port_save;
00093   uint8_t flags;
00094 
00095 
00096   port_set_out();
00097   
00098 
00099   cbi(LCD_RW_PORT, LCD_RW_BIT);//RW=0
00100 
00101   if (rs) 
00102     sbi(LCD_RS_PORT, LCD_RS_BIT); //RS=1 
00103   else
00104     cbi(LCD_RS_PORT, LCD_RS_BIT); //RS=0 
00105       
00106 
00107   // port state save
00108   IRQ_LOCK(flags);
00109  
00110  port_save= LCD_DATA_PORT & ~(LCD_DATA_MASK);
00111 
00112   /* output high nibble first */
00113   LCD_DATA_PORT = ( ( ((data>>4) << LCD_FIRST_DATA_BIT) & LCD_DATA_MASK )
00114                     |  port_save );
00115 
00116   e_toggle();
00117   
00118   /* output low nibble */
00119   LCD_DATA_PORT = ( ((data<<LCD_FIRST_DATA_BIT) & LCD_DATA_MASK)
00120                     |  port_save );
00121 
00122 
00123   IRQ_UNLOCK(flags);
00124 
00125   e_toggle();
00126 }
00127 
00128 
00129 
00130 static uint8_t lcd_read(uint8_t rs) 
00131 {
00132   register uint8_t dataH, dataL;
00133   
00134   
00135   if (rs) sbi(LCD_RS_PORT, LCD_RS_BIT);    /* RS=1: read data      */
00136   else    cbi(LCD_RS_PORT, LCD_RS_BIT);    /* RS=0: read busy flag */
00137   sbi(LCD_RW_PORT, LCD_RW_BIT);            /* RW=1  read mode      */
00138   
00139   /* configure data pins as input */
00140   port_set_in();
00141   
00142   sbi(LCD_E_PORT, LCD_E_BIT);
00143   e_delay();
00144   
00145   
00146   dataH = PIN(LCD_PORT) >> LCD_FIRST_DATA_BIT ;/* read high nibble first */
00147   
00148   cbi(LCD_E_PORT, LCD_E_BIT);   
00149   e_delay();                           /* Enable 500ns low       */
00150   
00151 
00152   sbi(LCD_E_PORT, LCD_E_BIT);
00153   e_delay();
00154   
00155   dataL = PIN(LCD_PORT) >> LCD_FIRST_DATA_BIT ;            /* read low nibble        */
00156 
00157   cbi(LCD_E_PORT, LCD_E_BIT);   
00158     
00159   return ( (dataH<<4) | (dataL&0x0F) );
00160 }
00161 
00162 
00163 // use for init, to set lcd mode to 4 bits
00164 void initial_8_bit_write(uint8_t value)
00165 {
00166   register uint8_t port_save;
00167   uint8_t flags;
00168 
00169 
00170   cbi(LCD_RW_PORT, LCD_RW_BIT);
00171 
00172   cbi(LCD_RS_PORT, LCD_RS_BIT);
00173 
00174 
00175   IRQ_LOCK(flags);
00176 
00177   // port save
00178   port_save = LCD_DATA_PORT & ~(LCD_DATA_MASK);
00179 
00180 
00181   LCD_DATA_PORT = ( ((value <<LCD_FIRST_DATA_BIT) & LCD_DATA_MASK)
00182                     |  port_save );
00183 
00184   IRQ_UNLOCK(flags);
00185 
00186   e_toggle();
00187   wait_ms(1);           // delay, busy flag can't be checked here 
00188 }
00189 
00190 /**********************************************************/
00191 /*
00192 ** commands and more
00193 */
00194 
00195 static inline unsigned char lcd_waitbusy(void)
00196 /* loops while lcd is busy, reads address counter */
00197 {
00198   register unsigned char c;
00199   
00200   while ( (c=lcd_read(0)) & (1<<LCD_BUSY)) ;
00201   
00202   return (c);  // return address counter
00203 }
00204 
00205 
00206 
00207 void lcd_command(uint8_t cmd)
00208      /* send commando <cmd> to LCD */
00209 {
00210   lcd_waitbusy();
00211   lcd_write(cmd,0);
00212 }
00213 
00214 
00215 
00216 static inline void lcd_newline(uint8_t pos)
00217      /* goto start of next line */
00218 {
00219   register uint8_t addressCounter;
00220   
00221   
00222 #if LCD_LINES==1
00223   addressCounter = 0;
00224 #endif
00225 #if LCD_LINES==2
00226   if ( pos < (LCD_START_LINE2) )
00227     addressCounter = LCD_START_LINE2;
00228   else
00229     addressCounter = LCD_START_LINE1;
00230 #endif
00231 #if LCD_LINES==4
00232   if ( pos < LCD_START_LINE3 )
00233     addressCounter = LCD_START_LINE2;
00234   else if ( (pos >= LCD_START_LINE2) && (pos < LCD_START_LINE4) )
00235     addressCounter = LCD_START_LINE3;
00236   else if ( (pos >= LCD_START_LINE3) && (pos < LCD_START_LINE2) )
00237     addressCounter = LCD_START_LINE4;
00238   else 
00239     addressCounter = LCD_START_LINE1;
00240 #endif
00241 
00242 
00243   lcd_command((1<<LCD_DDRAM)+addressCounter);
00244   
00245 }/* lcd_newline */
00246 
00247 
00248 
00249 
00250 
00251 
00252 /**********************************************************/
00253 
00254 /*
00255 ** PUBLIC FUNCTIONS 
00256 */
00257 
00258 
00259 
00260 void lcd_gotoxy(uint8_t x, uint8_t y)
00261      /* goto position (x,y) */
00262 {
00263 #if (LCD_LINES==1)
00264   lcd_command((1<<LCD_DDRAM)+LCD_START_LINE1+x);
00265 #endif
00266 #if (LCD_LINES==2)
00267   if ( y==0 ) 
00268     lcd_command((1<<LCD_DDRAM)+LCD_START_LINE1+x);
00269   else
00270     lcd_command((1<<LCD_DDRAM)+LCD_START_LINE2+x);
00271 #endif
00272 #if LCD_LINES==4
00273   if ( y==0 )
00274     lcd_command((1<<LCD_DDRAM)+LCD_START_LINE1+x);
00275   else if ( y==1)
00276     lcd_command((1<<LCD_DDRAM)+LCD_START_LINE2+x);
00277   else if ( y==2)
00278     lcd_command((1<<LCD_DDRAM)+LCD_START_LINE3+x);
00279   else /* y==3 */
00280     lcd_command((1<<LCD_DDRAM)+LCD_START_LINE4+x);
00281 #endif
00282   
00283 }/* lcd_gotoxy */
00284 
00285 
00286 
00287 
00288 void lcd_clrscr(void)
00289      /* clear lcd and set cursor to home position */
00290 {
00291   lcd_command(1<<LCD_CLR);
00292 }
00293 
00294 
00295 
00296 void lcd_home(void)
00297      /* set cursor to home position */
00298 {
00299   lcd_command(1<<LCD_HOME);
00300 }
00301 
00302 
00303 
00304 void lcd_putc(char c)
00305      /* print character at current cursor position */
00306 {
00307   register unsigned char pos;
00308   
00309   pos = lcd_waitbusy();   // read busy-flag and address counter
00310   
00311 #if LCD_DOUBLE_ADDRESSING == 1
00312   if(pos==8)
00313     {
00314       lcd_gotoxy(0,1);
00315       lcd_waitbusy();
00316     }
00317 #endif
00318 
00319   if (c=='\n')        // new line
00320     lcd_newline(pos);
00321   else if (c== '\f') // form feed = clear screen
00322     lcd_clrscr();
00323         else                // normal car
00324     lcd_write(c, 1);
00325 }
00326 
00327 /* for use with fdevopen */
00328 int lcd_dev_putc(char c, FILE* f)
00329 {
00330         lcd_putc(c);
00331         return c;
00332 }
00333 
00334 void lcd_init(uint8_t dispAttr)
00335      /* initialize display and select type of cursor */
00336      /* dispAttr: LCD_DISP_OFF, LCD_DISP_ON, LCD_DISP_ON_CURSOR, LCD_DISP_CURSOR_BLINK */
00337 {
00338 
00339 
00340   // DDRs
00341   port_set_out();
00342 
00343   sbi(DDR(LCD_RW_PORT), LCD_RW_BIT);
00344   sbi(DDR(LCD_RS_PORT), LCD_RS_BIT);
00345   sbi(DDR(LCD_E_PORT), LCD_E_BIT);
00346 
00347 
00348   wait_ms(16);        /* wait 16ms or more after power-on       */
00349   
00350   /*------ Initialize lcd to 4 bit i/o mode -------*/ 
00351   /* initial write to lcd is 8bit */
00352   initial_8_bit_write(LCD_FUNCTION_8BIT_1LINE>>4);
00353   initial_8_bit_write(LCD_FUNCTION_8BIT_1LINE>>4);
00354   initial_8_bit_write(LCD_FUNCTION_8BIT_1LINE>>4);
00355   initial_8_bit_write(LCD_FUNCTION_4BIT_1LINE>>4);
00356 
00357 
00358   
00359   lcd_command(LCD_FUNCTION_DEFAULT);      /* function set: display lines  */
00360   lcd_command(LCD_DISP_OFF);              /* display off                  */
00361   lcd_clrscr();                           /* display clear                */ 
00362   lcd_command(LCD_MODE_DEFAULT);          /* set entry mode               */
00363   lcd_command(dispAttr);                  /* display/cursor control       */
00364 
00365 
00366 
00367 
00368 }/* lcd_init */