Gordons Projects

--> Projects Top-Level GIT

Makefiles: Honour WIRINGPI_SONAME_SUFFIX
[wiringPi] / devLib / lcd128x64.c
1 /*
2  * lcd128x64.c:
3  *      Graphics-based LCD driver.
4  *      This is designed to drive the parallel interface LCD drivers
5  *      based on the generic 12864H chips
6  *
7  *      There are many variations on these chips, however they all mostly
8  *      seem to be similar.
9  *      This implementation has the Pins from the Pi hard-wired into it,
10  *      in particular wiringPi pins 0-7 so that we can use
11  *      digitalWriteByete() to speed things up somewhat.
12  *
13  * Copyright (c) 2013 Gordon Henderson.
14  ***********************************************************************
15  * This file is part of wiringPi:
16  *      https://projects.drogon.net/raspberry-pi/wiringpi/
17  *
18  *    wiringPi is free software: you can redistribute it and/or modify
19  *    it under the terms of the GNU Lesser General Public License as published by
20  *    the Free Software Foundation, either version 3 of the License, or
21  *    (at your option) any later version.
22  *
23  *    wiringPi is distributed in the hope that it will be useful,
24  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
25  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
26  *    GNU Lesser General Public License for more details.
27  *
28  *    You should have received a copy of the GNU Lesser General Public License
29  *    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
30  ***********************************************************************
31  */
32
33 #include <stdio.h>
34 #include <stdlib.h>
35
36 #include <wiringPi.h>
37
38 #include "font.h"
39 #include "lcd128x64.h"
40
41 // Size
42
43 #define LCD_WIDTH       128
44 #define LCD_HEIGHT       64
45
46 // Hardware Pins
47 //      Note pins 0-7 are the 8-bit data port
48
49 #define CS1             10
50 #define CS2             11
51 #define STROBE          12
52 #define RS              13
53
54 // Software copy of the framebuffer
55 //      it's 8-bit deep although the display itself is only 1-bit deep.
56
57 static unsigned char frameBuffer [LCD_WIDTH * LCD_HEIGHT] ;
58
59 static int maxX,    maxY ;
60 static int lastX,   lastY ;
61 static int xOrigin, yOrigin ;
62 static int lcdOrientation = 0 ;
63
64 /*
65  * strobe:
66  *      Toggle the strobe (Really the "E") pin to the device.
67  *      According to the docs, data is latched on the falling edge.
68  *********************************************************************************
69  */
70
71 static void strobe (void)
72 {
73   digitalWrite (STROBE, 1) ; delayMicroseconds (1) ;
74   digitalWrite (STROBE, 0) ; delayMicroseconds (5) ;
75 }
76
77
78 /*
79  * sentData:
80  *      Send an data or command byte to the display.
81  *********************************************************************************
82  */
83
84 static void sendData (const int data, const int chip)
85 {
86   digitalWrite     (chip, 0) ;
87   digitalWriteByte (data) ;
88   strobe           () ;
89   digitalWrite     (chip, 1) ;
90 }
91
92
93 /*
94  * sendCommand:
95  *      Send a command byte to the display
96  *********************************************************************************
97  */
98
99 static void sendCommand (const int command, const int chip)
100 {
101   digitalWrite (RS, 0) ;
102   sendData     (command, chip) ;
103   digitalWrite (RS, 1) ;
104 }
105
106
107 /*
108  * setCol: SetLine:
109  *      Set the column and line addresses
110  *********************************************************************************
111  */
112
113 static void setCol  (int col, const int chip)
114   { sendCommand (0x40 | (col  & 0x3F), chip) ; }
115
116 static void setLine (int line, const int chip)
117   { sendCommand (0xB8 | (line & 0x07), chip) ; }
118
119
120 /*
121  * lcd128x64update:
122  *      Copy our software version to the real display
123  *********************************************************************************
124  */
125
126 void lcd128x64update (void)
127 {
128   int line, x, y, fbLoc ;
129   unsigned char byte ;
130
131 // Left side 
132
133   for (line = 0 ; line < 8 ; ++line)
134   {
135     setCol  (0,    CS1) ;
136     setLine (line, CS1) ;
137
138     for (x = 63 ; x >= 0 ; --x)
139     {
140       byte = 0 ;
141       for (y = 0 ; y < 8 ; ++y)
142       {
143         fbLoc = x + (((7 - line) * 8) + (7 - y)) * LCD_WIDTH ;
144         if (frameBuffer [fbLoc] != 0)
145           byte |= (1 << y) ;
146       }
147       sendData (byte, CS1) ;
148     }
149   }
150
151 // Right side 
152
153   for (line = 0 ; line < 8 ; ++line)
154   {
155     setCol  (0,    CS2) ;
156     setLine (line, CS2) ;
157
158     for (x = 127 ; x >= 64 ; --x)
159     {
160       byte = 0 ;
161       for (y = 0 ; y < 8 ; ++y)
162       {
163         fbLoc = x + (((7 - line) * 8) + (7 - y)) * LCD_WIDTH ;
164         if (frameBuffer [fbLoc] != 0)
165           byte |= (1 << y) ;
166       }
167       sendData (byte, CS2) ;
168     }
169   }
170 }
171
172
173 /*
174  * lcd128x64setOrigin:
175  *      Set the display offset origin
176  *********************************************************************************
177  */
178
179 void lcd128x64setOrigin (int x, int y)
180 {
181   xOrigin = x ;
182   yOrigin = y ;
183 }
184
185
186 /*
187  * lcd128x64setOrientation:
188  *      Set the display orientation:
189  *      0: Normal, the display is portrait mode, 0,0 is top left
190  *      1: Landscape
191  *      2: Portrait, flipped
192  *      3: Landscape, flipped
193  *********************************************************************************
194  */
195
196 void lcd128x64setOrientation (int orientation)
197 {
198   lcdOrientation = orientation & 3 ;
199
200   lcd128x64setOrigin (0,0) ;
201
202   switch (lcdOrientation)
203   {
204     case 0:
205       maxX = LCD_WIDTH ;
206       maxY = LCD_HEIGHT ;
207       break ;
208
209     case 1:
210       maxX = LCD_HEIGHT ;
211       maxY = LCD_WIDTH ;
212       break ;
213
214     case 2:
215       maxX = LCD_WIDTH ;
216       maxY = LCD_HEIGHT ;
217       break ;
218
219     case 3:
220       maxX = LCD_HEIGHT ;
221       maxY = LCD_WIDTH ;
222       break ;
223   }
224 }
225
226
227 /*
228  * lcd128x64orientCoordinates:
229  *      Adjust the coordinates given to the display orientation
230  *********************************************************************************
231  */
232
233 void lcd128x64orientCoordinates (int *x, int *y)
234 {
235   register int tmp ;
236
237   *x += xOrigin ;
238   *y += yOrigin ;
239   *y  = maxY - *y - 1 ;
240
241   switch (lcdOrientation)
242   {
243     case 0:
244       break;
245
246     case 1:
247       tmp = maxY - *y - 1 ;
248       *y = *x ;
249       *x = tmp ;
250       break;
251
252     case 2:
253       *x = maxX - *x - 1 ;
254       *y = maxY - *y - 1 ;
255       break;
256
257     case 3:
258       *x = maxX - *x - 1 ;
259       tmp = *y ;
260       *y = *x ;
261       *x = tmp ;
262       break ;
263   }
264 }
265
266
267 /*
268  * lcd128x64getScreenSize:
269  *      Return the max X & Y screen sizes. Needs to be called again, if you 
270  *      change screen orientation.
271  *********************************************************************************
272  */
273
274 void lcd128x64getScreenSize (int *x, int *y)
275 {
276   *x = maxX ;
277   *y = maxY ;
278 }
279
280
281 /*
282  *********************************************************************************
283  * Standard Graphical Functions
284  *********************************************************************************
285  */
286
287
288 /*
289  * lcd128x64point:
290  *      Plot a pixel.
291  *********************************************************************************
292  */
293
294 void lcd128x64point (int x, int y, int colour)
295 {
296   lastX = x ;
297   lastY = y ;
298
299   lcd128x64orientCoordinates (&x, &y) ;
300
301   if ((x < 0) || (x >= LCD_WIDTH) || (y < 0) || (y >= LCD_HEIGHT))
302     return ;
303
304   frameBuffer [x + y * LCD_WIDTH] = colour ;
305 }
306
307
308 /*
309  * lcd128x64line: lcd128x64lineTo:
310  *      Classic Bressenham Line code
311  *********************************************************************************
312  */
313
314 void lcd128x64line (int x0, int y0, int x1, int y1, int colour)
315 {
316   int dx, dy ;
317   int sx, sy ;
318   int err, e2 ;
319
320   lastX = x1 ;
321   lastY = y1 ;
322
323   dx = abs (x1 - x0) ;
324   dy = abs (y1 - y0) ;
325
326   sx = (x0 < x1) ? 1 : -1 ;
327   sy = (y0 < y1) ? 1 : -1 ;
328
329   err = dx - dy ;
330  
331   for (;;)
332   {
333     lcd128x64point (x0, y0, colour) ;
334
335     if ((x0 == x1) && (y0 == y1))
336       break ;
337
338     e2 = 2 * err ;
339
340     if (e2 > -dy)
341     {
342       err -= dy ;
343       x0  += sx ;
344     }
345
346     if (e2 < dx)
347     {
348       err += dx ;
349       y0  += sy ;
350     }
351   }
352
353 }
354
355 void lcd128x64lineTo (int x, int y, int colour)
356 {
357   lcd128x64line (lastX, lastY, x, y, colour) ;
358 }
359
360
361 /*
362  * lcd128x64rectangle:
363  *      A rectangle is a spoilt days fishing
364  *********************************************************************************
365  */
366
367 void lcd128x64rectangle (int x1, int y1, int x2, int y2, int colour, int filled)
368 {
369   register int x ;
370
371   if (filled)
372   {
373     /**/ if (x1 == x2)
374       lcd128x64line (x1, y1, x2, y2, colour) ;
375     else if (x1 < x2)
376       for (x = x1 ; x <= x2 ; ++x)
377         lcd128x64line (x, y1, x, y2, colour) ;
378     else
379       for (x = x2 ; x <= x1 ; ++x)
380         lcd128x64line (x, y1, x, y2, colour) ;
381   }
382   else
383   {
384     lcd128x64line   (x1, y1, x2, y1, colour) ;
385     lcd128x64lineTo (x2, y2, colour) ;
386     lcd128x64lineTo (x1, y2, colour) ;
387     lcd128x64lineTo (x1, y1, colour) ;
388   }
389 }
390
391
392 /*
393  * lcd128x64circle:
394  *      This is the midpoint circle algorithm.
395  *********************************************************************************
396  */
397
398 void lcd128x64circle (int x, int y, int r, int colour, int filled)
399 {
400   int ddF_x = 1 ;
401   int ddF_y = -2 * r ;
402
403   int f = 1 - r ;
404   int x1 = 0 ;
405   int y1 = r ;
406
407   if (filled)
408   {
409     lcd128x64line (x, y + r, x, y - r, colour) ;
410     lcd128x64line (x + r, y, x - r, y, colour) ;
411   }
412   else
413   {
414     lcd128x64point (x, y + r, colour) ;
415     lcd128x64point (x, y - r, colour) ;
416     lcd128x64point (x + r, y, colour) ;
417     lcd128x64point (x - r, y, colour) ;
418   }
419
420   while (x1 < y1)
421   {
422     if (f >= 0)
423     {
424       y1-- ;
425       ddF_y += 2 ;
426       f += ddF_y ;
427     }
428     x1++ ;
429     ddF_x += 2 ;
430     f += ddF_x ;
431     if (filled)
432     {
433       lcd128x64line (x + x1, y + y1, x - x1, y + y1, colour) ;
434       lcd128x64line (x + x1, y - y1, x - x1, y - y1, colour) ;
435       lcd128x64line (x + y1, y + x1, x - y1, y + x1, colour) ;
436       lcd128x64line (x + y1, y - x1, x - y1, y - x1, colour) ;
437     }
438     else
439     {
440       lcd128x64point (x + x1, y + y1, colour) ; lcd128x64point (x - x1, y + y1, colour) ;
441       lcd128x64point (x + x1, y - y1, colour) ; lcd128x64point (x - x1, y - y1, colour) ;
442       lcd128x64point (x + y1, y + x1, colour) ; lcd128x64point (x - y1, y + x1, colour) ;
443       lcd128x64point (x + y1, y - x1, colour) ; lcd128x64point (x - y1, y - x1, colour) ;
444     }
445   }
446 }
447
448
449 /*
450  * lcd128x64ellipse:
451  *      Fast ellipse drawing algorithm by 
452  *      John Kennedy
453  *      Mathematics Department
454  *      Santa Monica College
455  *      1900 Pico Blvd.
456  *      Santa Monica, CA 90405
457  *      jrkennedy6@gmail.com
458  *      -Confirned in email this algorithm is in the public domain -GH-
459  *********************************************************************************
460  */
461
462 static void plot4ellipsePoints (int cx, int cy, int x, int y, int colour, int filled)
463 {
464   if (filled)
465   {
466     lcd128x64line (cx + x, cy + y, cx - x, cy + y, colour) ;
467     lcd128x64line (cx - x, cy - y, cx + x, cy - y, colour) ;
468   }
469   else
470   {
471     lcd128x64point (cx + x, cy + y, colour) ;
472     lcd128x64point (cx - x, cy + y, colour) ;
473     lcd128x64point (cx - x, cy - y, colour) ;
474     lcd128x64point (cx + x, cy - y, colour) ;
475   }
476 }
477
478 void lcd128x64ellipse (int cx, int cy, int xRadius, int yRadius, int colour, int filled)
479 {
480   int x, y ;
481   int xChange, yChange, ellipseError ;
482   int twoAsquare, twoBsquare ;
483   int stoppingX, stoppingY ;
484
485   twoAsquare = 2 * xRadius * xRadius ;
486   twoBsquare = 2 * yRadius * yRadius ;
487
488   x = xRadius ;
489   y = 0 ;
490
491   xChange = yRadius * yRadius * (1 - 2 * xRadius) ;
492   yChange = xRadius * xRadius ;
493
494   ellipseError = 0 ;
495   stoppingX    = twoBsquare * xRadius ;
496   stoppingY    = 0 ;
497
498   while (stoppingX >= stoppingY)        // 1st set of points
499   {
500     plot4ellipsePoints (cx, cy, x, y, colour, filled) ;
501     ++y ;
502     stoppingY    += twoAsquare ;
503     ellipseError += yChange ;
504     yChange      += twoAsquare ;
505
506     if ((2 * ellipseError + xChange) > 0 )
507     {
508       --x ;
509       stoppingX    -= twoBsquare ;
510       ellipseError += xChange ;
511       xChange      += twoBsquare ;
512     }
513   }
514
515   x = 0 ;
516   y = yRadius ;
517
518   xChange = yRadius * yRadius ;
519   yChange = xRadius * xRadius * (1 - 2 * yRadius) ;
520
521   ellipseError = 0 ;
522   stoppingX    = 0 ;
523   stoppingY    = twoAsquare * yRadius ;
524
525   while (stoppingX <= stoppingY)        //2nd set of points
526   {
527     plot4ellipsePoints (cx, cy, x, y, colour, filled) ;
528     ++x ;
529     stoppingX    += twoBsquare ;
530     ellipseError += xChange ;
531     xChange      += twoBsquare ;
532
533     if ((2 * ellipseError + yChange) > 0 )
534     {
535       --y ;
536       stoppingY -= twoAsquare ;
537       ellipseError += yChange ;
538       yChange += twoAsquare ;
539     }
540   }
541 }
542
543
544 /*
545  * lcd128x64putchar:
546  *      Print a single character to the screen
547  *********************************************************************************
548  */
549
550 void lcd128x64putchar (int x, int y, int c, int bgCol, int fgCol)
551 {
552   int y1, y2 ;
553
554   unsigned char line ;
555   unsigned char *fontPtr ;
556
557 // Can't print if we're offscreen
558
559 //if ((x < 0) || (x >= (maxX - fontWidth)) || (y < 0) || (y >= (maxY - fontHeight)))
560 //  return ;
561
562   fontPtr = font + c * fontHeight ;
563
564   for (y1 = fontHeight - 1 ; y1 >= 0 ; --y1)
565   {
566     y2 = y + y1 ;
567     line = *fontPtr++ ;
568     lcd128x64point (x + 0, y2, (line & 0x80) == 0 ? bgCol : fgCol) ;
569     lcd128x64point (x + 1, y2, (line & 0x40) == 0 ? bgCol : fgCol) ;
570     lcd128x64point (x + 2, y2, (line & 0x20) == 0 ? bgCol : fgCol) ;
571     lcd128x64point (x + 3, y2, (line & 0x10) == 0 ? bgCol : fgCol) ;
572     lcd128x64point (x + 4, y2, (line & 0x08) == 0 ? bgCol : fgCol) ;
573     lcd128x64point (x + 5, y2, (line & 0x04) == 0 ? bgCol : fgCol) ;
574     lcd128x64point (x + 6, y2, (line & 0x02) == 0 ? bgCol : fgCol) ;
575     lcd128x64point (x + 7, y2, (line & 0x01) == 0 ? bgCol : fgCol) ;
576   }
577 }
578
579
580 /*
581  * lcd128x64puts:
582  *      Send a string to the display. Obeys \n and \r formatting
583  *********************************************************************************
584  */
585
586 void lcd128x64puts (int x, int y, const char *str, int bgCol, int fgCol)
587 {
588   int c, mx, my ;
589
590   mx = x ; my = y ;
591
592   while (*str)
593   {
594     c = *str++ ;
595
596     if (c == '\r')
597     {
598       mx = x ;
599       continue ;
600     }
601
602     if (c == '\n')
603     {
604       mx  = x ;
605       my -= fontHeight ;
606       continue ;
607     }
608
609     lcd128x64putchar (mx, my, c, bgCol, fgCol) ;
610
611     mx += fontWidth ;
612     if (mx >= (maxX - fontWidth))
613     {
614       mx  = 0 ;
615       my -= fontHeight ;
616     }
617   }
618 }
619
620
621 /*
622  * lcd128x64clear:
623  *      Clear the display to the given colour.
624  *********************************************************************************
625  */
626
627 void lcd128x64clear (int colour)
628 {
629   register int i ;
630   register unsigned char *ptr = frameBuffer ;
631
632   for (i = 0 ; i < (maxX * maxY) ; ++i)
633     *ptr++ = colour ;
634 }
635
636
637
638
639 /*
640  * lcd128x64setup:
641  *      Initialise the display and GPIO.
642  *********************************************************************************
643  */
644
645 int lcd128x64setup (void)
646 {
647   int i ;
648
649   for (i = 0 ; i < 8 ; ++i)
650     pinMode (i, OUTPUT) ;
651
652   digitalWrite (CS1,    1) ;
653   digitalWrite (CS2,    1) ;
654   digitalWrite (STROBE, 0) ;
655   digitalWrite (RS,     1) ;
656
657   pinMode (CS1,    OUTPUT) ;
658   pinMode (CS2,    OUTPUT) ;
659   pinMode (STROBE, OUTPUT) ;
660   pinMode (RS,     OUTPUT) ;
661
662   sendCommand (0x3F, CS1) ;     // Display ON
663   sendCommand (0xC0, CS1) ;     // Set display start line to 0
664
665   sendCommand (0x3F, CS2) ;     // Display ON
666   sendCommand (0xC0, CS2) ;     // Set display start line to 0
667
668   lcd128x64clear          (0) ;
669   lcd128x64setOrientation (0) ;
670   lcd128x64update         () ;
671
672   return 0 ;
673 }