projects / hackover2013-badge-firmware.git / blob
? search:


f8e4ee4764a22b9a93a608f1231aff576f7fedc6
[hackover2013-badge-firmware.git] / drivers / displays / bitmap / ssd1306 / ssd1306.c
1 /**************************************************************************/
2 /*!
3 @file ssd1306.c
4 @author K. Townsend (microBuilder.eu)
5
6 @section DESCRIPTION
7
8 Driver for 128x64 OLED display based on the SSD1306 controller.
9
10 This driver is based on the SSD1306 Library from Limor Fried
11 (Adafruit Industries) at: https://github.com/adafruit/SSD1306
12
13 @section LICENSE
14
15 Software License Agreement (BSD License)
16
17 Copyright (c) 2012, microBuilder SARL
18 All rights reserved.
19
20 Redistribution and use in source and binary forms, with or without
21 modification, are permitted provided that the following conditions are met:
22 1. Redistributions of source code must retain the above copyright
23 notice, this list of conditions and the following disclaimer.
24 2. Redistributions in binary form must reproduce the above copyright
25 notice, this list of conditions and the following disclaimer in the
26 documentation and/or other materials provided with the distribution.
27 3. Neither the name of the copyright holders nor the
28 names of its contributors may be used to endorse or promote products
29 derived from this software without specific prior written permission.
30
31 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ''AS IS'' AND ANY
32 EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
33 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
34 DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
35 DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
36 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
37 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
38 ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
39 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
40 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
41 */
42 /**************************************************************************/
43 #include <string.h>
44
45 #include "ssd1306.h"
46
47 #include "core/gpio/gpio.h"
48 #include "core/i2c/i2c.h"
49 #include "core/systick/systick.h"
50 #include "drivers/displays/smallfonts.h"
51
52 #define DELAY(mS) do { systickDelay( mS / CFG_SYSTICK_DELAY_IN_MS ); } while(0);
53
54 // LCD framebuffer
55 uint8_t _ssd1306buffer[SSD1306_LCDWIDTH * SSD1306_LCDHEIGHT / 8];
56
57 #if defined SSD1306_BUS_I2C
58 void ssd1306SendCommand(uint8_t byte);
59 void ssd1306SendData(uint8_t data);
60
61 extern volatile uint8_t I2CMasterBuffer[I2C_BUFSIZE];
62 extern volatile uint8_t I2CSlaveBuffer[I2C_BUFSIZE];
63 extern volatile uint32_t I2CReadLength, I2CWriteLength;
64 #endif
65
66 #if defined SSD1306_BUS_SPI
67 void ssd1306SendByte(uint8_t byte);
68
69 #define CMD(c) do { gpioSetValue( SSD1306_CS_PORT, SSD1306_CS_PIN, 1 ); \
70 gpioSetValue( SSD1306_DC_PORT, SSD1306_DC_PIN, 0 ); \
71 gpioSetValue( SSD1306_CS_PORT, SSD1306_CS_PIN, 0 ); \
72 ssd1306SendByte( c ); \
73 gpioSetValue( SSD1306_CS_PORT, SSD1306_CS_PIN, 1 ); \
74 } while (0);
75 #define DATA(c) do { gpioSetValue( SSD1306_CS_PORT, SSD1306_CS_PIN, 1 ); \
76 gpioSetValue( SSD1306_DC_PORT, SSD1306_DC_PIN, 1 ); \
77 gpioSetValue( SSD1306_CS_PORT, SSD1306_CS_PIN, 0 ); \
78 ssd1306SendByte( c ); \
79 gpioSetValue( SSD1306_CS_PORT, SSD1306_CS_PIN, 1 ); \
80 } while (0);
81 #endif
82
83 /**************************************************************************/
84 /* Private Methods */
85 /**************************************************************************/
86
87 #if defined SSD1306_BUS_SPI
88 /**************************************************************************/
89 /*!
90 @brief Simulates an SPI write using GPIO
91
92 @param[in] byte
93 The byte to send
94 */
95 /**************************************************************************/
96 void ssd1306SendByte(uint8_t byte)
97 {
98 int8_t i;
99
100 // Make sure clock pin starts high
101 gpioSetValue(SSD1306_SCLK_PORT, SSD1306_SCLK_PIN, 1);
102
103 // Write from MSB to LSB
104 for (i=7; i>=0; i--)
105 {
106 // Set clock pin low
107 gpioSetValue(SSD1306_SCLK_PORT, SSD1306_SCLK_PIN, 0);
108 // Set data pin high or low depending on the value of the current bit
109 gpioSetValue(SSD1306_SDAT_PORT, SSD1306_SDAT_PIN, byte & (1 << i) ? 1 : 0);
110 // Set clock pin high
111 gpioSetValue(SSD1306_SCLK_PORT, SSD1306_SCLK_PIN, 1);
112 }
113 }
114 #endif
115
116 #if defined SSD1306_BUS_I2C
117 /**************************************************************************/
118 /*!
119 @brief Sends a command via I2C
120
121 @param[in] byte
122 The byte to send
123 */
124 /**************************************************************************/
125 void ssd1306SendCommand(uint8_t byte)
126 {
127 uint8_t control = 0x00; // Co = 0, D/C = 0
128 uint32_t i2cState;
129
130 // Clear write buffers
131 uint32_t i;
132 for ( i = 0; i < I2C_BUFSIZE; i++ )
133 {
134 I2CMasterBuffer[i] = 0x00;
135 }
136
137 // Send the specified bytes
138 I2CWriteLength = 3;
139 I2CReadLength = 0;
140 I2CMasterBuffer[0] = SSD1306_I2C_ADDRESS;
141 I2CMasterBuffer[1] = control;
142 I2CMasterBuffer[2] = byte;
143 i2cState = i2cEngine();
144
145 // Check if we got an ACK
146 if ((i2cState == I2CSTATE_NACK) || (i2cState == I2CSTATE_SLA_NACK))
147 {
148 // I2C slave didn't acknowledge the master transfer
149 // The PN532 probably isn't connected properly or the
150 // bus select pins are in the wrong state
151 // return PN532_ERROR_NACK;
152 }
153
154 // return PN532_ERROR_NONE;
155 }
156
157 /**************************************************************************/
158 /*!
159 @brief Sends data via I2C
160
161 @param[in] byte
162 The byte to send
163 */
164 /**************************************************************************/
165 void ssd1306SendData(uint8_t data)
166 {
167 uint8_t control = 0x40; // Co = 0, D/C = 1
168 uint32_t i2cState;
169
170 // Clear write buffers
171 uint32_t i;
172 for ( i = 0; i < I2C_BUFSIZE; i++ )
173 {
174 I2CMasterBuffer[i] = 0x00;
175 }
176
177 // Send the specified bytes
178 I2CWriteLength = 3;
179 I2CReadLength = 0;
180 I2CMasterBuffer[0] = SSD1306_I2C_ADDRESS;
181 I2CMasterBuffer[1] = control;
182 I2CMasterBuffer[2] = data;
183 i2cState = i2cEngine();
184
185 // Check if we got an ACK
186 if ((i2cState == I2CSTATE_NACK) || (i2cState == I2CSTATE_SLA_NACK))
187 {
188 // I2C slave didn't acknowledge the master transfer
189 // The PN532 probably isn't connected properly or the
190 // bus select pins are in the wrong state
191 // return PN532_ERROR_NACK;
192 }
193
194 // return PN532_ERROR_NONE;
195 }
196 #endif
197
198 /**************************************************************************/
199 /*!
200 @brief Draws a single graphic character using the supplied font
201 */
202 /**************************************************************************/
203 static void ssd1306DrawChar(uint16_t x, uint16_t y, uint8_t c, struct FONT_DEF font)
204 {
205 uint8_t col, column[font.u8Width];
206
207 // Make sure we are exceeding the display limits
208 // This also gets checked in ssd1306DrawPixel, but if we start
209 // outside the limits we can avoid some unecessary work at the outset
210 if ((x > SSD1306_LCDWIDTH) || (y > SSD1306_LCDHEIGHT))
211 return;
212
213 // Check if the requested character is available
214 if ((c >= font.u8FirstChar) && (c <= font.u8LastChar))
215 {
216 // Retrieve appropriate columns from font data
217 for (col = 0; col < font.u8Width; col++)
218 {
219 column[col] = font.au8FontTable[((c - 32) * font.u8Width) + col]; // Get first column of appropriate character
220 }
221 }
222 else
223 {
224 // Requested character is not available in this font ... send a space instead
225 for (col = 0; col < font.u8Width; col++)
226 {
227 column[col] = 0xFF; // Send solid space
228 }
229 }
230
231 // Render each column
232 uint16_t xoffset, yoffset;
233 for (xoffset = 0; xoffset < font.u8Width; xoffset++)
234 {
235 for (yoffset = 0; yoffset < (font.u8Height + 1); yoffset++)
236 {
237 uint8_t bit = 0x00;
238 bit = (column[xoffset] << (8 - (yoffset + 1))); // Shift current row bit left
239 bit = (bit >> 7); // Shift current row but right (results in 0x01 for black, and 0x00 for white)
240 if (bit)
241 {
242 ssd1306DrawPixel(x + xoffset, y + yoffset);
243 }
244 }
245 }
246 }
247
248 /**************************************************************************/
249 /* Public Methods */
250 /**************************************************************************/
251
252 /**************************************************************************/
253 /*!
254 @brief Initialises the SSD1306 LCD display
255 */
256 /**************************************************************************/
257 void ssd1306Init(uint8_t vccstate)
258 {
259 // SPI Initialisation
260 #if defined SSD1306_BUS_SPI
261 // Set all pins to output
262 gpioSetDir(SSD1306_SCLK_PORT, SSD1306_SCLK_PIN, gpioDirection_Output);
263 gpioSetDir(SSD1306_SDAT_PORT, SSD1306_SDAT_PIN, gpioDirection_Output);
264 gpioSetDir(SSD1306_DC_PORT, SSD1306_DC_PIN, gpioDirection_Output);
265 gpioSetDir(SSD1306_RST_PORT, SSD1306_RST_PIN, gpioDirection_Output);
266 gpioSetDir(SSD1306_CS_PORT, SSD1306_CS_PIN, gpioDirection_Output);
267
268 // Reset the LCD
269 gpioSetValue(SSD1306_RST_PORT, SSD1306_RST_PIN, 1);
270 DELAY(1);
271 gpioSetValue(SSD1306_RST_PORT, SSD1306_RST_PIN, 0);
272 DELAY(10);
273 gpioSetValue(SSD1306_RST_PORT, SSD1306_RST_PIN, 1);
274
275 #if defined SSD1306_128_32
276 // Init sequence taken from datasheet for UG-2832HSWEG04 (128x32 OLED module)
277 CMD(SSD1306_DISPLAYOFF); // 0xAE
278 CMD(SSD1306_SETDISPLAYCLOCKDIV); // 0xD5
279 CMD(0x80); // the suggested ratio 0x80
280 CMD(SSD1306_SETMULTIPLEX); // 0xA8
281 CMD(0x1F); // 31
282 CMD(SSD1306_SETDISPLAYOFFSET); // 0xD3
283 CMD(0x0); // no offset
284 CMD(SSD1306_SETSTARTLINE | 0x0); // line #0
285 CMD(SSD1306_CHARGEPUMP); // 0x8D
286 if (vccstate == SSD1306_EXTERNALVCC)
287 { CMD(0x10) }
288 else
289 { CMD(0x14) }
290 CMD(SSD1306_MEMORYMODE); // 0x20
291 CMD(0x00); // 0x0 act like ks0108
292 CMD(SSD1306_SEGREMAP | 0x1);
293 CMD(SSD1306_COMSCANDEC);
294 CMD(SSD1306_SETCOMPINS); // 0xDA
295 CMD(0x02);
296 CMD(SSD1306_SETCONTRAST); // 0x81
297 if (vccstate == SSD1306_EXTERNALVCC)
298 { CMD(0x9F) }
299 else
300 { CMD(0xCF) }
301 CMD(SSD1306_SETPRECHARGE); // 0xd9
302 if (vccstate == SSD1306_EXTERNALVCC)
303 { CMD(0x22) }
304 else
305 { CMD(0xF1) }
306 CMD(SSD1306_SETVCOMDETECT); // 0xDB
307 CMD(0x40);
308 CMD(SSD1306_DISPLAYALLON_RESUME); // 0xA4
309 CMD(SSD1306_NORMALDISPLAY); // 0xA6
310 #endif
311
312 #if defined SSD1306_128_64
313 // Init sequence taken from datasheet for UG-2864HSWEG01 (128x64 OLED module)
314 CMD(SSD1306_DISPLAYOFF); // 0xAE
315 CMD(SSD1306_SETDISPLAYCLOCKDIV); // 0xD5
316 CMD(0x80); // the suggested ratio 0x80
317 CMD(SSD1306_SETMULTIPLEX); // 0xA8
318 CMD(0x3F); // 63
319 CMD(SSD1306_SETDISPLAYOFFSET); // 0xD3
320 CMD(0x0); // no offset
321 CMD(SSD1306_SETSTARTLINE | 0x0); // line #0
322 CMD(SSD1306_CHARGEPUMP); // 0x8D
323 if (vccstate == SSD1306_EXTERNALVCC)
324 { CMD(0x10) }
325 else
326 { CMD(0x14) }
327 CMD(SSD1306_MEMORYMODE); // 0x20
328 CMD(0x00); // 0x0 act like ks0108
329 CMD(SSD1306_SEGREMAP | 0x1);
330 CMD(SSD1306_COMSCANDEC);
331 CMD(SSD1306_SETCOMPINS); // 0xDA
332 CMD(0x12);
333 CMD(SSD1306_SETCONTRAST); // 0x81
334 if (vccstate == SSD1306_EXTERNALVCC)
335 { CMD(0x9F) }
336 else
337 { CMD(0xCF) }
338 CMD(SSD1306_SETPRECHARGE); // 0xd9
339 if (vccstate == SSD1306_EXTERNALVCC)
340 { CMD(0x22) }
341 else
342 { CMD(0xF1) }
343 CMD(SSD1306_SETVCOMDETECT); // 0xDB
344 CMD(0x40);
345 CMD(SSD1306_DISPLAYALLON_RESUME); // 0xA4
346 CMD(SSD1306_NORMALDISPLAY); // 0xA6
347 #endif
348 // Enabled the OLED panel
349 CMD(SSD1306_DISPLAYON);
350 #endif
351
352 // I2C Initialisation
353 #if defined SSD1306_BUS_I2C
354 #if defined SSD1306_128_32
355 // Init sequence taken from datasheet for UG-2832HSWEG04 (128x32 OLED module)
356 ssd1306SendCommand(SSD1306_DISPLAYOFF); // 0xAE
357 ssd1306SendCommand(SSD1306_SETDISPLAYCLOCKDIV); // 0xD5
358 ssd1306SendCommand(0x80); // the suggested ratio 0x80
359 ssd1306SendCommand(SSD1306_SETMULTIPLEX); // 0xA8
360 ssd1306SendCommand(0x1F); // 31
361 ssd1306SendCommand(SSD1306_SETDISPLAYOFFSET); // 0xD3
362 ssd1306SendCommand(0x0); // no offset
363 ssd1306SendCommand(SSD1306_SETSTARTLINE | 0x0); // line #0
364 ssd1306SendCommand(SSD1306_CHARGEPUMP); // 0x8D
365 if (vccstate == SSD1306_EXTERNALVCC)
366 { ssd1306SendCommand(0x10); }
367 else
368 { ssd1306SendCommand(0x14); }
369 ssd1306SendCommand(SSD1306_MEMORYMODE); // 0x20
370 ssd1306SendCommand(0x00); // 0x0 act like ks0108
371 ssd1306SendCommand(SSD1306_SEGREMAP | 0x1);
372 ssd1306SendCommand(SSD1306_COMSCANDEC);
373 ssd1306SendCommand(SSD1306_SETCOMPINS); // 0xDA
374 ssd1306SendCommand(0x02);
375 ssd1306SendCommand(SSD1306_SETCONTRAST); // 0x81
376 if (vccstate == SSD1306_EXTERNALVCC)
377 { ssd1306SendCommand(0x9F); }
378 else
379 { ssd1306SendCommand(0xCF); }
380 ssd1306SendCommand(SSD1306_SETPRECHARGE); // 0xd9
381 if (vccstate == SSD1306_EXTERNALVCC)
382 { ssd1306SendCommand(0x22); }
383 else
384 { ssd1306SendCommand(0xF1); }
385 ssd1306SendCommand(SSD1306_SETVCOMDETECT); // 0xDB
386 ssd1306SendCommand(0x40);
387 ssd1306SendCommand(SSD1306_DISPLAYALLON_RESUME); // 0xA4
388 ssd1306SendCommand(SSD1306_NORMALDISPLAY); // 0xA6
389 #endif
390
391 #if defined SSD1306_128_64
392 // Init sequence taken from datasheet for UG-2864HSWEG01 (128x64 OLED module)
393 ssd1306SendCommand(SSD1306_DISPLAYOFF); // 0xAE
394 ssd1306SendCommand(SSD1306_SETDISPLAYCLOCKDIV); // 0xD5
395 ssd1306SendCommand(0x80); // the suggested ratio 0x80
396 ssd1306SendCommand(SSD1306_SETMULTIPLEX); // 0xA8
397 ssd1306SendCommand(0x3F); // 63
398 ssd1306SendCommand(SSD1306_SETDISPLAYOFFSET); // 0xD3
399 ssd1306SendCommand(0x0); // no offset
400 ssd1306SendCommand(SSD1306_SETSTARTLINE | 0x0); // line #0
401 ssd1306SendCommand(SSD1306_CHARGEPUMP); // 0x8D
402 if (vccstate == SSD1306_EXTERNALVCC)
403 { ssd1306SendCommand(0x10); }
404 else
405 { ssd1306SendCommand(0x14); }
406 ssd1306SendCommand(SSD1306_MEMORYMODE); // 0x20
407 ssd1306SendCommand(0x00); // 0x0 act like ks0108
408 ssd1306SendCommand(SSD1306_SEGREMAP | 0x1);
409 ssd1306SendCommand(SSD1306_COMSCANDEC);
410 ssd1306SendCommand(SSD1306_SETCOMPINS); // 0xDA
411 ssd1306SendCommand(0x12);
412 ssd1306SendCommand(SSD1306_SETCONTRAST); // 0x81
413 if (vccstate == SSD1306_EXTERNALVCC)
414 { ssd1306SendCommand(0x9F); }
415 else
416 { ssd1306SendCommand(0xCF); }
417 ssd1306SendCommand(SSD1306_SETPRECHARGE); // 0xd9
418 if (vccstate == SSD1306_EXTERNALVCC)
419 { ssd1306SendCommand(0x22); }
420 else
421 { ssd1306SendCommand(0xF1); }
422 ssd1306SendCommand(SSD1306_SETVCOMDETECT); // 0xDB
423 ssd1306SendCommand(0x40);
424 ssd1306SendCommand(SSD1306_DISPLAYALLON_RESUME); // 0xA4
425 ssd1306SendCommand(SSD1306_NORMALDISPLAY); // 0xA6
426 #endif
427 // Enable the OLED panel
428 ssd1306SendCommand(SSD1306_DISPLAYON);
429 #endif
430 }
431
432 /**************************************************************************/
433 /*!
434 @brief Draws a single pixel in image buffer
435
436 @param[in] x
437 The x position (0..127)
438 @param[in] y
439 The y position (0..63)
440 */
441 /**************************************************************************/
442 void ssd1306DrawPixel(uint8_t x, uint8_t y)
443 {
444 if ((x >= SSD1306_LCDWIDTH) || (y >= SSD1306_LCDHEIGHT))
445 return;
446
447 _ssd1306buffer[x+ (y/8)*SSD1306_LCDWIDTH] |= (1 << y%8);
448 }
449
450 /**************************************************************************/
451 /*!
452 @brief Clears a single pixel in image buffer
453
454 @param[in] x
455 The x position (0..127)
456 @param[in] y
457 The y position (0..63)
458 */
459 /**************************************************************************/
460 void ssd1306ClearPixel(uint8_t x, uint8_t y)
461 {
462 if ((x >= SSD1306_LCDWIDTH) || (y >= SSD1306_LCDHEIGHT))
463 return;
464
465 _ssd1306buffer[x+ (y/8)*SSD1306_LCDWIDTH] &= ~(1 << y%8);
466 }
467
468 /**************************************************************************/
469 /*!
470 @brief Gets the value (1 or 0) of the specified pixel from the buffer
471
472 @param[in] x
473 The x position (0..127)
474 @param[in] y
475 The y position (0..63)
476
477 @return 1 if the pixel is enabled, 0 if disabled
478 */
479 /**************************************************************************/
480 uint8_t ssd1306GetPixel(uint8_t x, uint8_t y)
481 {
482 if ((x >= SSD1306_LCDWIDTH) || (y >=SSD1306_LCDHEIGHT)) return 0;
483 return _ssd1306buffer[x+ (y/8)*SSD1306_LCDWIDTH] & (1 << y%8) ? 1 : 0;
484 }
485
486 /**************************************************************************/
487 /*!
488 @brief Clears the screen
489 */
490 /**************************************************************************/
491 void ssd1306ClearScreen()
492 {
493 memset(_ssd1306buffer, 0, 1024);
494 }
495
496 /**************************************************************************/
497 /*!
498 @brief Renders the contents of the pixel buffer on the LCD
499 */
500 /**************************************************************************/
501 void ssd1306Refresh(void)
502 {
503 #if defined SSD1306_BUS_SPI
504 CMD(SSD1306_SETLOWCOLUMN | 0x0); // low col = 0
505 CMD(SSD1306_SETHIGHCOLUMN | 0x0); // hi col = 0
506 CMD(SSD1306_SETSTARTLINE | 0x0); // line #0
507
508 uint16_t i;
509 for (i=0; i<1024; i++)
510 {
511 DATA(_ssd1306buffer[i]);
512 }
513 #endif
514
515 #if defined SSD1306_BUS_I2C
516 ssd1306SendCommand(SSD1306_SETLOWCOLUMN | 0x0); // low col = 0
517 ssd1306SendCommand(SSD1306_SETHIGHCOLUMN | 0x0); // hi col = 0
518 ssd1306SendCommand(SSD1306_SETSTARTLINE | 0x0); // line #0
519
520 uint16_t i;
521 for (i=0; i<1024; i++)
522 {
523 ssd1306SendData(_ssd1306buffer[i]);
524 }
525 #endif
526 }
527
528 /**************************************************************************/
529 /*!
530 @brief Draws a string using the supplied font data.
531
532 @param[in] x
533 Starting x co-ordinate
534 @param[in] y
535 Starting y co-ordinate
536 @param[in] text
537 The string to render
538 @param[in] font
539 Pointer to the FONT_DEF to use when drawing the string
540
541 @section Example
542
543 @code
544
545 #include "drivers/displays/bitmap/ssd1306/ssd1306.h"
546 #include "drivers/displays/smallfonts.h"
547
548 // Configure the pins and initialise the LCD screen
549 ssd1306Init(SSD1306_INTERNALVCC);
550
551 // Render some text on the screen
552 ssd1306DrawString(1, 10, "5x8 System", Font_System5x8);
553 ssd1306DrawString(1, 20, "7x8 System", Font_System7x8);
554
555 // Refresh the screen to see the results
556 ssd1306Refresh();
557
558 @endcode
559 */
560 /**************************************************************************/
561 void ssd1306DrawString(uint16_t x, uint16_t y, char* text, struct FONT_DEF font)
562 {
563 uint8_t l;
564 for (l = 0; l < strlen(text); l++)
565 {
566 ssd1306DrawChar(x + (l * (font.u8Width + 1)), y, text[l], font);
567 }
568 }
569
570 /**************************************************************************/
571 /*!
572 @brief Shifts the contents of the frame buffer up the specified
573 number of pixels
574
575 @param[in] height
576 The number of pixels to shift the frame buffer up, leaving
577 a blank space at the bottom of the frame buffer x pixels
578 high
579
580 @section Example
581
582 @code
583
584 #include "drivers/displays/bitmap/ssd1306/ssd1306.h"
585 #include "drivers/displays/smallfonts.h"
586
587 // Configure the pins and initialise the LCD screen
588 ssd1306Init(SSD1306_INTERNALVCC);
589
590 // Continually write some text, scrolling upward one line each time
591 while (1)
592 {
593 // Shift the buffer up 8 pixels (adjust for font-height)
594 ssd1306ShiftFrameBuffer(8);
595 // Render some text on the screen with different fonts
596 ssd1306DrawString(1, 56, "INSERT TEXT HERE", Font_System5x8);
597 // Refresh the screen to see the results
598 ssd1306Refresh();
599 // Wait a bit before writing the next line
600 systickDelay(1000);
601 }
602
603 @endcode
604 */
605 /**************************************************************************/
606 void ssd1306ShiftFrameBuffer( uint8_t height )
607 {
608 if (height == 0) return;
609 if (height >= SSD1306_LCDHEIGHT)
610 {
611 // Clear the entire frame buffer
612 ssd1306ClearScreen();
613 return;
614 }
615
616 // This is horribly inefficient, but at least easy to understand
617 // In a production environment, this should be significantly optimised
618
619 uint8_t y, x;
620 for (y = 0; y < SSD1306_LCDHEIGHT; y++)
621 {
622 for (x = 0; x < SSD1306_LCDWIDTH; x++)
623 {
624 if ((SSD1306_LCDHEIGHT - 1) - y > height)
625 {
626 // Shift height from further ahead in the buffer
627 ssd1306GetPixel(x, y + height) ? ssd1306DrawPixel(x, y) : ssd1306ClearPixel(x, y);
628 }
629 else
630 {
631 // Clear the entire line
632 ssd1306ClearPixel(x, y);
633 }
634 }
635 }
636 }
Unnamed repository; edit this file 'description' to name the repository.
This page took 0.092188 seconds and 3 git commands to generate.