drv/lcd_text.c

   1 /**
   2  * \file
   3  * <!--
   4  * Copyright 2005 Develer S.r.l. (http://www.develer.com/)
   5  * This file is part of DevLib - See README.devlib for information.
   6  * -->
   7  *
   8  * \brief Generic text LCD driver (impl.).
   9  *
  10  * \version $Id$
  11  * \author Bernardo Innocenti <bernie@develer.com>
  12  * \author Stefano Fedrigo <aleph@develer.com>
  13  */
  14
  15 /*#*
  16  *#* $Log$
  17  *#* Revision 1.4  2006/09/20 20:02:43  marco
  18  *#* Replaced ISLISTEMPTY with LIST_EMPTY
  19  *#*
  20  *#* Revision 1.3  2006/07/19 12:56:25  bernie
  21  *#* Convert to new Doxygen style.
  22  *#*
  23  *#* Revision 1.2  2006/02/24 00:27:14  bernie
  24  *#* Use new naming convention for list macros.
  25  *#*
  26  *#* Revision 1.1  2005/11/04 18:00:42  bernie
  27  *#* Import into DevLib.
  28  *#*
  29  *#* Revision 1.11  2005/06/14 14:43:43  bernie
  30  *#* Add DevLib headers.
  31  *#*
  32  *#* Revision 1.10  2005/06/06 17:41:57  batt
  33  *#* Add lcd_layerSet function.
  34  *#*
  35  *#* Revision 1.9  2005/06/01 16:40:07  batt
  36  *#* Remove debug string.
  37  *#*
  38  *#* Revision 1.8  2005/06/01 16:38:04  batt
  39  *#* Adapt to changes in mware/list.h.
  40  *#*
  41  *#* Revision 1.7  2005/06/01 10:45:22  batt
  42  *#* lcd_setAddr(): Bugfix boundary condition; Misc cleanup.
  43  *#*
  44  *#* Revision 1.6  2005/06/01 10:36:23  batt
  45  *#* Layer: Rename member variables and Doxygenize.
  46  *#*
  47  *#* Revision 1.5  2005/05/27 11:05:58  batt
  48  *#* Do not write on lcd if layer is hidden.
  49  *#*/
  50
  51 #include "lcd_text.h"
  52 #include "lcd_hd44.h"
  53 #include <drv/timer.h> // timer_delay()
  54 #include <mware/formatwr.h> // _formatted_write()
  55 #include <mware/list.h> // LIST_EMPTY()
  56 #include <cfg/macros.h> // BV()
  57 #include <cfg/debug.h>
  58
  59 #include <string.h> // strlen()
  60
  61
  62 /** Maximum number of layers. */
  63 #define LCD_LAYERS 6
  64
  65 #if CONFIG_KERNEL
  66         /** Semaphore to arbitrate access to the display. */
  67         static struct Semaphore lcd_semaphore;
  68         #define LOCK_LCD        sem_obtain(&lcd_semaphore)
  69         #define UNLOCK_LCD      sem_release(&lcd_semaphore)
  70 #else /* !CONFIG_KERNEL */
  71         #define LOCK_LCD        do {} while (0)
  72         #define UNLOCK_LCD      do {} while (0)
  73 #endif /* !CONFIG_KERNEL */
  74
  75 DECLARE_LIST_TYPE(Layer);
  76
  77 Layer *lcd_DefLayer;
  78 static Layer lcd_LayersPool[LCD_LAYERS];
  79 static LIST_TYPE(Layer) lcd_Layers;
  80 static LIST_TYPE(Layer) lcd_FreeLayers;
  81
  82 /**
  83  * Current cursor status.
  84  *
  85  * One of LCD_CMD_CURSOR_OFF, LCD_CMD_CURSOR_BLOCK or LCD_CMD_CURSOR_LINE.
  86  */
  87 static uint8_t lcd_CursorStatus;
  88
  89 /** Current cursor position, encoded as a Cursor position and status. */
  90 static lcdpos_t lcd_CursorAddr;
  91
  92
  93 void lcd_setAddr(Layer *layer, lcdpos_t addr)
  94 {
  95         /* Sanity check: wrap around to display limits */
  96         while (addr >= LCD_ROWS * LCD_COLS)
  97                 addr -= LCD_ROWS * LCD_COLS;
  98
  99         layer->addr = addr;
 100 }
 101
 102 #if CONFIG_KERNEL
 103
 104 void lcd_lock(void)
 105 {
 106         LOCK_LCD;
 107 }
 108
 109
 110 void lcd_unlock(void)
 111 {
 112         UNLOCK_LCD;
 113 }
 114
 115 #endif /* CONFIG_KERNEL */
 116
 117
 118 /**
 119  * Write one character to the display at the current
 120  * cursor prosition, then move the cursor right. The
 121  * cursor is wrapped to the next line when it moves
 122  * beyond the end of the current line.
 123  *
 124  * \note Does _NOT_ lock the display semaphore.
 125  */
 126 static void lcd_putCharUnlocked(char c, Layer *layer)
 127 {
 128         Layer *l2;
 129         lcdpos_t addr = layer->addr;
 130
 131         /* Store character in layer buffer */
 132         layer->buf[addr] = c;
 133
 134         /* Move to next character */
 135         if (++layer->addr >= LCD_COLS * LCD_ROWS)
 136                 layer->addr = 0;
 137
 138         /* Do not write on LCD if layer is hidden. */
 139         if (layer->pri == LAYER_HIDDEN)
 140                 return;
 141
 142         /*
 143          * Check if this location is obscured by
 144          * other layers above us.
 145          */
 146         for (l2 = layer->pred; l2->pred; l2 = l2->pred)
 147         {
 148                 if (l2->buf[addr])
 149                 {
 150                         /* DB(kprintf("layer %04x obs %04x at %d\n", l2, layer, addr);) */
 151                         return;
 152                 }
 153         }
 154
 155         /* Write character */
 156         if (c)
 157                 lcd_putc(addr, c);
 158         else
 159                 /* FIXME: should look for layers beneath! */
 160                 lcd_putc(addr, ' ');
 161 }
 162
 163
 164 void lcd_putChar(char c, Layer *layer)
 165 {
 166         LOCK_LCD;
 167         lcd_putCharUnlocked(c, layer);
 168         UNLOCK_LCD;
 169 }
 170
 171 void lcd_layerSet(Layer *layer, char c)
 172 {
 173         int i;
 174
 175         LOCK_LCD;
 176         lcd_setAddr(layer, 0);
 177         for (i = 0; i < LCD_COLS * LCD_ROWS; i++)
 178                 lcd_putCharUnlocked(c, layer);
 179         UNLOCK_LCD;
 180 }
 181
 182
 183 void lcd_clear(Layer *layer)
 184 {
 185         lcd_layerSet(layer, 0);
 186 }
 187
 188
 189 void lcd_clearLine(Layer *layer, int y)
 190 {
 191         int i;
 192
 193         LOCK_LCD;
 194         lcd_setAddr(layer, LCD_POS(0, y));
 195         for (i = 0; i < LCD_COLS; i++)
 196                 lcd_putCharUnlocked(0, layer);
 197         UNLOCK_LCD;
 198 }
 199
 200
 201 void lcd_moveCursor(lcdpos_t addr)
 202 {
 203         LOCK_LCD;
 204         lcd_moveTo(addr);
 205         UNLOCK_LCD;
 206 }
 207
 208
 209 char lcd_setCursor(char mode)
 210 {
 211         static const char cursor_cmd[3] =
 212         {
 213                 LCD_CMD_CURSOR_OFF, LCD_CMD_CURSOR_BLOCK, LCD_CMD_CURSOR_LINE
 214         };
 215         char oldmode = lcd_CursorStatus;
 216
 217         LOCK_LCD;
 218         lcd_CursorStatus = mode;
 219         lcd_setReg(cursor_cmd[(int)mode]);
 220         if (mode)
 221                 lcd_moveCursor(lcd_CursorAddr);
 222         UNLOCK_LCD;
 223
 224         return oldmode;
 225 }
 226
 227
 228 int lcd_vprintf(Layer *layer, lcdpos_t addr, uint8_t mode, const char *format, va_list ap)
 229 {
 230         int len;
 231
 232         LOCK_LCD;
 233
 234         /*
 235          * Se il cursore era acceso, spegnilo durante
 236          * l'output per evitare che salti alla posizione
 237          * in cui si scrive.
 238          */
 239         if (lcd_CursorStatus)
 240                 lcd_setReg(LCD_CMD_CURSOR_OFF);
 241
 242         /* Spostamento del cursore */
 243         lcd_setAddr(layer, addr);
 244
 245         if (mode & LCD_CENTER)
 246         {
 247                 int pad;
 248
 249                 /*
 250                  * NOTE: calculating the string lenght BEFORE it gets
 251                  * printf()-formatted. Real lenght may differ.
 252                  */
 253                 pad = (LCD_COLS - strlen(format)) / 2;
 254                 while (pad--)
 255                         lcd_putCharUnlocked(' ', layer);
 256         }
 257
 258         len = _formatted_write(format, (void (*)(char, void *))lcd_putCharUnlocked, layer, ap);
 259
 260         if (mode & (LCD_FILL | LCD_CENTER))
 261                 while (layer->addr % LCD_COLS)
 262                         lcd_putCharUnlocked(' ', layer);
 263
 264         /*
 265          * Riaccendi il cursore e riportalo alla
 266          * vecchia posizione
 267          */
 268         if (lcd_CursorStatus)
 269                 lcd_setCursor(lcd_CursorStatus);
 270
 271         UNLOCK_LCD;
 272
 273         return len;
 274 }
 275
 276
 277 int lcd_printf(Layer *layer, lcdpos_t addr, uint8_t mode, const char *format, ...)
 278 {
 279         int len;
 280         va_list ap;
 281
 282         va_start(ap, format);
 283         len = lcd_vprintf(layer, addr, mode, format, ap);
 284         va_end(ap);
 285
 286         return len;
 287 }
 288
 289
 290 /**
 291  * Internal function to move a layer between two positions.
 292  *
 293  * \note The layer must be *already* enqueued in some list.
 294  * \note The display must be already locked!
 295  */
 296 static void lcd_enqueueLayer(Layer *layer, char pri)
 297 {
 298         Layer *l2;
 299
 300         /* Remove layer from whatever list it was in before */
 301         REMOVE(layer);
 302
 303         layer->pri = pri;
 304
 305         /*
 306          * Search for the first layer whose priority
 307          * is less or equal to the layer we are adding.
 308          */
 309         FOREACH_NODE(l2, &lcd_Layers)
 310                 if (l2->pri <= pri)
 311                         break;
 312
 313         /* Enqueue layer */
 314         INSERT_BEFORE(layer, l2);
 315 }
 316
 317 Layer *lcd_newLayer(char pri)
 318 {
 319         Layer *layer;
 320
 321         LOCK_LCD;
 322
 323         if (LIST_EMPTY(&lcd_FreeLayers))
 324         {
 325                 UNLOCK_LCD;
 326                 //ASSERT(false);
 327                 return NULL;
 328         }
 329
 330         layer = (Layer *)LIST_HEAD(&lcd_FreeLayers);
 331         layer->addr = 0;
 332         memset(layer->buf, 0, LCD_ROWS * LCD_COLS);
 333
 334         lcd_enqueueLayer(layer, pri);
 335
 336         UNLOCK_LCD;
 337         return layer;
 338 }
 339
 340 /**
 341  * Redraw the display (internal).
 342  *
 343  * \note The display must be already locked.
 344  */
 345 static void lcd_refresh(void)
 346 {
 347         lcdpos_t addr;
 348         Layer *l;
 349
 350         for (addr = 0; addr < LCD_ROWS * LCD_COLS; ++addr)
 351         {
 352                 FOREACH_NODE(l, &lcd_Layers)
 353                 {
 354                         //kprintf("%d %x %p\n", addr, l->buf[0], l);
 355                         if (l->pri == LAYER_HIDDEN)
 356                                 break;
 357
 358                         if (l->buf[addr])
 359                         {
 360                                 /* Refresh location */
 361                                 lcd_putc(addr, l->buf[addr]);
 362                                 goto done;
 363                         }
 364                 }
 365
 366                 /* Draw background */
 367                 lcd_putc(addr, ' ');
 368         done:
 369                 ;
 370         }
 371 }
 372
 373 /**
 374  * Rearrange layer depth and refresh display accordingly.
 375  *
 376  * \note Setting a priority of LAYER_HIDDEN makes the layer invisible.
 377  */
 378 void lcd_setLayerDepth(Layer *layer, char pri)
 379 {
 380         if (pri != layer->pri)
 381         {
 382                 LOCK_LCD;
 383                 lcd_enqueueLayer(layer, pri);
 384                 /* Vile but simple */
 385                 lcd_refresh();
 386                 UNLOCK_LCD;
 387         }
 388 }
 389
 390 void lcd_deleteLayer(Layer *layer)
 391 {
 392         LOCK_LCD;
 393
 394 /* We use lcd_refresh() instead.  Much simpler than this mess, but slower. */
 395 #if 0
 396         Layer *l2;
 397         lcdpos_t addr;
 398
 399         /* Repair damage on underlaying layers */
 400         for (addr = 0; addr < LCD_ROWS * LCD_COLS; ++addr)
 401         {
 402                 /* If location was covered by us */
 403                 if (layer->buf[addr])
 404                 {
 405                         /* ...and it wasn't covered by others above us... */
 406                         for (l2 = layer->pred; l2->pred; l2 = l2->pred)
 407                                 if (l2->buf[addr])
 408                                         /* can't just break here! */
 409                                         goto not_visible;
 410
 411                         /* ...scan underlaying layers to repair damage */
 412                         for (l2 = layer->succ; l2->succ; l2 = l2->succ)
 413                                 if (l2->buf[addr])
 414                                 {
 415                                         /* Refresh character */
 416                                         lcd_putc(addr, l2->buf[addr]);
 417
 418                                         /* No need to search on deeper layers */
 419                                         break;
 420                                 }
 421
 422                         not_visible:
 423                                 ;
 424                 }
 425         }
 426 #endif
 427
 428         // Remove layer from lcd_Layers list.
 429         REMOVE(layer);
 430
 431         /* Put layer back into free list */
 432         ADDHEAD(&lcd_FreeLayers, layer);
 433
 434         lcd_refresh();
 435
 436         UNLOCK_LCD;
 437 }
 438
 439
 440 static void lcd_setDefLayer(Layer *layer)
 441 {
 442         lcd_DefLayer = layer;
 443 }
 444
 445 #include <cfg/debug.h>
 446 void lcd_init(void)
 447 {
 448         int i;
 449
 450         LIST_INIT(&lcd_Layers);
 451         LIST_INIT(&lcd_FreeLayers);
 452         for (i = 0; i < LCD_LAYERS; ++i)
 453                 ADDHEAD(&lcd_FreeLayers, &lcd_LayersPool[i]);
 454
 455         lcd_setDefLayer(lcd_newLayer(0));
 456
 457         lcd_hw_init();
 458
 459         lcd_setCursor(0);
 460 }
 461
 462 #if CONFIG_TEST
 463 void lcd_test(void)
 464 {
 465         int i;
 466
 467         for (i = 0; i < LCD_ROWS * LCD_COLS; ++i)
 468         {
 469                 lcd_putCharUnlocked('0' + (i % 10), lcd_DefLayer);
 470                 timer_delay(100);
 471         }
 472 }
 473 #endif /* CONFIG_TEST */
 474