]> git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/CORTEX_LM3Sxxxx_Rowley/osram128x64x4.c
Add FreeRTOS-Plus directory.
[freertos] / FreeRTOS / Demo / CORTEX_LM3Sxxxx_Rowley / osram128x64x4.c
1 //*****************************************************************************\r
2 //\r
3 // osram128x64x4.c - Driver for the OSRAM 128x64x4 graphical OLED display.\r
4 //\r
5 // Copyright (c) 2006-2007 Luminary Micro, Inc.  All rights reserved.\r
6 // \r
7 // Software License Agreement\r
8 // \r
9 // Luminary Micro, Inc. (LMI) is supplying this software for use solely and\r
10 // exclusively on LMI's microcontroller products.\r
11 // \r
12 // The software is owned by LMI and/or its suppliers, and is protected under\r
13 // applicable copyright laws.  All rights are reserved.  Any use in violation\r
14 // of the foregoing restrictions may subject the user to criminal sanctions\r
15 // under applicable laws, as well as to civil liability for the breach of the\r
16 // terms and conditions of this license.\r
17 // \r
18 // THIS SOFTWARE IS PROVIDED "AS IS".  NO WARRANTIES, WHETHER EXPRESS, IMPLIED\r
19 // OR STATUTORY, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF\r
20 // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE.\r
21 // LMI SHALL NOT, IN ANY CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR\r
22 // CONSEQUENTIAL DAMAGES, FOR ANY REASON WHATSOEVER.\r
23 // \r
24 // This is part of revision 1408 of the Stellaris Peripheral Driver Library.\r
25 //\r
26 //*****************************************************************************\r
27 \r
28 //*****************************************************************************\r
29 //\r
30 //! \addtogroup ek_lm3sx965_api\r
31 //! @{\r
32 //\r
33 //*****************************************************************************\r
34 \r
35 #include "hw_ssi.h"\r
36 #include "hw_memmap.h"\r
37 #include "hw_sysctl.h"\r
38 #include "hw_types.h"\r
39 #include "debug.h"\r
40 #include "gpio.h"\r
41 #include "ssi.h"\r
42 #include "sysctl.h"\r
43 #include "osram128x64x4.h"\r
44 \r
45 //*****************************************************************************\r
46 //\r
47 // Flag to indicate if SSI port is enabled for OSRAM usage.\r
48 //\r
49 //*****************************************************************************\r
50 static volatile tBoolean g_bSSIEnabled = false;\r
51 \r
52 //*****************************************************************************\r
53 //\r
54 // Define the OSRAM 128x64x4 Remap Setting(s).  This will be used in\r
55 // several places in the code to switch between vertical and horizontal\r
56 // address incrementing.\r
57 //\r
58 // The Remap Command (0xA0) takes one 8-bit parameter.  The parameter is\r
59 // defined as follows.\r
60 //\r
61 // Bit 7: Reserved\r
62 // Bit 6: Disable(0)/Enable(1) COM Split Odd Even\r
63 //        When enabled, the COM signals are split Odd on one side, even on\r
64 //        the other.  Otherwise, they are split 0-39 on one side, 40-79 on\r
65 //        the other.\r
66 // Bit 5: Reserved\r
67 // Bit 4: Disable(0)/Enable(1) COM Remap\r
68 //        When Enabled, ROW 0-79 map to COM 79-0 (i.e. reverse row order)\r
69 // Bit 3: Reserved\r
70 // Bit 2: Horizontal(0)/Vertical(1) Address Increment\r
71 //        When set, data RAM address will increment along the column rather\r
72 //        than along the row.\r
73 // Bit 1: Disable(0)/Enable(1) Nibble Remap\r
74 //        When enabled, the upper and lower nibbles in the DATA bus for access\r
75 //        to the data RAM are swapped.\r
76 // Bit 0: Disable(0)/Enable(1) Column Address Remap\r
77 //        When enabled, DATA RAM columns 0-63 are remapped to Segment Columns\r
78 //        127-0.\r
79 //\r
80 //*****************************************************************************\r
81 #define OSRAM_INIT_REMAP    0x52\r
82 #define OSRAM_INIT_OFFSET   0x4C\r
83 static const unsigned char g_pucOSRAM128x64x4VerticalInc[]   = { 0xA0, 0x56 };\r
84 static const unsigned char g_pucOSRAM128x64x4HorizontalInc[] = { 0xA0, 0x52 };\r
85 \r
86 //*****************************************************************************\r
87 //\r
88 // A 5x7 font (in a 6x8 cell, where the sixth column is omitted from this\r
89 // table) for displaying text on the OLED display.  The data is organized as\r
90 // bytes from the left column to the right column, with each byte containing\r
91 // the top row in the LSB and the bottom row in the MSB.\r
92 //\r
93 // Note:  This is the same font data that is used in the EK-LM3S811\r
94 // osram96x16x1 driver.  The single bit-per-pixel is expaned in the StringDraw\r
95 // function to the appropriate four bit-per-pixel gray scale format.\r
96 //\r
97 //*****************************************************************************\r
98 static const unsigned char g_pucFont[96][5] =\r
99 {\r
100     { 0x00, 0x00, 0x00, 0x00, 0x00 }, // " "\r
101     { 0x00, 0x00, 0x4f, 0x00, 0x00 }, // !\r
102     { 0x00, 0x07, 0x00, 0x07, 0x00 }, // "\r
103     { 0x14, 0x7f, 0x14, 0x7f, 0x14 }, // #\r
104     { 0x24, 0x2a, 0x7f, 0x2a, 0x12 }, // $\r
105     { 0x23, 0x13, 0x08, 0x64, 0x62 }, // %\r
106     { 0x36, 0x49, 0x55, 0x22, 0x50 }, // &\r
107     { 0x00, 0x05, 0x03, 0x00, 0x00 }, // '\r
108     { 0x00, 0x1c, 0x22, 0x41, 0x00 }, // (\r
109     { 0x00, 0x41, 0x22, 0x1c, 0x00 }, // )\r
110     { 0x14, 0x08, 0x3e, 0x08, 0x14 }, // *\r
111     { 0x08, 0x08, 0x3e, 0x08, 0x08 }, // +\r
112     { 0x00, 0x50, 0x30, 0x00, 0x00 }, // ,\r
113     { 0x08, 0x08, 0x08, 0x08, 0x08 }, // -\r
114     { 0x00, 0x60, 0x60, 0x00, 0x00 }, // .\r
115     { 0x20, 0x10, 0x08, 0x04, 0x02 }, // /\r
116     { 0x3e, 0x51, 0x49, 0x45, 0x3e }, // 0\r
117     { 0x00, 0x42, 0x7f, 0x40, 0x00 }, // 1\r
118     { 0x42, 0x61, 0x51, 0x49, 0x46 }, // 2\r
119     { 0x21, 0x41, 0x45, 0x4b, 0x31 }, // 3\r
120     { 0x18, 0x14, 0x12, 0x7f, 0x10 }, // 4\r
121     { 0x27, 0x45, 0x45, 0x45, 0x39 }, // 5\r
122     { 0x3c, 0x4a, 0x49, 0x49, 0x30 }, // 6\r
123     { 0x01, 0x71, 0x09, 0x05, 0x03 }, // 7\r
124     { 0x36, 0x49, 0x49, 0x49, 0x36 }, // 8\r
125     { 0x06, 0x49, 0x49, 0x29, 0x1e }, // 9\r
126     { 0x00, 0x36, 0x36, 0x00, 0x00 }, // :\r
127     { 0x00, 0x56, 0x36, 0x00, 0x00 }, // ;\r
128     { 0x08, 0x14, 0x22, 0x41, 0x00 }, // <\r
129     { 0x14, 0x14, 0x14, 0x14, 0x14 }, // =\r
130     { 0x00, 0x41, 0x22, 0x14, 0x08 }, // >\r
131     { 0x02, 0x01, 0x51, 0x09, 0x06 }, // ?\r
132     { 0x32, 0x49, 0x79, 0x41, 0x3e }, // @\r
133     { 0x7e, 0x11, 0x11, 0x11, 0x7e }, // A\r
134     { 0x7f, 0x49, 0x49, 0x49, 0x36 }, // B\r
135     { 0x3e, 0x41, 0x41, 0x41, 0x22 }, // C\r
136     { 0x7f, 0x41, 0x41, 0x22, 0x1c }, // D\r
137     { 0x7f, 0x49, 0x49, 0x49, 0x41 }, // E\r
138     { 0x7f, 0x09, 0x09, 0x09, 0x01 }, // F\r
139     { 0x3e, 0x41, 0x49, 0x49, 0x7a }, // G\r
140     { 0x7f, 0x08, 0x08, 0x08, 0x7f }, // H\r
141     { 0x00, 0x41, 0x7f, 0x41, 0x00 }, // I\r
142     { 0x20, 0x40, 0x41, 0x3f, 0x01 }, // J\r
143     { 0x7f, 0x08, 0x14, 0x22, 0x41 }, // K\r
144     { 0x7f, 0x40, 0x40, 0x40, 0x40 }, // L\r
145     { 0x7f, 0x02, 0x0c, 0x02, 0x7f }, // M\r
146     { 0x7f, 0x04, 0x08, 0x10, 0x7f }, // N\r
147     { 0x3e, 0x41, 0x41, 0x41, 0x3e }, // O\r
148     { 0x7f, 0x09, 0x09, 0x09, 0x06 }, // P\r
149     { 0x3e, 0x41, 0x51, 0x21, 0x5e }, // Q\r
150     { 0x7f, 0x09, 0x19, 0x29, 0x46 }, // R\r
151     { 0x46, 0x49, 0x49, 0x49, 0x31 }, // S\r
152     { 0x01, 0x01, 0x7f, 0x01, 0x01 }, // T\r
153     { 0x3f, 0x40, 0x40, 0x40, 0x3f }, // U\r
154     { 0x1f, 0x20, 0x40, 0x20, 0x1f }, // V\r
155     { 0x3f, 0x40, 0x38, 0x40, 0x3f }, // W\r
156     { 0x63, 0x14, 0x08, 0x14, 0x63 }, // X\r
157     { 0x07, 0x08, 0x70, 0x08, 0x07 }, // Y\r
158     { 0x61, 0x51, 0x49, 0x45, 0x43 }, // Z\r
159     { 0x00, 0x7f, 0x41, 0x41, 0x00 }, // [\r
160     { 0x02, 0x04, 0x08, 0x10, 0x20 }, // "\"\r
161     { 0x00, 0x41, 0x41, 0x7f, 0x00 }, // ]\r
162     { 0x04, 0x02, 0x01, 0x02, 0x04 }, // ^\r
163     { 0x40, 0x40, 0x40, 0x40, 0x40 }, // _\r
164     { 0x00, 0x01, 0x02, 0x04, 0x00 }, // `\r
165     { 0x20, 0x54, 0x54, 0x54, 0x78 }, // a\r
166     { 0x7f, 0x48, 0x44, 0x44, 0x38 }, // b\r
167     { 0x38, 0x44, 0x44, 0x44, 0x20 }, // c\r
168     { 0x38, 0x44, 0x44, 0x48, 0x7f }, // d\r
169     { 0x38, 0x54, 0x54, 0x54, 0x18 }, // e\r
170     { 0x08, 0x7e, 0x09, 0x01, 0x02 }, // f\r
171     { 0x0c, 0x52, 0x52, 0x52, 0x3e }, // g\r
172     { 0x7f, 0x08, 0x04, 0x04, 0x78 }, // h\r
173     { 0x00, 0x44, 0x7d, 0x40, 0x00 }, // i\r
174     { 0x20, 0x40, 0x44, 0x3d, 0x00 }, // j\r
175     { 0x7f, 0x10, 0x28, 0x44, 0x00 }, // k\r
176     { 0x00, 0x41, 0x7f, 0x40, 0x00 }, // l\r
177     { 0x7c, 0x04, 0x18, 0x04, 0x78 }, // m\r
178     { 0x7c, 0x08, 0x04, 0x04, 0x78 }, // n\r
179     { 0x38, 0x44, 0x44, 0x44, 0x38 }, // o\r
180     { 0x7c, 0x14, 0x14, 0x14, 0x08 }, // p\r
181     { 0x08, 0x14, 0x14, 0x18, 0x7c }, // q\r
182     { 0x7c, 0x08, 0x04, 0x04, 0x08 }, // r\r
183     { 0x48, 0x54, 0x54, 0x54, 0x20 }, // s\r
184     { 0x04, 0x3f, 0x44, 0x40, 0x20 }, // t\r
185     { 0x3c, 0x40, 0x40, 0x20, 0x7c }, // u\r
186     { 0x1c, 0x20, 0x40, 0x20, 0x1c }, // v\r
187     { 0x3c, 0x40, 0x30, 0x40, 0x3c }, // w\r
188     { 0x44, 0x28, 0x10, 0x28, 0x44 }, // x\r
189     { 0x0c, 0x50, 0x50, 0x50, 0x3c }, // y\r
190     { 0x44, 0x64, 0x54, 0x4c, 0x44 }, // z\r
191     { 0x00, 0x08, 0x36, 0x41, 0x00 }, // {\r
192     { 0x00, 0x00, 0x7f, 0x00, 0x00 }, // |\r
193     { 0x00, 0x41, 0x36, 0x08, 0x00 }, // }\r
194     { 0x02, 0x01, 0x02, 0x04, 0x02 }, // ~\r
195     { 0x02, 0x01, 0x02, 0x04, 0x02 }, // ~\r
196 };\r
197 \r
198 //*****************************************************************************\r
199 //\r
200 // The sequence of commands used to initialize the SSD0303 controller.  Each\r
201 // command is described as follows:  there is a byte specifying the number of\r
202 // bytes in the command sequence, followed by that many bytes of command data.\r
203 // Note:  This initialization sequence is derived from OSRAM App Note AN018.\r
204 //\r
205 //*****************************************************************************\r
206 static const unsigned char g_pucOSRAM128x64x4Init[] =\r
207 {\r
208     //\r
209     // Column Address\r
210     //\r
211     4, 0x15, 0, 63, 0xe3,\r
212 \r
213     //\r
214     // Row Address\r
215     //\r
216     4, 0x75, 0, 63, 0xe3,\r
217 \r
218     //\r
219     // Contrast Control\r
220     //\r
221     3, 0x81, 50, 0xe3,\r
222 \r
223     //\r
224     // Half Current Range\r
225     //\r
226     2, 0x85, 0xe3,\r
227 \r
228     //\r
229     // Display Re-map\r
230     //\r
231     3, 0xA0, OSRAM_INIT_REMAP, 0xe3,\r
232 \r
233     //\r
234     // Display Start Line\r
235     //\r
236     3, 0xA1, 0, 0xe3,\r
237 \r
238     //\r
239     // Display Offset\r
240     //\r
241     3, 0xA2, OSRAM_INIT_OFFSET, 0xe3,\r
242 \r
243     //\r
244     // Display Mode Normal\r
245     //\r
246     2, 0xA4, 0xe3,\r
247 \r
248     //\r
249     // Multiplex Ratio\r
250     //\r
251     3, 0xA8, 63, 0xe3,\r
252 \r
253     //\r
254     // Phase Length\r
255     //\r
256     3, 0xB1, 0x22, 0xe3,\r
257 \r
258     //\r
259     // Row Period\r
260     //\r
261     3, 0xB2, 70, 0xe3,\r
262 \r
263     //\r
264     // Display Clock Divide\r
265     //\r
266     3, 0xB3, 0xF1, 0xe3,\r
267 \r
268     //\r
269     // VSL\r
270     //\r
271     3, 0xBF, 0x0D, 0xe3,\r
272 \r
273     //\r
274     // VCOMH\r
275     //\r
276     3, 0xBE, 0x02, 0xe3,\r
277 \r
278     //\r
279     // VP\r
280     //\r
281     3, 0xBC, 0x10, 0xe3,\r
282 \r
283     //\r
284     // Gamma\r
285     //\r
286     10, 0xB8, 0x01, 0x11, 0x22, 0x32, 0x43, 0x54, 0x65, 0x76, 0xe3,\r
287 \r
288     //\r
289     // Set DC-DC\r
290     3, 0xAD, 0x03, 0xe3,\r
291 \r
292     //\r
293     // Display ON/OFF\r
294     //\r
295     2, 0xAF, 0xe3,\r
296 };\r
297 \r
298 //*****************************************************************************\r
299 //\r
300 //! \internal\r
301 //!\r
302 //! Write a sequence of command bytes to the SSD0323 controller.\r
303 //!\r
304 //! The data is written in a polled fashion; this function will not return\r
305 //! until the entire byte sequence has been written to the controller.\r
306 //!\r
307 //! \return None.\r
308 //\r
309 //*****************************************************************************\r
310 static void\r
311 OSRAMWriteCommand(const unsigned char *pucBuffer, unsigned long ulCount)\r
312 {\r
313     unsigned long ulTemp;\r
314 \r
315     //\r
316     // Return iff SSI port is not enabled for OSRAM.\r
317     //\r
318     if(!g_bSSIEnabled)\r
319     {\r
320         return;\r
321     }\r
322 \r
323     //\r
324     // Clear the command/control bit to enable command mode.\r
325     //\r
326     GPIOPinWrite(GPIO_PORTC_BASE, GPIO_PIN_7, 0);\r
327 \r
328     //\r
329     // Loop while there are more bytes left to be transferred.\r
330     //\r
331     while(ulCount != 0)\r
332     {\r
333         //\r
334         // Write the next byte to the controller.\r
335         //\r
336         SSIDataPut(SSI0_BASE, *pucBuffer++);\r
337 \r
338         //\r
339         // Dummy read to drain the fifo and time the GPIO signal.\r
340         //\r
341         SSIDataGet(SSI0_BASE, &ulTemp);\r
342 \r
343         //\r
344         // Decrement the BYTE counter.\r
345         //\r
346         ulCount--;\r
347     }\r
348 }\r
349 \r
350 //*****************************************************************************\r
351 //\r
352 //! \internal\r
353 //!\r
354 //! Write a sequence of data bytes to the SSD0323 controller.\r
355 //!\r
356 //! The data is written in a polled fashion; this function will not return\r
357 //! until the entire byte sequence has been written to the controller.\r
358 //!\r
359 //! \return None.\r
360 //\r
361 //*****************************************************************************\r
362 static void\r
363 OSRAMWriteData(const unsigned char *pucBuffer, unsigned long ulCount)\r
364 {\r
365     unsigned long ulTemp;\r
366 \r
367     //\r
368     // Return iff SSI port is not enabled for OSRAM.\r
369     //\r
370     if(!g_bSSIEnabled)\r
371     {\r
372         return;\r
373     }\r
374 \r
375     //\r
376     // Set the command/control bit to enable data mode.\r
377     //\r
378     GPIOPinWrite(GPIO_PORTC_BASE, GPIO_PIN_7, GPIO_PIN_7);\r
379 \r
380     //\r
381     // Loop while there are more bytes left to be transferred.\r
382     //\r
383     while(ulCount != 0)\r
384     {\r
385         //\r
386         // Write the next byte to the controller.\r
387         //\r
388         SSIDataPut(SSI0_BASE, *pucBuffer++);\r
389 \r
390         //\r
391         // Dummy read to drain the fifo and time the GPIO signal.\r
392         //\r
393         SSIDataGet(SSI0_BASE, &ulTemp);\r
394 \r
395         //\r
396         // Decrement the BYTE counter.\r
397         //\r
398         ulCount--;\r
399     }\r
400 }\r
401 \r
402 //*****************************************************************************\r
403 //\r
404 //! Clears the OLED display.\r
405 //!\r
406 //! This function will clear the display RAM.  All pixels in the display will\r
407 //! be turned off.\r
408 //!\r
409 //! This function is contained in <tt>osram128x64x4.c</tt>, with\r
410 //! <tt>osram128x64x4.h</tt> containing the API definition for use by\r
411 //! applications.\r
412 //!\r
413 //! \return None.\r
414 //\r
415 //*****************************************************************************\r
416 void\r
417 OSRAM128x64x4Clear(void)\r
418 {\r
419     static const unsigned char pucCommand1[] = { 0x15, 0, 63 };\r
420     static const unsigned char pucCommand2[] = { 0x75, 0, 79 };\r
421     unsigned long ulRow, ulColumn;\r
422     static unsigned char pucZeroBuffer[8] = { 0, 0, 0, 0, 0, 0, 0, 0};\r
423 \r
424     //\r
425     // Set the window to fill the entire display.\r
426     //\r
427     OSRAMWriteCommand(pucCommand1, sizeof(pucCommand1));\r
428     OSRAMWriteCommand(pucCommand2, sizeof(pucCommand2));\r
429     OSRAMWriteCommand(g_pucOSRAM128x64x4VerticalInc,\r
430                       sizeof(g_pucOSRAM128x64x4VerticalInc));\r
431 \r
432     //\r
433     // In vertical address increment mode, loop through each column, filling\r
434     // each row with 0.\r
435     //\r
436     for(ulColumn = 0; ulColumn < (128/2); ulColumn++)\r
437     {\r
438         //\r
439         // 8 rows (bytes) per row of text.\r
440         //\r
441         for(ulRow = 0; ulRow < 80; ulRow += 8)\r
442         {\r
443             OSRAMWriteData(pucZeroBuffer, sizeof(pucZeroBuffer));\r
444         }\r
445     }\r
446 }\r
447 \r
448 //*****************************************************************************\r
449 //\r
450 //! Displays a string on the OLED display.\r
451 //!\r
452 //! \param pcStr is a pointer to the string to display.\r
453 //! \param ulX is the horizontal position to display the string, specified in\r
454 //! columns from the left edge of the display.\r
455 //! \param ulY is the vertical position to display the string, specified in\r
456 //! rows from the top edge of the display.\r
457 //! \param ucLevel is the 4-bit grey scale value to be used for displayed text.\r
458 //!\r
459 //! This function will draw a string on the display.  Only the ASCII characters\r
460 //! between 32 (space) and 126 (tilde) are supported; other characters will\r
461 //! result in random data being draw on the display (based on whatever appears\r
462 //! before/after the font in memory).  The font is mono-spaced, so characters\r
463 //! such as "i" and "l" have more white space around them than characters such\r
464 //! as "m" or "w".\r
465 //!\r
466 //! If the drawing of the string reaches the right edge of the display, no more\r
467 //! characters will be drawn.  Therefore, special care is not required to avoid\r
468 //! supplying a string that is "too long" to display.\r
469 //!\r
470 //! This function is contained in <tt>osram128x64x4.c</tt>, with\r
471 //! <tt>osram128x64x4.h</tt> containing the API definition for use by\r
472 //! applications.\r
473 //!\r
474 //! \note Because the OLED display packs 2 pixels of data in a single byte, the\r
475 //! parameter \e ulX must be an even column number (e.g. 0, 2, 4, etc).\r
476 //!\r
477 //! \return None.\r
478 //\r
479 //*****************************************************************************\r
480 void\r
481 OSRAM128x64x4StringDraw(const char *pcStr, unsigned long ulX,\r
482                         unsigned long ulY, unsigned char ucLevel)\r
483 {\r
484     static unsigned char pucBuffer[8];\r
485     unsigned long ulIdx1, ulIdx2;\r
486     unsigned char ucTemp;\r
487 \r
488     //\r
489     // Check the arguments.\r
490     //\r
491     ASSERT(ulX < 128);\r
492     ASSERT((ulX & 1) == 0);\r
493     ASSERT(ulY < 64);\r
494     ASSERT(ucLevel < 16);\r
495 \r
496     //\r
497     // Setup a window starting at the specified column and row, ending\r
498     // at the right edge of the display and 8 rows down (single character row).\r
499     //\r
500     pucBuffer[0] = 0x15;\r
501     pucBuffer[1] = ulX / 2;\r
502     pucBuffer[2] = 63;\r
503     OSRAMWriteCommand(pucBuffer, 3);\r
504     pucBuffer[0] = 0x75;\r
505     pucBuffer[1] = ulY;\r
506     pucBuffer[2] = ulY + 7;\r
507     OSRAMWriteCommand(pucBuffer, 3);\r
508     OSRAMWriteCommand(g_pucOSRAM128x64x4VerticalInc,\r
509                       sizeof(g_pucOSRAM128x64x4VerticalInc));\r
510 \r
511     //\r
512     // Loop while there are more characters in the string.\r
513     //\r
514     while(*pcStr != 0)\r
515     {\r
516         //\r
517         // Get a working copy of the current character and convert to an\r
518         // index into the character bit-map array.\r
519         //\r
520         ucTemp = *pcStr;\r
521         ucTemp &= 0x7F;\r
522         if(ucTemp < ' ')\r
523         {\r
524             ucTemp = ' ';\r
525         }\r
526         else\r
527         {\r
528             ucTemp -= ' ';\r
529         }\r
530 \r
531         //\r
532         // Build and display the character buffer.\r
533         //\r
534         for(ulIdx1 = 0; ulIdx1 < 3; ulIdx1++)\r
535         {\r
536             //\r
537             // Convert two columns of 1-bit font data into a single data\r
538             // byte column of 4-bit font data.\r
539             //\r
540             for(ulIdx2 = 0; ulIdx2 < 8; ulIdx2++)\r
541             {\r
542                 pucBuffer[ulIdx2] = 0;\r
543                 if(g_pucFont[ucTemp][ulIdx1*2] & (1 << ulIdx2))\r
544                 {\r
545                     pucBuffer[ulIdx2] = ((ucLevel << 4) & 0xf0);\r
546                 }\r
547                 if((ulIdx1 < 2) &&\r
548                     (g_pucFont[ucTemp][ulIdx1*2+1] & (1 << ulIdx2)))\r
549                 {\r
550                     pucBuffer[ulIdx2] |= ((ucLevel << 0) & 0x0f);\r
551                 }\r
552             }\r
553 \r
554             //\r
555             // If there is room, dump the single data byte column to the\r
556             // display.  Otherwise, bail out.\r
557             //\r
558             if(ulX < 126)\r
559             {\r
560                 OSRAMWriteData(pucBuffer, 8);\r
561                 ulX += 2;\r
562             }\r
563             else\r
564             {\r
565                 return;\r
566             }\r
567         }\r
568 \r
569         //\r
570         // Advance to the next character.\r
571         //\r
572         pcStr++;\r
573     }\r
574 }\r
575 \r
576 //*****************************************************************************\r
577 //\r
578 //! Displays an image on the OLED display.\r
579 //!\r
580 //! \param pucImage is a pointer to the image data.\r
581 //! \param ulX is the horizontal position to display this image, specified in\r
582 //! columns from the left edge of the display.\r
583 //! \param ulY is the vertical position to display this image, specified in\r
584 //! rows from the top of the display.\r
585 //! \param ulWidth is the width of the image, specified in columns.\r
586 //! \param ulHeight is the height of the image, specified in rows.\r
587 //!\r
588 //! This function will display a bitmap graphic on the display.  Because of the\r
589 //! format of the display RAM, the starting column (/e ulX) and the number of\r
590 //! columns (/e ulWidth) must be an integer multiple of two.\r
591 //!\r
592 //! The image data is organized with the first row of image data appearing left\r
593 //! to right, followed immediately by the second row of image data.  Each byte\r
594 //! contains the data for two columns in the current row, with the leftmost\r
595 //! column being contained in bits 7:4 and the rightmost column being contained\r
596 //! in bits 3:0.\r
597 //!\r
598 //! For example, an image six columns wide and seven scan lines tall would\r
599 //! be arranged as follows (showing how the twenty one bytes of the image would\r
600 //! appear on the display):\r
601 //!\r
602 //! \verbatim\r
603 //!     +-------------------+-------------------+-------------------+\r
604 //!     |      Byte 0       |      Byte 1       |      Byte 2       |\r
605 //!     +---------+---------+---------+---------+---------+---------+\r
606 //!     | 7 6 5 4 | 3 2 1 0 | 7 6 5 4 | 3 2 1 0 | 7 6 5 4 | 3 2 1 0 |\r
607 //!     +---------+---------+---------+---------+---------+---------+\r
608 //!     |      Byte 3       |      Byte 4       |      Byte 5       |\r
609 //!     +---------+---------+---------+---------+---------+---------+\r
610 //!     | 7 6 5 4 | 3 2 1 0 | 7 6 5 4 | 3 2 1 0 | 7 6 5 4 | 3 2 1 0 |\r
611 //!     +---------+---------+---------+---------+---------+---------+\r
612 //!     |      Byte 6       |      Byte 7       |      Byte 8       |\r
613 //!     +---------+---------+---------+---------+---------+---------+\r
614 //!     | 7 6 5 4 | 3 2 1 0 | 7 6 5 4 | 3 2 1 0 | 7 6 5 4 | 3 2 1 0 |\r
615 //!     +---------+---------+---------+---------+---------+---------+\r
616 //!     |      Byte 9       |      Byte 10      |      Byte 11      |\r
617 //!     +---------+---------+---------+---------+---------+---------+\r
618 //!     | 7 6 5 4 | 3 2 1 0 | 7 6 5 4 | 3 2 1 0 | 7 6 5 4 | 3 2 1 0 |\r
619 //!     +---------+---------+---------+---------+---------+---------+\r
620 //!     |      Byte 12      |      Byte 13      |      Byte 14      |\r
621 //!     +---------+---------+---------+--3------+---------+---------+\r
622 //!     | 7 6 5 4 | 3 2 1 0 | 7 6 5 4 | 3 2 1 0 | 7 6 5 4 | 3 2 1 0 |\r
623 //!     +---------+---------+---------+---------+---------+---------+\r
624 //!     |      Byte 15      |      Byte 16      |      Byte 17      |\r
625 //!     +---------+---------+---------+---------+---------+---------+\r
626 //!     | 7 6 5 4 | 3 2 1 0 | 7 6 5 4 | 3 2 1 0 | 7 6 5 4 | 3 2 1 0 |\r
627 //!     +---------+---------+---------+---------+---------+---------+\r
628 //!     |      Byte 18      |      Byte 19      |      Byte 20      |\r
629 //!     +---------+---------+---------+---------+---------+---------+\r
630 //!     | 7 6 5 4 | 3 2 1 0 | 7 6 5 4 | 3 2 1 0 | 7 6 5 4 | 3 2 1 0 |\r
631 //!     +---------+---------+---------+---------+---------+---------+\r
632 //! \endverbatim\r
633 //!\r
634 //! This function is contained in <tt>osram128x64x4.c</tt>, with\r
635 //! <tt>osram128x64x4.h</tt> containing the API definition for use by`\r
636 //! applications.\r
637 //!\r
638 //! \return None.\r
639 //\r
640 //*****************************************************************************\r
641 void\r
642 OSRAM128x64x4ImageDraw(const unsigned char *pucImage, unsigned long ulX,\r
643                unsigned long ulY, unsigned long ulWidth,\r
644                unsigned long ulHeight)\r
645 {\r
646     static unsigned char pucBuffer[8];\r
647 \r
648     //\r
649     // Check the arguments.\r
650     //\r
651     ASSERT(ulX < 128);\r
652     ASSERT((ulX & 1) == 0);\r
653     ASSERT(ulY < 64);\r
654     ASSERT((ulX + ulWidth) <= 128);\r
655     ASSERT((ulY + ulHeight) <= 64);\r
656     ASSERT((ulWidth & 1) == 0);\r
657 \r
658     //\r
659     // Setup a window starting at the specified column and row, and ending\r
660     // at the column + width and row+height.\r
661     //\r
662     pucBuffer[0] = 0x15;\r
663     pucBuffer[1] = ulX / 2;\r
664     pucBuffer[2] = (ulX + ulWidth - 2) / 2;\r
665     OSRAMWriteCommand(pucBuffer, 3);\r
666     pucBuffer[0] = 0x75;\r
667     pucBuffer[1] = ulY;\r
668     pucBuffer[2] = ulY + ulHeight - 1;\r
669     OSRAMWriteCommand(pucBuffer, 3);\r
670     OSRAMWriteCommand(g_pucOSRAM128x64x4HorizontalInc,\r
671                       sizeof(g_pucOSRAM128x64x4HorizontalInc));\r
672 \r
673     //\r
674     // Loop while there are more rows to display.\r
675     //\r
676     while(ulHeight--)\r
677     {\r
678         //\r
679         // Write this row of image data.\r
680         //\r
681         OSRAMWriteData(pucImage, (ulWidth / 2));\r
682 \r
683         //\r
684         // Advance to the next row of the image.\r
685         //\r
686         pucImage += (ulWidth / 2);\r
687     }\r
688 }\r
689 \r
690 //*****************************************************************************\r
691 //\r
692 //! Enable the SSI component of the OLED display driver.\r
693 //!\r
694 //! \param ulFrequency specifies the SSI Clock Frequency to be used.\r
695 //!\r
696 //! This function initializes the SSI interface to the OLED display.\r
697 //!\r
698 //! This function is contained in <tt>osram128x64x4.c</tt>, with\r
699 //! <tt>osram128x64x4.h</tt> containing the API definition for use by\r
700 //! applications.\r
701 //!\r
702 //! \return None.\r
703 //\r
704 //*****************************************************************************\r
705 void\r
706 OSRAM128x64x4Enable(unsigned long ulFrequency)\r
707 {\r
708     unsigned long ulTemp;\r
709 \r
710     //\r
711     // Disable the SSI port.\r
712     //\r
713     SSIDisable(SSI0_BASE);\r
714 \r
715     //\r
716     // Configure the SSI0 port for master mode.\r
717     //\r
718     SSIConfig(SSI0_BASE, SSI_FRF_MOTO_MODE_2, SSI_MODE_MASTER, ulFrequency, 8);\r
719 \r
720     //\r
721     // (Re)Enable SSI control of the FSS pin.\r
722     //\r
723     GPIOPinTypeSSI(GPIO_PORTA_BASE, GPIO_PIN_3);\r
724     GPIOPadConfigSet(GPIO_PORTA_BASE, GPIO_PIN_3, GPIO_STRENGTH_8MA,\r
725                      GPIO_PIN_TYPE_STD_WPU);\r
726 \r
727     //\r
728     // Enable the SSI port.\r
729     //\r
730     SSIEnable(SSI0_BASE);\r
731 \r
732     //\r
733     // Drain the receive fifo.\r
734     //\r
735     while(SSIDataNonBlockingGet(SSI0_BASE, &ulTemp) != 0)\r
736     {\r
737     }\r
738 \r
739     //\r
740     // Indicate that the OSRAM driver can use the SSI Port.\r
741     //\r
742     g_bSSIEnabled = true;\r
743 }\r
744 \r
745 //*****************************************************************************\r
746 //\r
747 //! Enable the SSI component of the OLED display driver.\r
748 //!\r
749 //! \param ulFrequency specifies the SSI Clock Frequency to be used.\r
750 //!\r
751 //! This function initializes the SSI interface to the OLED display.\r
752 //!\r
753 //! This function is contained in <tt>osram128x64x4.c</tt>, with\r
754 //! <tt>osram128x64x4.h</tt> containing the API definition for use by\r
755 //! applications.\r
756 //!\r
757 //! \return None.\r
758 //\r
759 //*****************************************************************************\r
760 void\r
761 OSRAM128x64x4Disable(void)\r
762 {\r
763     unsigned long ulTemp;\r
764 \r
765     //\r
766     // Indicate that the OSRAM driver can no longer use the SSI Port.\r
767     //\r
768     g_bSSIEnabled = false;\r
769 \r
770     //\r
771     // Drain the receive fifo.\r
772     //\r
773     while(SSIDataNonBlockingGet(SSI0_BASE, &ulTemp) != 0)\r
774     {\r
775     }\r
776 \r
777     //\r
778     // Disable the SSI port.\r
779     //\r
780     SSIDisable(SSI0_BASE);\r
781 \r
782     //\r
783     // Disable SSI control of the FSS pin.\r
784     //\r
785     GPIODirModeSet(GPIO_PORTA_BASE, GPIO_PIN_3, GPIO_DIR_MODE_OUT);\r
786     GPIOPadConfigSet(GPIO_PORTA_BASE, GPIO_PIN_3, GPIO_STRENGTH_8MA,\r
787                      GPIO_PIN_TYPE_STD_WPU);\r
788     GPIOPinWrite(GPIO_PORTA_BASE, GPIO_PIN_3, GPIO_PIN_3);\r
789 \r
790 }\r
791 \r
792 //*****************************************************************************\r
793 //\r
794 //! Initialize the OLED display.\r
795 //!\r
796 //! \param ulFrequency specifies the SSI Clock Frequency to be used.\r
797 //!\r
798 //! This function initializes the SSI interface to the OLED display and\r
799 //! configures the SSD0323 controller on the panel.\r
800 //!\r
801 //! This function is contained in <tt>osram128x64x4.c</tt>, with\r
802 //! <tt>osram128x64x4.h</tt> containing the API definition for use by\r
803 //! applications.\r
804 //!\r
805 //! \return None.\r
806 //\r
807 //*****************************************************************************\r
808 void\r
809 OSRAM128x64x4Init(unsigned long ulFrequency)\r
810 {\r
811     unsigned long ulIdx;\r
812 \r
813     //\r
814     // Enable the SSI0 and GPIO port  blocks as they are needed by this driver.\r
815     //\r
816     SysCtlPeripheralEnable(SYSCTL_PERIPH_SSI0);\r
817     SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);\r
818     SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC);\r
819 \r
820     //\r
821     // Configure the SSI0CLK and SSIOTX pins for SSI operation.\r
822     //\r
823     GPIOPinTypeSSI(GPIO_PORTA_BASE, GPIO_PIN_2 | GPIO_PIN_3 | GPIO_PIN_5);\r
824     GPIOPadConfigSet(GPIO_PORTA_BASE, GPIO_PIN_2, GPIO_STRENGTH_8MA,\r
825                      GPIO_PIN_TYPE_STD_WPU);\r
826     GPIOPadConfigSet(GPIO_PORTA_BASE, GPIO_PIN_3, GPIO_STRENGTH_8MA,\r
827                      GPIO_PIN_TYPE_STD_WPU);\r
828     GPIOPadConfigSet(GPIO_PORTA_BASE, GPIO_PIN_5, GPIO_STRENGTH_8MA,\r
829                      GPIO_PIN_TYPE_STD_WPU);\r
830 \r
831     //\r
832     // Configure the PC7 pin as a D/Cn signal for OLED device.\r
833     //\r
834     GPIODirModeSet(GPIO_PORTC_BASE, GPIO_PIN_7, GPIO_DIR_MODE_OUT);\r
835     GPIOPadConfigSet(GPIO_PORTC_BASE, GPIO_PIN_7, GPIO_STRENGTH_8MA,\r
836                      GPIO_PIN_TYPE_STD);\r
837     GPIOPinWrite(GPIO_PORTC_BASE, GPIO_PIN_7, GPIO_PIN_7);\r
838 \r
839     //\r
840     // Configure and enable the SSI0 port for master mode.\r
841     //\r
842     OSRAM128x64x4Enable(ulFrequency);\r
843 \r
844     //\r
845     // Clear the frame buffer.\r
846     //\r
847     OSRAM128x64x4Clear();\r
848 \r
849     //\r
850     // Initialize the SSD0323 controller.  Loop through the initialization\r
851     // sequence array, sending each command "string" to the controller.\r
852     //\r
853     for(ulIdx = 0; ulIdx < sizeof(g_pucOSRAM128x64x4Init);\r
854         ulIdx += g_pucOSRAM128x64x4Init[ulIdx] + 1)\r
855     {\r
856         //\r
857         // Send this command.\r
858         //\r
859         OSRAMWriteCommand(g_pucOSRAM128x64x4Init + ulIdx + 1,\r
860                           g_pucOSRAM128x64x4Init[ulIdx] - 1);\r
861     }\r
862 }\r
863 \r
864 //*****************************************************************************\r
865 //\r
866 //! Turns on the OLED display.\r
867 //!\r
868 //! This function will turn on the OLED display, causing it to display the\r
869 //! contents of its internal frame buffer.\r
870 //!\r
871 //! This function is contained in <tt>osram128x64x4.c</tt>, with\r
872 //! <tt>osram128x64x4.h</tt> containing the API definition for use by\r
873 //! applications.\r
874 //!\r
875 //! \return None.\r
876 //\r
877 //*****************************************************************************\r
878 void\r
879 OSRAM128x64x4DisplayOn(void)\r
880 {\r
881     unsigned long ulIdx;\r
882 \r
883     //\r
884     // Initialize the SSD0323 controller.  Loop through the initialization\r
885     // sequence array, sending each command "string" to the controller.\r
886     //\r
887     for(ulIdx = 0; ulIdx < sizeof(g_pucOSRAM128x64x4Init);\r
888         ulIdx += g_pucOSRAM128x64x4Init[ulIdx] + 1)\r
889     {\r
890         //\r
891         // Send this command.\r
892         //\r
893         OSRAMWriteCommand(g_pucOSRAM128x64x4Init + ulIdx + 1,\r
894                           g_pucOSRAM128x64x4Init[ulIdx] - 1);\r
895     }\r
896 }\r
897 \r
898 //*****************************************************************************\r
899 //\r
900 //! Turns off the OLED display.\r
901 //!\r
902 //! This function will turn off the OLED display.  This will stop the scanning\r
903 //! of the panel and turn off the on-chip DC-DC converter, preventing damage to\r
904 //! the panel due to burn-in (it has similar characters to a CRT in this\r
905 //! respect).\r
906 //!\r
907 //! This function is contained in <tt>osram128x64x4.c</tt>, with\r
908 //! <tt>osram128x64x4.h</tt> containing the API definition for use by\r
909 //! applications.\r
910 //!\r
911 //! \return None.\r
912 //\r
913 //*****************************************************************************\r
914 void\r
915 OSRAM128x64x4DisplayOff(void)\r
916 {\r
917     static const unsigned char pucCommand1[] =\r
918     {\r
919         0xAE, 0xAD, 0x02\r
920     };\r
921 \r
922     //\r
923     // Turn off the DC-DC converter and the display.\r
924     //\r
925     OSRAMWriteCommand(pucCommand1, sizeof(pucCommand1));\r
926 }\r
927 \r
928 //*****************************************************************************\r
929 //\r
930 // Close the Doxygen group.\r
931 //! @}\r
932 //\r
933 //*****************************************************************************\r