OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [rtos/] [freertos-6.1.1/] [Demo/] [ARM7_STR75x_IAR/] [STLibrary/] [src/] [lcd.c] - Blame information for rev 577

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 577 jeremybenn 
/******************** (C) COPYRIGHT 2006 STMicroelectronics ********************
2 
* File Name          : lcd.c
3 
* Author             : MCD Application Team
4 
* Date First Issued  : 03/10/2006
5 
* Description        : This file includes the LCD driver for GXM12232-2SL liquid
6 
*                      Crystal Display Module of STR75x-EVAL.
7 
********************************************************************************
8 
* History:
9 
* 07/17/2006 : V1.0
10 
* 03/10/2006 : V0.1
11 
********************************************************************************
12 
* THE PRESENT SOFTWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
13 
* WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE TIME.
14 
* AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY DIRECT,
15 
* INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE
16 
* CONTENT OF SUCH SOFTWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING
17 
* INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
18 
*******************************************************************************/
19 
 
20 
/* Includes ------------------------------------------------------------------*/
21 
#include "lcd.h"
22 
 
23 
/* Private typedef -----------------------------------------------------------*/
24 
 
25 
  /* Peripherals InitStructure define */
26 
GPIO_InitTypeDef GPIO_InitStructure;
27 
 
28 
/* Private define ------------------------------------------------------------*/
29 
#define LCD_GPIO_Pins 0x3FC00
30 
/* Private macro -------------------------------------------------------------*/
31 
/* Private variables ---------------------------------------------------------*/
32 
  /* Global variable to set the written text color: used for LCD_Printf */
33 
  TextColorMode_TypeDef TextMode = BlackText;
34 
 
35 
  /* ASCII Table: each character is 7 column (7dots large) on two pages (16dots high)  */
36 
  /* 7 column character: Two 8bit data to display one column*/
37 
  const u8 AsciiDotsTable[1778] = {
38 
  /* ASCII 0   */  0x1f,0xe0,0x10,0x20,0x10,0x20,0x10,0x20,0x10,0x20,0x1f,0xe0,0x00,0x00,
39 
  /* ASCII 1   */  0x1f,0xe0,0x10,0x20,0x10,0x20,0x10,0x20,0x10,0x20,0x1f,0xe0,0x00,0x00,
40 
  /* ASCII 2   */  0x1f,0xe0,0x10,0x20,0x10,0x20,0x10,0x20,0x10,0x20,0x1f,0xe0,0x00,0x00,
41 
  /* ASCII 3   */  0x1f,0xe0,0x10,0x20,0x10,0x20,0x10,0x20,0x10,0x20,0x1f,0xe0,0x00,0x00,
42 
  /* ASCII 4   */  0x1f,0xe0,0x10,0x20,0x10,0x20,0x10,0x20,0x10,0x20,0x1f,0xe0,0x00,0x00,
43 
  /* ASCII 5   */  0x1f,0xe0,0x10,0x20,0x10,0x20,0x10,0x20,0x10,0x20,0x1f,0xe0,0x00,0x00,
44 
  /* ASCII 6   */  0x1f,0xe0,0x10,0x20,0x10,0x20,0x10,0x20,0x10,0x20,0x1f,0xe0,0x00,0x00,
45 
  /* ASCII 7   */  0x1f,0xe0,0x10,0x20,0x10,0x20,0x10,0x20,0x10,0x20,0x1f,0xe0,0x00,0x00,
46 
  /* ASCII 8   */  0x1f,0xe0,0x10,0x20,0x10,0x20,0x10,0x20,0x10,0x20,0x1f,0xe0,0x00,0x00,
47 
  /* ASCII 9   */  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
48 
  /* ASCII 10  */  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
49 
  /* ASCII 11  */  0x1f,0xe0,0x10,0x20,0x10,0x20,0x10,0x20,0x10,0x20,0x1f,0xe0,0x00,0x00,
50 
  /* ASCII 12  */  0x1f,0xe0,0x10,0x20,0x10,0x20,0x10,0x20,0x10,0x20,0x1f,0xe0,0x00,0x00,
51 
  /* ASCII 13  */  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
52 
  /* ASCII 14  */  0x1f,0xe0,0x10,0x20,0x10,0x20,0x10,0x20,0x10,0x20,0x1f,0xe0,0x00,0x00,
53 
  /* ASCII 15  */  0x1f,0xe0,0x10,0x20,0x10,0x20,0x10,0x20,0x10,0x20,0x1f,0xe0,0x00,0x00,
54 
  /* ASCII 16  */  0x1f,0xe0,0x10,0x20,0x10,0x20,0x10,0x20,0x10,0x20,0x1f,0xe0,0x00,0x00,
55 
  /* ASCII 17  */  0x1f,0xe0,0x10,0x20,0x10,0x20,0x10,0x20,0x10,0x20,0x1f,0xe0,0x00,0x00,
56 
  /* ASCII 18  */  0x1f,0xe0,0x10,0x20,0x10,0x20,0x10,0x20,0x10,0x20,0x1f,0xe0,0x00,0x00,
57 
  /* ASCII 19  */  0x1f,0xe0,0x10,0x20,0x10,0x20,0x10,0x20,0x10,0x20,0x1f,0xe0,0x00,0x00,
58 
  /* ASCII 20  */  0x1f,0xe0,0x10,0x20,0x10,0x20,0x10,0x20,0x10,0x20,0x1f,0xe0,0x00,0x00,
59 
  /* ASCII 21  */  0x1f,0xe0,0x10,0x20,0x10,0x20,0x10,0x20,0x10,0x20,0x1f,0xe0,0x00,0x00,
60 
  /* ASCII 22  */  0x1f,0xe0,0x10,0x20,0x10,0x20,0x10,0x20,0x10,0x20,0x1f,0xe0,0x00,0x00,
61 
  /* ASCII 23  */  0x1f,0xe0,0x10,0x20,0x10,0x20,0x10,0x20,0x10,0x20,0x1f,0xe0,0x00,0x00,
62 
  /* ASCII 24  */  0x1f,0xe0,0x10,0x20,0x10,0x20,0x10,0x20,0x10,0x20,0x1f,0xe0,0x00,0x00,
63 
  /* ASCII 25  */  0x1f,0xe0,0x10,0x20,0x10,0x20,0x10,0x20,0x10,0x20,0x1f,0xe0,0x00,0x00,
64 
  /* ASCII 26  */  0x1f,0xe0,0x10,0x20,0x10,0x20,0x10,0x20,0x10,0x20,0x1f,0xe0,0x00,0x00,
65 
  /* ASCII 27  */  0x1f,0xe0,0x10,0x20,0x10,0x20,0x10,0x20,0x10,0x20,0x1f,0xe0,0x00,0x00,
66 
  /* ASCII 28  */  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
67 
  /* ASCII 29  */  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
68 
  /* ASCII 30  */  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
69 
  /* ASCII 31  */  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
70 
  /* ASCII 32  */  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
71 
  /* ASCII 33  */  0x00,0x00,0x00,0x00,0x00,0x00,0x13,0xe0,0x00,0x00,0x00,0x00,0x00,0x00,
72 
  /* ASCII 34  */  0x00,0x00,0x00,0xe0,0x00,0x20,0x00,0x00,0x00,0xe0,0x00,0x20,0x00,0x00,
73 
  /* ASCII 35  */  0x00,0x00,0x35,0x00,0x0f,0x80,0x35,0x60,0x0f,0x80,0x05,0x60,0x00,0x00,
74 
  /* ASCII 36  */  0x00,0x00,0x0d,0x80,0x0a,0x40,0x3a,0x60,0x06,0x40,0x00,0x00,0x00,0x00,
75 
  /* ASCII 37  */  0x00,0x00,0x02,0x40,0x02,0xa0,0x0a,0x40,0x15,0x00,0x09,0x00,0x00,0x00,
76 
  /* ASCII 38  */  0x00,0x00,0x0c,0x00,0x13,0x00,0x14,0x80,0x08,0x80,0x14,0x00,0x00,0x00,
77 
  /* ASCII 39  */  0x00,0x00,0x00,0x00,0x00,0x00,0x01,0xe0,0x00,0x00,0x00,0x00,0x00,0x00,
78 
  /* ASCII 40  */  0x00,0x00,0x00,0x00,0x00,0x00,0x1f,0x80,0x60,0x60,0x00,0x00,0x00,0x00,
79 
  /* ASCII 41  */  0x00,0x00,0x00,0x00,0x60,0x60,0x1f,0x80,0x00,0x00,0x00,0x00,0x00,0x00,
80 
  /* ASCII 42  */  0x00,0x00,0x00,0x40,0x03,0x40,0x00,0xe0,0x03,0x40,0x00,0x40,0x00,0x00,
81 
  /* ASCII 43  */  0x02,0x00,0x02,0x00,0x02,0x00,0x1f,0xc0,0x02,0x00,0x02,0x00,0x02,0x00,
82 
  /* ASCII 44  */  0x00,0x00,0x00,0x00,0x60,0x00,0x38,0x00,0x08,0x00,0x00,0x00,0x00,0x00,
83 
  /* ASCII 45  */  0x00,0x00,0x02,0x00,0x02,0x00,0x02,0x00,0x02,0x00,0x02,0x00,0x00,0x00,
84 
  /* ASCII 46  */  0x00,0x00,0x00,0x00,0x18,0x00,0x18,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
85 
  /* ASCII 47  */  0x00,0x00,0x20,0x00,0x18,0x00,0x06,0x00,0x01,0x80,0x00,0x60,0x00,0x00,
86 
  /* ASCII 48  */  0x00,0x00,0x0f,0xc0,0x10,0x20,0x10,0x20,0x10,0x20,0x0f,0xc0,0x00,0x00,
87 
  /* ASCII 49  */  0x00,0x00,0x10,0x00,0x10,0x20,0x1f,0xe0,0x10,0x00,0x10,0x00,0x00,0x00,
88 
  /* ASCII 50  */  0x00,0x00,0x18,0x40,0x14,0x20,0x12,0x20,0x11,0x20,0x18,0xc0,0x00,0x00,
89 
  /* ASCII 51  */  0x00,0x00,0x08,0x40,0x10,0x20,0x11,0x20,0x11,0x20,0x0e,0xc0,0x00,0x00,
90 
  /* ASCII 52  */  0x00,0x00,0x06,0x00,0x05,0x00,0x04,0xc0,0x14,0x20,0x1f,0xe0,0x14,0x00,
91 
  /* ASCII 53  */  0x00,0x00,0x08,0x00,0x11,0xe0,0x11,0x20,0x11,0x20,0x0e,0x20,0x00,0x00,
92 
  /* ASCII 54  */  0x00,0x00,0x0f,0x80,0x11,0x40,0x11,0x20,0x11,0x20,0x0e,0x20,0x00,0x00,
93 
  /* ASCII 55  */  0x00,0x00,0x00,0x60,0x00,0x20,0x18,0x20,0x07,0x20,0x00,0xe0,0x00,0x00,
94 
  /* ASCII 56  */  0x00,0x00,0x0e,0xc0,0x11,0x20,0x11,0x20,0x11,0x20,0x0e,0xc0,0x00,0x00,
95 
  /* ASCII 57  */  0x00,0x00,0x11,0xc0,0x12,0x20,0x12,0x20,0x0a,0x20,0x07,0xc0,0x00,0x00,
96 
  /* ASCII 58  */  0x00,0x00,0x00,0x00,0x19,0x80,0x19,0x80,0x00,0x00,0x00,0x00,0x00,0x00,
97 
  /* ASCII 59  */  0x00,0x00,0x00,0x00,0x30,0x00,0x19,0x80,0x09,0x80,0x00,0x00,0x00,0x00,
98 
  /* ASCII 60  */  0x02,0x00,0x05,0x00,0x05,0x00,0x08,0x80,0x10,0x40,0x10,0x40,0x00,0x00,
99 
  /* ASCII 61  */  0x00,0x00,0x05,0x00,0x05,0x00,0x05,0x00,0x05,0x00,0x05,0x00,0x00,0x00,
100 
  /* ASCII 62  */  0x10,0x40,0x10,0x40,0x08,0x80,0x05,0x00,0x05,0x00,0x02,0x00,0x00,0x00,
101 
  /* ASCII 63  */  0x00,0x00,0x00,0x00,0x10,0x80,0x14,0x40,0x02,0x40,0x01,0x80,0x00,0x00,
102 
  /* ASCII 64  */  0x00,0x00,0x1f,0xe0,0x20,0x10,0x23,0x10,0x24,0x90,0x17,0xe0,0x00,0x00,
103 
  /* ASCII 65  */  0x10,0x00,0x1c,0x00,0x17,0xa0,0x04,0x60,0x17,0x80,0x1c,0x00,0x10,0x00,
104 
  /* ASCII 66  */  0x10,0x20,0x1f,0xe0,0x11,0x20,0x11,0x20,0x11,0x20,0x0e,0xc0,0x00,0x00,
105 
  /* ASCII 67  */  0x00,0x00,0x0f,0xc0,0x10,0x20,0x10,0x20,0x10,0x20,0x08,0x60,0x00,0x00,
106 
  /* ASCII 68  */  0x10,0x20,0x1f,0xe0,0x10,0x20,0x10,0x20,0x08,0x40,0x07,0x80,0x00,0x00,
107 
  /* ASCII 69  */  0x10,0x20,0x1f,0xe0,0x11,0x20,0x13,0xa0,0x10,0x20,0x18,0x60,0x00,0x00,
108 
  /* ASCII 70  */  0x00,0x00,0x10,0x20,0x1f,0xe0,0x11,0x20,0x03,0xa0,0x00,0x20,0x00,0x60,
109 
  /* ASCII 71  */  0x00,0x00,0x0f,0xc0,0x10,0x20,0x10,0x20,0x12,0x20,0x0e,0x60,0x02,0x00,
110 
  /* ASCII 72  */  0x10,0x20,0x1f,0xe0,0x11,0x20,0x01,0x00,0x11,0x20,0x1f,0xe0,0x10,0x20,
111 
  /* ASCII 73  */  0x00,0x00,0x10,0x20,0x10,0x20,0x1f,0xe0,0x10,0x20,0x10,0x20,0x00,0x00,
112 
  /* ASCII 74  */  0x00,0x00,0x0e,0x00,0x10,0x20,0x10,0x20,0x0f,0xe0,0x00,0x20,0x00,0x00,
113 
  /* ASCII 75  */  0x10,0x20,0x1f,0xe0,0x12,0x20,0x03,0x00,0x04,0xa0,0x18,0x60,0x10,0x20,
114 
  /* ASCII 76  */  0x00,0x00,0x10,0x20,0x1f,0xe0,0x10,0x20,0x10,0x00,0x1c,0x00,0x00,0x00,
115 
  /* ASCII 77  */  0x10,0x20,0x1f,0xe0,0x10,0xe0,0x03,0x00,0x10,0xe0,0x1f,0xe0,0x10,0x20,
116 
  /* ASCII 78  */  0x10,0x20,0x1f,0xe0,0x10,0xe0,0x07,0x00,0x18,0x20,0x1f,0xe0,0x00,0x20,
117 
  /* ASCII 79  */  0x00,0x00,0x0f,0xc0,0x10,0x20,0x10,0x20,0x10,0x20,0x0f,0xc0,0x00,0x00,
118 
  /* ASCII 80  */  0x00,0x00,0x10,0x20,0x1f,0xe0,0x12,0x20,0x02,0x20,0x01,0xc0,0x00,0x00,
119 
  /* ASCII 81  */  0x00,0x00,0x0f,0xc0,0x10,0x20,0x30,0x20,0x30,0x20,0x2f,0xc0,0x00,0x00,
120 
  /* ASCII 82  */  0x10,0x20,0x1f,0xe0,0x12,0x20,0x02,0x20,0x06,0x20,0x09,0xc0,0x10,0x00,
121 
  /* ASCII 83  */  0x00,0x00,0x18,0xc0,0x09,0x20,0x11,0x20,0x11,0x40,0x0e,0x60,0x00,0x00,
122 
  /* ASCII 84  */  0x00,0x60,0x00,0x20,0x10,0x20,0x1f,0xe0,0x10,0x20,0x00,0x20,0x00,0x60,
123 
  /* ASCII 85  */  0x00,0x20,0x0f,0xe0,0x10,0x20,0x10,0x00,0x10,0x20,0x0f,0xe0,0x00,0x20,
124 
  /* ASCII 86  */  0x00,0x20,0x00,0xe0,0x07,0x20,0x18,0x00,0x07,0x20,0x00,0xe0,0x00,0x20,
125 
  /* ASCII 87  */  0x00,0x20,0x0f,0xe0,0x10,0x20,0x0f,0x00,0x10,0x20,0x0f,0xe0,0x00,0x20,
126 
  /* ASCII 88  */  0x10,0x20,0x18,0x60,0x04,0x80,0x03,0x00,0x04,0x80,0x18,0x60,0x10,0x20,
127 
  /* ASCII 89  */  0x00,0x20,0x00,0x60,0x11,0xa0,0x1e,0x00,0x11,0xa0,0x00,0x60,0x00,0x20,
128 
  /* ASCII 90  */  0x00,0x00,0x18,0x60,0x14,0x20,0x13,0x20,0x10,0xa0,0x18,0x60,0x00,0x00,
129 
  /* ASCII 91  */  0x00,0x00,0x00,0x00,0x7f,0xe0,0x40,0x20,0x40,0x20,0x00,0x00,0x00,0x00,
130 
  /* ASCII 92  */  0x00,0x00,0x00,0x20,0x01,0xc0,0x06,0x00,0x38,0x00,0x00,0x00,0x00,0x00,
131 
  /* ASCII 93  */  0x00,0x00,0x00,0x00,0x40,0x20,0x40,0x20,0x7f,0xe0,0x00,0x00,0x00,0x00,
132 
  /* ASCII 94  */  0x00,0x00,0x01,0x00,0x00,0x80,0x00,0x60,0x00,0x80,0x01,0x00,0x00,0x00,
133 
  /* ASCII 95  */  0x80,0x00,0x80,0x00,0x80,0x00,0x80,0x00,0x80,0x00,0x80,0x00,0x80,0x00,
134 
  /* ASCII 96  */  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x20,0x00,0x40,0x00,0x00,0x00,0x00,
135 
  /* ASCII 97  */  0x00,0x00,0x0d,0x00,0x12,0x80,0x12,0x80,0x12,0x80,0x1f,0x00,0x10,0x00,
136 
  /* ASCII 98  */  0x10,0x20,0x1f,0xe0,0x11,0x00,0x10,0x80,0x10,0x80,0x0f,0x00,0x00,0x00,
137 
  /* ASCII 99  */  0x00,0x00,0x0f,0x00,0x10,0x80,0x10,0x80,0x10,0x80,0x09,0x80,0x00,0x00,
138 
  /* ASCII 100 */  0x00,0x00,0x0f,0x00,0x10,0x80,0x10,0x80,0x11,0x20,0x1f,0xe0,0x10,0x00,
139 
  /* ASCII 101 */  0x00,0x00,0x0f,0x00,0x12,0x80,0x12,0x80,0x12,0x80,0x13,0x00,0x00,0x00,
140 
  /* ASCII 102 */  0x00,0x00,0x10,0x80,0x1f,0xc0,0x10,0xa0,0x10,0xa0,0x10,0xa0,0x00,0x00,
141 
  /* ASCII 103 */  0x00,0x00,0x0f,0x00,0x50,0x80,0x50,0x80,0x51,0x00,0x3f,0x80,0x00,0x80,
142 
  /* ASCII 104 */  0x10,0x20,0x1f,0xe0,0x11,0x00,0x00,0x80,0x10,0x80,0x1f,0x00,0x10,0x00,
143 
  /* ASCII 105 */  0x00,0x00,0x10,0x80,0x10,0x80,0x1f,0xa0,0x10,0x00,0x10,0x00,0x00,0x00,
144 
  /* ASCII 106 */  0x00,0x00,0x40,0x80,0x40,0x80,0x40,0xa0,0x3f,0x80,0x00,0x00,0x00,0x00,
145 
  /* ASCII 107 */  0x10,0x20,0x1f,0xe0,0x02,0x00,0x16,0x80,0x19,0x80,0x10,0x80,0x00,0x00,
146 
  /* ASCII 108 */  0x00,0x00,0x10,0x00,0x10,0x20,0x1f,0xe0,0x10,0x00,0x10,0x00,0x00,0x00,
147 
  /* ASCII 109 */  0x10,0x80,0x1f,0x80,0x10,0x80,0x1f,0x00,0x10,0x80,0x1f,0x00,0x10,0x00,
148 
  /* ASCII 110 */  0x10,0x80,0x1f,0x80,0x11,0x00,0x00,0x80,0x10,0x80,0x1f,0x00,0x10,0x00,
149 
  /* ASCII 111 */  0x00,0x00,0x0f,0x00,0x10,0x80,0x10,0x80,0x10,0x80,0x0f,0x00,0x00,0x00,
150 
  /* ASCII 112 */  0x40,0x80,0x7f,0x80,0x51,0x00,0x10,0x80,0x10,0x80,0x0f,0x00,0x00,0x00,
151 
  /* ASCII 113 */  0x00,0x00,0x0f,0x00,0x10,0x80,0x10,0x80,0x51,0x00,0x7f,0x80,0x40,0x80,
152 
  /* ASCII 114 */  0x00,0x00,0x10,0x80,0x1f,0x80,0x11,0x00,0x10,0x80,0x10,0x80,0x00,0x00,
153 
  /* ASCII 115 */  0x00,0x00,0x19,0x00,0x12,0x80,0x12,0x80,0x12,0x80,0x0d,0x80,0x00,0x00,
154 
  /* ASCII 116 */  0x00,0x00,0x00,0x80,0x0f,0xc0,0x10,0x80,0x10,0x80,0x10,0x80,0x08,0x00,
155 
  /* ASCII 117 */  0x00,0x80,0x0f,0x80,0x10,0x00,0x10,0x00,0x08,0x80,0x1f,0x80,0x10,0x00,
156 
  /* ASCII 118 */  0x00,0x80,0x03,0x80,0x0c,0x80,0x10,0x00,0x0c,0x80,0x03,0x80,0x00,0x80,
157 
  /* ASCII 119 */  0x00,0x80,0x0f,0x80,0x10,0x80,0x0e,0x00,0x10,0x80,0x0f,0x80,0x00,0x80,
158 
  /* ASCII 120 */  0x10,0x80,0x19,0x80,0x06,0x00,0x06,0x00,0x19,0x80,0x10,0x80,0x00,0x00,
159 
  /* ASCII 121 */  0x00,0x80,0x41,0x80,0x46,0x80,0x78,0x00,0x4c,0x80,0x03,0x80,0x00,0x80,
160 
  /* ASCII 122 */  0x00,0x00,0x19,0x80,0x14,0x80,0x12,0x80,0x11,0x80,0x18,0x80,0x00,0x00,
161 
  /* ASCII 123 */  0x00,0x00,0x00,0x00,0x04,0x00,0x3b,0xc0,0x40,0x20,0x00,0x00,0x00,0x00,
162 
  /* ASCII 124 */  0x00,0x00,0x00,0x00,0x00,0x00,0x3f,0xe0,0x00,0x00,0x00,0x00,0x00,0x00,
163 
  /* ASCII 125 */  0x00,0x00,0x00,0x00,0x40,0x20,0x3b,0xc0,0x04,0x00,0x00,0x00,0x00,0x00,
164 
  /* ASCII 126 */  0x00,0x00,0x04,0x00,0x02,0x00,0x04,0x00,0x04,0x00,0x02,0x00,0x00,0x00};
165 
 
166 
/* Private function prototypes -----------------------------------------------*/
167 
/* Private functions ---------------------------------------------------------*/
168 
 
169 
/*******************************************************************************
170 
* Function Name  : LCD_DataLinesConfig
171 
* Description    : Configure data lines D0~D7 (P2.10~P2.17) in Input Floating mode
172 
*                  for read from LCD or in Output Push-Pull mode for write on LCD
173 
* Input          : - Mode: specifies the configuration mode for data lines D0~D7
174 
*                       - Input: configure in Input Floating mode
175 
*                       - Output: configure in Output Push-Pul mode
176 
* Output         : None
177 
* Return         : None
178 
*******************************************************************************/
179 
void LCD_DataLinesConfig(DataConfigMode_TypeDef Mode)
180 
{
181 
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10 | GPIO_Pin_11 | GPIO_Pin_12 | GPIO_Pin_13 |
182 
                                GPIO_Pin_14 | GPIO_Pin_15 | GPIO_Pin_16 | GPIO_Pin_17;
183 
  if (Mode == Input)
184 
  {
185 
    /* Configure D0~D7 lines (P2.10~2.17) in Input Floating mode */
186 
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
187 
  }
188 
  else
189 
  {
190 
    /* Configure D0~D7 lines (P2.10~2.17) in Output Push-Pull mode */
191 
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
192 
  }
193 
  GPIO_Init(GPIO2, &GPIO_InitStructure);
194 
}
195 
 
196 
/*******************************************************************************
197 
* Function Name  : LCD_DataLinesWrite
198 
* Description    : Write a value on D0~D7 (P2.10~P2.17)
199 
* Input          : - GPIOx: GPIO port to write on. It could be
200 
*                  - PortVal: value to write
201 
* Output         : None
202 
* Return         : None.
203 
*******************************************************************************/
204 
void LCD_DataLinesWrite(GPIO_TypeDef* GPIOx, u32 PortVal)
205 
{
206 
  u32 Tmp = 0;
207 
 
208 
  /* Store the PM register value */
209 
  Tmp = GPIO_GetPortMask(GPIOx);
210 
  /* Mask the corresponding GPIO pins */
211 
  GPIO_PinMaskConfig(GPIOx, LCD_GPIO_Pins, DISABLE);
212 
  GPIO_PinMaskConfig(GPIOx, ~LCD_GPIO_Pins, ENABLE);
213 
  /* Write in the hole register */
214 
  GPIO_Write(GPIOx, (PortVal<<10));
215 
 
216 
  GPIO_PinMaskConfig(GPIOx, ~LCD_GPIO_Pins, DISABLE);
217 
  /* Return the initial PM register value */
218 
  GPIO_PinMaskConfig(GPIOx, Tmp, ENABLE);
219 
 
220 
}
221 
 
222 
/*******************************************************************************
223 
* Function Name  : LCD_CtrlLinesConfig
224 
* Description    : Configure control lines E2, E1, RW, DI (P2.0~P2.3) in
225 
*                  Output Push-Pull mode.
226 
* Input          : None
227 
* Output         : None
228 
* Return         : None
229 
*******************************************************************************/
230 
void LCD_CtrlLinesConfig(void)
231 
{
232 
  /* Configure E2, E1, RW, DI lines (P2.0~2.3) in Output Push-Pull mode */
233 
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2 | GPIO_Pin_3;
234 
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
235 
  GPIO_Init(GPIO2, &GPIO_InitStructure);
236 
}
237 
 
238 
/*******************************************************************************
239 
* Function Name  : LCD_CtrlLinesWrite
240 
* Description    : Set or reset control lines E2, E1, RW, DI (P2.0~P2.3).
241 
* Input          : - GPIOx: where x can be 0,1 or 2 to select the GPIO peripheral.
242 
*                  - CtrlPins: the Control line. This parameter can be:
243 
*                       - CtrlPin_E2: Enabe clock signal for Slave
244 
*                       - CtrlPin_E1: Enabe clock signal for Master
245 
*                       - CtrlPin_RW: Read/Write control line
246 
*                       - CtrlPin_DI:
247 
* Output         : None
248 
* Return         : None
249 
*******************************************************************************/
250 
void LCD_CtrlLinesWrite(GPIO_TypeDef* GPIOx, u32 CtrlPins, BitAction BitVal)
251 
{
252 
  /* Set or Reset the control line */
253 
  if(BitVal != Bit_RESET)
254 
  {
255 
    GPIOx->PD |= CtrlPins;
256 
  }
257 
  else
258 
  {
259 
    GPIOx->PD &= ~CtrlPins;
260 
  }
261 
}
262 
 
263 
/*******************************************************************************
264 
* Function Name  : LCD_CheckMasterStatus
265 
* Description    : Check whether master LCD is busy or not
266 
* Input          : None
267 
* Output         : None
268 
* Return         : None
269 
*******************************************************************************/
270 
void LCD_CheckMasterStatus(void)
271 
{
272 
  u8 MasterStatus = 0;
273 
 
274 
  /* Configure Data lines as Input */
275 
  LCD_DataLinesConfig(Input);
276 
  /* Start the master read sequence */
277 
  LCD_CtrlLinesWrite(GPIO2, CtrlPin_E1, Bit_RESET);   /* E1 = 0 */
278 
  LCD_CtrlLinesWrite(GPIO2, CtrlPin_RW, Bit_SET);     /* RW = 1 */
279 
  LCD_CtrlLinesWrite(GPIO2, CtrlPin_DI, Bit_RESET);   /* DI = 0 */
280 
  LCD_CtrlLinesWrite(GPIO2, CtrlPin_E1, Bit_SET);     /* E1 = 1 */
281 
  MasterStatus = GPIO_Read(GPIO2);
282 
  LCD_CtrlLinesWrite(GPIO2, CtrlPin_E1, Bit_RESET);   /* E1 = 0 */
283 
 
284 
  /* Wait until BF is cleared: D7 line */
285 
  while ((MasterStatus & 0x20000))
286 
  {
287 
    LCD_CtrlLinesWrite(GPIO2, CtrlPin_E1, Bit_SET);   /* E1 = 1 */
288 
    MasterStatus = GPIO_Read(GPIO2);
289 
    LCD_CtrlLinesWrite(GPIO2, CtrlPin_E1, Bit_RESET); /* E1 = 0 */
290 
  }
291 
}
292 
 
293 
/*******************************************************************************
294 
* Function Name  : LCD_CheckSlaveStatus
295 
* Description    : Check whether slave LCD is busy or not
296 
* Input          : None
297 
* Output         : None
298 
* Return         : None
299 
*******************************************************************************/
300 
void LCD_CheckSlaveStatus(void)
301 
{
302 
  u8 SlaveStatus = 0;
303 
 
304 
  /* Configure Data lines as Input */
305 
  LCD_DataLinesConfig(Input);
306 
  /* Start the slave read sequence */
307 
  LCD_CtrlLinesWrite(GPIO2, CtrlPin_E2, Bit_RESET);   /* E2 = 0 */
308 
  LCD_CtrlLinesWrite(GPIO2, CtrlPin_RW, Bit_SET);     /* RW = 1 */
309 
  LCD_CtrlLinesWrite(GPIO2, CtrlPin_DI, Bit_RESET);   /* DI = 0 */
310 
  LCD_CtrlLinesWrite(GPIO2, CtrlPin_E2, Bit_SET);     /* E2 = 1 */
311 
  SlaveStatus = GPIO_Read(GPIO2);
312 
  LCD_CtrlLinesWrite(GPIO2, CtrlPin_E2, Bit_RESET);   /* E2 = 0 */
313 
 
314 
  /* Wait until BF is cleared: D7 line */
315 
  while ((SlaveStatus & 0x20000))
316 
  {
317 
    LCD_CtrlLinesWrite(GPIO2, CtrlPin_E2, Bit_SET);   /* E2 = 1 */
318 
    SlaveStatus = GPIO_Read(GPIO2);
319 
    LCD_CtrlLinesWrite(GPIO2, CtrlPin_E2, Bit_RESET); /* E2 = 0 */
320 
  }
321 
}
322 
 
323 
/*******************************************************************************
324 
* Function Name  : LCD_SendMasterCmd
325 
* Description    : Send one byte command to master LCD.
326 
* Input          : - Cmd: the user expected command to send to master LCD
327 
* Output         : None
328 
* Return         : None
329 
*******************************************************************************/
330 
void LCD_SendMasterCmd(u8 Cmd)
331 
{
332 
  /* Check the master status */
333 
  LCD_CheckMasterStatus();
334 
  /* Configure Data lines as Output */
335 
  LCD_DataLinesConfig(Output);
336 
  /* Start the master send command sequence */
337 
  LCD_CtrlLinesWrite(GPIO2, CtrlPin_E1, Bit_RESET);  /* E1 = 0 */
338 
  LCD_CtrlLinesWrite(GPIO2, CtrlPin_RW, Bit_RESET);  /* RW = 0 */
339 
  LCD_CtrlLinesWrite(GPIO2, CtrlPin_DI, Bit_RESET);  /* DI = 0 */
340 
  LCD_CtrlLinesWrite(GPIO2, CtrlPin_E1, Bit_SET);    /* E1 = 1 */
341 
  /* Write master command */
342 
  LCD_DataLinesWrite(GPIO2, (u32)Cmd);
343 
  LCD_CtrlLinesWrite(GPIO2, CtrlPin_E1, Bit_RESET);  /* E1 = 0 */
344 
}
345 
 
346 
/*******************************************************************************
347 
* Function Name  : LCD_SendSlaveCmd
348 
* Description    : Send one byte command to slave LCD
349 
* Input          : - Cmd: the user expected command to send to slave LCD.
350 
* Output         : None
351 
* Return         : None
352 
*******************************************************************************/
353 
void LCD_SendSlaveCmd(u8 Cmd)
354 
{
355 
  /* Check the slave status */
356 
  LCD_CheckSlaveStatus();
357 
  /* Configure Data lines as Output */
358 
  LCD_DataLinesConfig(Output);
359 
  /* Start the slave send command sequence */
360 
  LCD_CtrlLinesWrite(GPIO2, CtrlPin_E2, Bit_RESET);  /* E2 = 0 */
361 
  LCD_CtrlLinesWrite(GPIO2, CtrlPin_RW, Bit_RESET);  /* RW = 0 */
362 
  LCD_CtrlLinesWrite(GPIO2, CtrlPin_DI, Bit_RESET);  /* DI = 0 */
363 
  LCD_CtrlLinesWrite(GPIO2, CtrlPin_E2, Bit_SET);    /* E2 = 1 */
364 
  /* Write slave command */
365 
  LCD_DataLinesWrite(GPIO2, (u32)Cmd);
366 
  LCD_CtrlLinesWrite(GPIO2, CtrlPin_E2, Bit_RESET);  /* E2 = 0 */
367 
}
368 
 
369 
/*******************************************************************************
370 
* Function Name  : LCD_SendMasterData
371 
* Description    : Display one byte data to master LCD.
372 
* Input          : - Data: the user expected data to display on master LCD.
373 
* Output         : None
374 
* Return         : None
375 
*******************************************************************************/
376 
void LCD_SendMasterData(u8 Data)
377 
{
378 
  /* Check the master status */
379 
  LCD_CheckMasterStatus();
380 
  /* Configure Data lines as Output */
381 
  LCD_DataLinesConfig(Output);
382 
  /* Start the master send data sequence */
383 
  LCD_CtrlLinesWrite(GPIO2, CtrlPin_E1, Bit_RESET);  /* E1 = 0 */
384 
  LCD_CtrlLinesWrite(GPIO2, CtrlPin_RW, Bit_RESET);  /* RW = 0 */
385 
  LCD_CtrlLinesWrite(GPIO2, CtrlPin_DI, Bit_SET);    /* DI = 1 */
386 
  LCD_CtrlLinesWrite(GPIO2, CtrlPin_E1, Bit_SET);    /* E1 = 1 */
387 
  /* Write data to the master */
388 
  LCD_DataLinesWrite(GPIO2, (u32)Data);
389 
  LCD_CtrlLinesWrite(GPIO2, CtrlPin_E1, Bit_RESET);  /* E1 = 0 */
390 
}
391 
 
392 
/*******************************************************************************
393 
* Function Name  : LCD_ReadMasterData
394 
* Description    : Read master byte data displayed on master LCD.
395 
* Input          : None
396 
* Output         : None
397 
* Return         : None
398 
*******************************************************************************/
399 
u32 LCD_ReadMasterData(void)
400 
{
401 
  u32 MasterData = 0;
402 
 
403 
  /* Check the master status */
404 
  LCD_CheckMasterStatus();
405 
  /* Configure Data lines as Input */
406 
  LCD_DataLinesConfig(Input);
407 
  /* Start the master read data sequence */
408 
  LCD_CtrlLinesWrite(GPIO2, CtrlPin_E1, Bit_RESET);  /* E1 = 0 */
409 
  LCD_CtrlLinesWrite(GPIO2, CtrlPin_RW, Bit_SET);    /* RW = 1 */
410 
  LCD_CtrlLinesWrite(GPIO2, CtrlPin_DI, Bit_SET);    /* DI = 1 */
411 
  LCD_CtrlLinesWrite(GPIO2, CtrlPin_E1, Bit_SET);    /* E1 = 1 */
412 
  /* Read data from the master */
413 
  MasterData = ((GPIO_Read(GPIO2)&0x3FC00)>>10);
414 
  LCD_CtrlLinesWrite(GPIO2, CtrlPin_E1, Bit_RESET);  /* E1 = 0 */
415 
  /* Read the master returned data */
416 
  return MasterData;
417 
}
418 
 
419 
/*******************************************************************************
420 
* Function Name  : LCD_SendSlaveData
421 
* Description    : Display one byte data to slave LCD.
422 
* Input          : - Data: the user expected data to display on slave LCD.
423 
* Output         : None
424 
* Return         : None
425 
*******************************************************************************/
426 
void LCD_SendSlaveData(u8 Data)
427 
{
428 
  /* Check the slave status */
429 
  LCD_CheckSlaveStatus();
430 
  /* Configure Data lines as Output */
431 
  LCD_DataLinesConfig(Output);
432 
  /* Start the slave send data sequence */
433 
  LCD_CtrlLinesWrite(GPIO2, CtrlPin_E2, Bit_RESET);  /* E2 = 0 */
434 
  LCD_CtrlLinesWrite(GPIO2, CtrlPin_RW, Bit_RESET);  /* RW = 0 */
435 
  LCD_CtrlLinesWrite(GPIO2, CtrlPin_DI, Bit_SET);    /* DI = 1 */
436 
  LCD_CtrlLinesWrite(GPIO2, CtrlPin_E2, Bit_SET);    /* E2 = 1 */
437 
  /* Write data to the slave */
438 
  LCD_DataLinesWrite(GPIO2, (u32)Data);
439 
  LCD_CtrlLinesWrite(GPIO2, CtrlPin_E2, Bit_RESET);  /* E2 = 0 */
440 
}
441 
 
442 
/*******************************************************************************
443 
* Function Name  : LCD_ReadSlaveData
444 
* Description    : Read slave byte data displayed on slave LCD.
445 
* Input          : None
446 
* Output         : None
447 
* Return         : None
448 
*******************************************************************************/
449 
u32 LCD_ReadSlaveData(void)
450 
{
451 
  u32 SlaveData = 0;
452 
 
453 
  /* Check the slave status */
454 
  LCD_CheckSlaveStatus();
455 
  /* Configure Data lines as Input */
456 
  LCD_DataLinesConfig(Input);
457 
  /* Start the slave read data sequence */
458 
  LCD_CtrlLinesWrite(GPIO2, CtrlPin_E2, Bit_RESET);  /* E2 = 0 */
459 
  LCD_CtrlLinesWrite(GPIO2, CtrlPin_RW, Bit_SET);    /* RW = 1 */
460 
  LCD_CtrlLinesWrite(GPIO2, CtrlPin_DI, Bit_SET);    /* DI = 1 */
461 
  LCD_CtrlLinesWrite(GPIO2, CtrlPin_E2, Bit_SET);    /* E2 = 1 */
462 
  /* Read data from the slave */
463 
  SlaveData = ((GPIO_Read(GPIO2)&0x3FC00)>>10);
464 
  LCD_CtrlLinesWrite(GPIO2, CtrlPin_E2, Bit_RESET);  /* E2 = 0 */
465 
  /* Read the slave returned data */
466 
  return SlaveData;
467 
}
468 
 
469 
/*******************************************************************************
470 
* Function Name  : LCD_Init
471 
* Description    : Initialize master and slave LCD.
472 
* Input          : None
473 
* Output         : None
474 
* Return         : None
475 
*******************************************************************************/
476 
void LCD_Init(void)
477 
{
478 
  /* Enable GPIO Clock */
479 
  MRCC_PeripheralClockConfig(MRCC_Peripheral_GPIO, ENABLE);
480 
 
481 
  /* Configure control lines signals as output mode */
482 
  LCD_CtrlLinesConfig();
483 
 
484 
  /* Master LCD Init */
485 
  LCD_SendMasterCmd(SOFTWARE_RESET);
486 
  LCD_SendMasterCmd(DISPLAY_OFF);
487 
  LCD_SendMasterCmd(DYNAMIC_DRIVE);
488 
  LCD_SendMasterCmd(DUTY_CYCLE);
489 
  LCD_SendMasterCmd(CLOCKWISE_OUTPUT);
490 
  LCD_SendMasterCmd(READ_MODIFY_WRITE_OFF);
491 
  LCD_SendMasterCmd(START_COLUMN);          /* Set master column address to 0 */
492 
  LCD_SendMasterCmd(START_LINE);            /* Set master display start line to 0 */
493 
  LCD_SendMasterCmd(DISPLAY_ON );
494 
 
495 
  /* Slave LCD Init */
496 
  LCD_SendSlaveCmd(SOFTWARE_RESET);
497 
  LCD_SendSlaveCmd(DISPLAY_OFF);
498 
  LCD_SendSlaveCmd(DYNAMIC_DRIVE);
499 
  LCD_SendSlaveCmd(DUTY_CYCLE);
500 
  LCD_SendSlaveCmd(CLOCKWISE_OUTPUT);
501 
  LCD_SendSlaveCmd(READ_MODIFY_WRITE_OFF);
502 
  LCD_SendSlaveCmd(START_COLUMN );          /* Set slave column address to 0 */
503 
  LCD_SendSlaveCmd(START_LINE);             /* Set slave display start line to 0 */
504 
  LCD_SendSlaveCmd(DISPLAY_ON);
505 
 
506 
  /* Clear LCD */
507 
  LCD_Clear();
508 
  /* Set current Page to 0 for Master and Slave LCDs */
509 
  LCD_SetSlavePage(0);
510 
  LCD_SetMasterPage(0);
511 
}
512 
 
513 
/*******************************************************************************
514 
* Function Name  : LCD_SetSlavePage
515 
* Description    : Set the display page of slave LCD, the page range is 0 to 3,
516 
*                  make sure the input will not exceed this range ,otherwise it
517 
*                  will reach a undecided result.
518 
* Input          : - Page: specifies the expected display page of slave LCD
519 
* Output         : None
520 
* Return         : None
521 
*******************************************************************************/
522 
void LCD_SetSlavePage(u8 Page)
523 
{
524 
  /* Set Slave page */
525 
  LCD_SendSlaveCmd(0xB8|Page);
526 
}
527 
 
528 
/*******************************************************************************
529 
* Function Name  : LCD_SetMasterPage
530 
* Description    : Set the display page of master LCD, the page range is 0 to 3,
531 
*                  make sure the input will not exceed this range ,otherwise it
532 
*                  will reach a undecided result.
533 
* Input          : - Page: specifies the expected display page of master LCD
534 
* Output         : None
535 
* Return         : None
536 
*******************************************************************************/
537 
void LCD_SetMasterPage(u8 Page)
538 
{
539 
  /* Set Master page */
540 
  LCD_SendMasterCmd(0xB8|Page);
541 
}
542 
 
543 
/*******************************************************************************
544 
* Function Name  : SetAddress
545 
* Description    : Set the display column of slave LCD. Column range is 0 to 61.
546 
* Input          : - Address: specifies the expected display column of slave LCD
547 
* Output         : None
548 
* Return         : None
549 
*******************************************************************************/
550 
void LCD_SetSlaveColumn(u8 Address)
551 
{
552 
  /* Set Slave column address */
553 
  LCD_SendSlaveCmd(Address&0x7F);
554 
}
555 
 
556 
/*******************************************************************************
557 
* Function Name  : LCD_SetMasterColumn
558 
* Description    : Set the display column of master LCD. Column range is 0 to 61.
559 
* Input          : - Address: specifies the expected display column of slave LCD
560 
* Output         : None
561 
* Return         : None
562 
*******************************************************************************/
563 
void LCD_SetMasterColumn(u8 Address)
564 
{
565 
  /* Set Master column address */
566 
  LCD_SendMasterCmd(Address&0x7F);
567 
}
568 
 
569 
/*******************************************************************************
570 
* Function Name  : LCD_SetTextColor
571 
* Description    : Set the text color for LCD.
572 
* Input          : - TextColor: BlackText: character on black, bottom on white.
573 
*                               WhiteText: character on white, bottom on black.
574 
* Output         : None
575 
* Return         : None
576 
*******************************************************************************/
577 
void LCD_SetTextColor(TextColorMode_TypeDef TextColor)
578 
{
579 
  if(TextColor)
580 
  {
581 
    /* Set White Text color */
582 
    TextMode=WhiteText;
583 
  }
584 
  else
585 
  {
586 
    /* Set Black Text color */
587 
    TextMode=BlackText;
588 
  }
589 
}
590 
 
591 
/*******************************************************************************
592 
* Function Name  : LCD_Clear
593 
* Description    : Clear the Master and Slave LCDs display.
594 
* Input          : None
595 
* Output         : None
596 
* Return         : None
597 
*******************************************************************************/
598 
void LCD_Clear(void)
599 
{
600 
  u8 Page = 0, Column = 0;
601 
 
602 
  /* Clear master and slave LCDs page by page */
603 
  for (Page=0; Page<4; Page++)
604 
  {
605 
    /* Set master and slave page by page */
606 
    LCD_SetMasterPage(Page);
607 
    LCD_SetSlavePage(Page);
608 
    /* Set master and slave column address */
609 
    LCD_SetMasterColumn(0);
610 
    LCD_SetSlaveColumn(0);
611 
    /* Send empty data to master and slave column address on the selected page */
612 
    for (Column=0; Column<61; Column++)
613 
    {
614 
      LCD_SendSlaveData(0);
615 
      LCD_SendMasterData(0);
616 
    }
617 
  }
618 
}
619 
 
620 
/*******************************************************************************
621 
* Function Name  : LCD_ClearLine
622 
* Description    : Clear the selected line of the LCD.
623 
* Input          : - Line: the Line to clear.
624 
*                      - Line1 (Page0&1): clear the first line
625 
*                      - Line2 (Page2&3): clear the second line
626 
* Output         : None
627 
* Return         : None
628 
*******************************************************************************/
629 
void LCD_ClearLine(u8 Line)
630 
{
631 
  u8 Page = 0, Column = 0;
632 
 
633 
  /* Clear the slected master and slave line */
634 
  for (Page=Line; Page<Line+2; Page++)
635 
  {
636 
    /* Set master and slave page by page */
637 
    LCD_SetMasterPage(Page);
638 
    LCD_SetSlavePage(Page);
639 
    /* Set master and slave column address */
640 
    LCD_SetMasterColumn(0);
641 
    LCD_SetSlaveColumn(0);
642 
    /* Send empty data to master and slave column address on the selected page */
643 
    for (Column=0; Column<61; Column++)
644 
    {
645 
      LCD_SendSlaveData(0);
646 
      LCD_SendMasterData(0);
647 
    }
648 
  }
649 
}
650 
 
651 
/*******************************************************************************
652 
* Function Name  : LCD_ClearMaster
653 
* Description    : Clear the master LCD.
654 
* Input          : None
655 
* Output         : None
656 
* Return         : None
657 
*******************************************************************************/
658 
void LCD_ClearMaster(void)
659 
{
660 
  u8 Page = 0, Column = 0;
661 
 
662 
  /* Clear all master LCD pages */
663 
  for (Page=0; Page<4; Page++)
664 
  {
665 
    /* Set master page by page */
666 
    LCD_SetMasterPage(Page);
667 
    /* Set master column address */
668 
    LCD_SetMasterColumn(0);
669 
    /* Send empty data to master column address on the selected page */
670 
    for (Column=0; Column<61; Column++)
671 
    {
672 
      LCD_SendMasterData(0);
673 
    }
674 
  }
675 
}
676 
 
677 
/*******************************************************************************
678 
* Function Name  : LCD_ClearSlave
679 
* Description    : Clear the slave LCD.
680 
* Input          : None
681 
* Output         : None
682 
* Return         : None
683 
*******************************************************************************/
684 
void LCD_ClearSlave()
685 
{
686 
  u8 Page = 0, Column = 0;
687 
 
688 
  /* Clear all slave LCD pages */
689 
  for (Page=0; Page<4; Page++)
690 
  {
691 
    /* Set slave page by page */
692 
    LCD_SetSlavePage(Page);
693 
    /* Set slave column address */
694 
    LCD_SetSlaveColumn(0);
695 
    /* Send empty data to slave column address on the selected page */
696 
    for (Column=0; Column<61; Column++)
697 
    {
698 
      LCD_SendSlaveData(0);
699 
    }
700 
  }
701 
}
702 
 
703 
/*******************************************************************************
704 
* Function Name  : LCD_DrawChar
705 
* Description    : Draw a character in LCD.
706 
*                  Note:
707 
*                  the LCD can only display two line character,so page 0 and 1
708 
*                  is to display the first line, page2 and page 3 is to display
709 
*                  the second line.
710 
* Input          : - Line: the Line where to display the character shape .
711 
*                      - Line1 (Page0&1): display character on the first line
712 
*                      - Line2 (Page2&3): display character on the second line
713 
*                  - Column: start column address.
714 
*                  - Width: the number of column (dots) of a character width.
715 
*                  - Bmp: the pointer of the dot matrix data.
716 
* Output         : None
717 
* Return         : None
718 
*******************************************************************************/
719 
void LCD_DrawChar(u8 Line, u8 Column, u8 Width, u8 *Bmp)
720 
{
721 
  u8 X = 0, ActualColumn = 0, Window = 0, i = 0;
722 
 
723 
  /* Draw the character column by column: width times */
724 
  for(X = Column; X<(Column+Width); X++)
725 
  {
726 
    if(X > 121)
727 
    {
728 
      /* Return if column exceeded 121 */
729 
      return;
730 
    }
731 
    if (X > 60)
732 
    {
733 
      /* To be displayed on slave LCD (Window = 1) */
734 
      Window = 1;
735 
      /* Get the Slave relative start column */
736 
      ActualColumn = X%61;
737 
    }
738 
    else
739 
    {
740 
      /* To be displayed on master LCD (Window = 0) */
741 
      ActualColumn = X;
742 
    }
743 
 
744 
    /* Switch window, display the character upper part */
745 
    if (Window)
746 
    {
747 
      /* Display it on slave LCD */
748 
      LCD_SetSlavePage(Line);
749 
      LCD_SetSlaveColumn(ActualColumn);
750 
      LCD_SendSlaveData(Bmp[i]);
751 
    }
752 
    else
753 
    {
754 
      /* Display it on master LCD */
755 
      LCD_SetMasterPage(Line);
756 
      LCD_SetMasterColumn(ActualColumn);
757 
      LCD_SendMasterData(Bmp[i]);
758 
    }
759 
    /* Switch window, diplay the character lower part  */
760 
    if (Window)
761 
    {
762 
      /* Display it on slave LCD */
763 
      LCD_SetSlavePage(Line+1);
764 
      LCD_SetSlaveColumn(ActualColumn);
765 
      LCD_SendSlaveData(Bmp[i+1]);
766 
    }
767 
    else
768 
    {
769 
      /* Display it on master LCD */
770 
      LCD_SetMasterPage(Line+1);
771 
      LCD_SetMasterColumn(ActualColumn);
772 
      LCD_SendMasterData(Bmp[i+1]);
773 
    }
774 
    /* Increment by 2 the character table index */
775 
    i+=2;
776 
  }
777 
}
778 
 
779 
/*******************************************************************************
780 
* Function Name  : LCD_DisplayChar
781 
* Description    : Display one character (7dots large, 16dots high).
782 
*                  Note:
783 
*                  the LCD can only display two line character,so page 0 and 1
784 
*                  is to display the first line, page2 and page 3 is to display
785 
*                  the second line.
786 
* Input          : - Line: the Line where to display the character.
787 
*                      - Line1 (Page0&1): display character on the first line
788 
*                      - Line2 (Page2&3): display character on the second line
789 
*                  - Column: start column address.
790 
*                  - Ascii: character ascii code.
791 
*                  - CharMode: BlackText: character on black, bottom on white.
792 
*                              WhiteText: character on white, bottom on black.
793 
* Output         : None
794 
* Return         : None
795 
*******************************************************************************/
796 
void LCD_DisplayChar(u8 Line, u8 Column, u8 Ascii, TextColorMode_TypeDef CharMode)
797 
{
798 
  u8  DotBuffer[14], i = 0;
799 
 
800 
  /* Display the character lower and upper 8bit parts (2*7columns) */
801 
  for (i=0;i<14;i++)
802 
  {
803 
    /* Character displayed as white Text on black buttom  */
804 
    if(CharMode)
805 
    {
806 
      if(i%2==0)
807 
      {
808 
        DotBuffer[i] = ~AsciiDotsTable[Ascii*14+i+1];
809 
      }
810 
      else
811 
      {
812 
        DotBuffer[i] = ~AsciiDotsTable[Ascii*14+i-1];
813 
      }
814 
    }
815 
    /* Character displayed as black Text on white buttom  */
816 
    else
817 
    {
818 
      if(i%2==0)
819 
      {
820 
        DotBuffer[i] = AsciiDotsTable[Ascii*14+i+1];
821 
      }
822 
      else
823 
      {
824 
        DotBuffer[i] = AsciiDotsTable[Ascii*14+i-1];
825 
      }
826 
    }
827 
  }
828 
  /* Display the asc code after conversion */
829 
  LCD_DrawChar(Line, Column, 7, DotBuffer);
830 
}
831 
 
832 
/*******************************************************************************
833 
* Function Name  : LCD_HexToAsciiLow
834 
* Description    : This function is used to convert the low nibble of an
835 
*                  unsigned byte (0-F hex) to ASCII.
836 
* Input          : - byte: byte to convert to ASCII.
837 
* Output         : None
838 
* Return         : ASCII value result of the conversion.
839 
*******************************************************************************/
840 
u8 LCD_HexToAsciiLow(u8 byte)
841 
{
842 
  /* Keep lower nibble only */
843 
  byte = byte & 0x0F;
844 
  /* If the ascii is a number */
845 
  if (byte <= 0x09)
846 
  {
847 
    /* Add 0x30 to its ascii */
848 
    return(byte + 0x30);
849 
  }
850 
  else
851 
  {
852 
    /* Add 0x37 to its ascii */
853 
    return (byte + 0x37);
854 
  }
855 
}
856 
 
857 
/*******************************************************************************
858 
* Function Name  : LCD_HexToAsciiHigh
859 
* Description    : This function is used to convert the high nibble of an
860 
*                  unsigned byte (0-F hex) to ASCII.
861 
* Input          : - byte: byte to convert to ASCII.
862 
* Output         : None
863 
* Return         : ASCII value result of the conversion.
864 
*******************************************************************************/
865 
u8 LCD_HexToAsciiHigh(u8 byte)
866 
{
867 
  /* Keep upper nibble only */
868 
  byte = byte & 0xF0;
869 
  byte = byte >> 4;
870 
  /* If the ascii is a number */
871 
  if (byte <= 0x09)
872 
  {
873 
    /* Add 0x30 to display its ascii */
874 
    return(byte + 0x30);
875 
  }
876 
  else
877 
  {
878 
    /* Add 0x37 to display its ascii */
879 
    return (byte + 0x37);
880 
  }
881 
}
882 
 
883 
/*******************************************************************************
884 
* Function Name  : LCD_DisplayString
885 
* Description    : This function is used to display a 17char max string of
886 
*                  characters on the LCD display on the selected line.
887 
*                  Note:
888 
*                  this function is the user interface to use the LCD driver.
889 
* Input          : - *ptr: pointer to string to display on LCD.
890 
*                  - Line: the Line where to display the character.
891 
*                      - Line1 (Page0&1): display character on the first line
892 
*                      - Line2 (Page2&3): display character on the second line
893 
* Output         : None
894 
* Return         : None
895 
*******************************************************************************/
896 
void LCD_DisplayString(u8 Line, u8 *ptr, TextColorMode_TypeDef CharMode)
897 
{
898 
  u8 RefColumn = 0, i = 0;
899 
 
900 
  /* Send the string character by character on lCD */
901 
  while ((*ptr!=0)&(i<17))
902 
  {
903 
    /* Display one character on LCD */
904 
    LCD_DisplayChar(Line, RefColumn, *ptr, CharMode);
905 
    /* Increment the column position by 7 */
906 
    RefColumn+=7;
907 
    /* Point on the next character */
908 
    ptr++;
909 
    /* Increment the character counter */
910 
    i++;
911 
    /* If we reach the maximum Line character */
912 
    if(i==17)
913 
    {
914 
      LCD_DisplayChar(Line, RefColumn-1, 0x1f, CharMode); /* Add missed columns */
915 
    }
916 
  }
917 
}
918 
 
919 
/*******************************************************************************
920 
* Function Name  : LCD_Printf
921 
* Description    : This function is used to display a string of characters
922 
*                  on the LCD display.
923 
*                  Note:
924 
*                  this function is the user interface to use the LCD driver.
925 
* Input          : - *ptr: pointer to string to display on LCD.
926 
* Output         : None
927 
* Return         : None
928 
*******************************************************************************/
929 
void LCD_Printf(u8 *ptr, ...)
930 
{
931 
  u8 RefColumn = 0, RefPage = 0, i = 0, c1 = 0;
932 
  u16  var = 0, c2 = 0, c3 = 0, c4 = 0, c5 = 0;
933 
  u32 WordVar = 0;
934 
 
935 
  /* Store pointer on LCD_Printf second parameter (String) */
936 
  u8 *var_ptr=(u8 *)(&ptr+1);
937 
 
938 
  /* Send String */
939 
  while (*ptr != 0)
940 
  {
941 
    c1 = *ptr;
942 
    /* Limited to AsciiDotsTable code table */
943 
    if(c1 <= 128)
944 
    {
945 
      /* Carriage return */
946 
      if ( *ptr == '\r')
947 
      {
948 
        ptr++;
949 
        RefColumn = 0;
950 
      }
951 
      /* Jump to Line2 */
952 
      else if( *ptr == '\n')
953 
      {
954 
        /* Point on the string to display */
955 
        ptr++;
956 
        /* Clear Line2 */
957 
        LCD_ClearLine(Line2);
958 
        /* Point on first Line2 column */
959 
        RefColumn = 0;
960 
        /* Increment RefPage by 2 */
961 
        RefPage+=2;
962 
      }
963 
      /* Display value on the passed format */
964 
      else if( *ptr == '%')
965 
      {
966 
        ptr++;
967 
        /* Display decimal value */
968 
        if (*ptr == 'd')
969 
        {
970 
          ptr++;
971 
          /* Get the word value to display */
972 
          WordVar = ((*var_ptr)|(*(var_ptr+1)<<8)|(*(var_ptr+2)<<16));
973 
          c1=WordVar/10000;
974 
          c2=(WordVar%10000)/1000;
975 
          c3=(WordVar%1000)/100;
976 
          c4=(WordVar%100)/10;
977 
          c5=(WordVar%10);
978 
          /* Display the ten miles digit */
979 
          if (c1!=0)
980 
          {
981 
            LCD_DisplayChar(RefPage, RefColumn, c1+0x30, TextMode);
982 
            RefColumn+=7;
983 
          }
984 
          /* Display the miles digit */
985 
          if (!((c1==0)&(c2==0)))
986 
          {
987 
          LCD_DisplayChar(RefPage, RefColumn, c2+0x30, TextMode);
988 
          RefColumn+=7;
989 
          }
990 
          /* Display the hundred digit */
991 
          if (!((c1==0)&(c2==0)&(c3==0)))
992 
          {
993 
          LCD_DisplayChar(RefPage, RefColumn, c3+0x30, TextMode);
994 
          RefColumn+=7;
995 
          }
996 
          /* Display the tens digit */
997 
          if (!((c1==0)&(c2==0)&(c3==0)&(c4==0)))
998 
          {
999 
          LCD_DisplayChar(RefPage, RefColumn, c4+0x30, TextMode);
1000 
          RefColumn+=7;
1001 
          }
1002 
          /* Display the rest */
1003 
          LCD_DisplayChar(RefPage, RefColumn, c5+0x30, TextMode);
1004 
          RefColumn+=7;
1005 
        }
1006 
        /* Display 16bits Hex value */
1007 
        else if (*ptr == 'x')
1008 
        {
1009 
          ptr++;
1010 
          /* Display 8bits MSB */
1011 
          var_ptr = var_ptr +1;
1012 
          var = *var_ptr;
1013 
          c1 = LCD_HexToAsciiHigh(var);
1014 
          LCD_DisplayChar(RefPage, RefColumn, c1, TextMode);
1015 
          RefColumn+=7;
1016 
          c1 = LCD_HexToAsciiLow(var);
1017 
          LCD_DisplayChar(RefPage, RefColumn, c1, TextMode);
1018 
          RefColumn+=7;
1019 
          /* Display 8bits LSB */
1020 
          var_ptr = var_ptr -1;
1021 
          var = *var_ptr;
1022 
          var_ptr = var_ptr +4;
1023 
          c1 = LCD_HexToAsciiHigh(var);
1024 
          LCD_DisplayChar(RefPage, RefColumn, c1, TextMode);
1025 
          RefColumn+=7;
1026 
          c1 = LCD_HexToAsciiLow(var);
1027 
          LCD_DisplayChar(RefPage, RefColumn, c1, TextMode);
1028 
          RefColumn+=7;
1029 
        }
1030 
        /* Display 32bits Hex value */
1031 
        else if (*ptr == 'w')
1032 
        {
1033 
          ptr++;
1034 
          /* Display 16bits MSB */
1035 
          var_ptr = var_ptr +3;
1036 
          var = *var_ptr;
1037 
          c1 = LCD_HexToAsciiHigh(var);
1038 
          LCD_DisplayChar(RefPage, RefColumn, c1, TextMode);
1039 
          RefColumn+=7;
1040 
          c1 = LCD_HexToAsciiLow(var);
1041 
          LCD_DisplayChar(RefPage, RefColumn, c1, TextMode);
1042 
          RefColumn+=7;
1043 
          var_ptr = var_ptr -1;
1044 
          var = *var_ptr;
1045 
          c1 = LCD_HexToAsciiHigh(var);
1046 
          LCD_DisplayChar(RefPage, RefColumn, c1, TextMode);
1047 
          RefColumn+=7;
1048 
          c1 = LCD_HexToAsciiLow(var);
1049 
          LCD_DisplayChar(RefPage, RefColumn, c1, TextMode);
1050 
          RefColumn+=7;
1051 
          /* Display 16bits LSB */
1052 
          var_ptr = var_ptr -1;
1053 
          var = *var_ptr;
1054 
          var_ptr = var_ptr +4;
1055 
          c1 = LCD_HexToAsciiHigh(var);
1056 
          LCD_DisplayChar(RefPage, RefColumn, c1, TextMode);
1057 
          RefColumn+=7;
1058 
          c1 = LCD_HexToAsciiLow(var);
1059 
          LCD_DisplayChar(RefPage, RefColumn, c1, TextMode);
1060 
          RefColumn+=7;
1061 
          var_ptr = var_ptr -5;
1062 
          var = *var_ptr;
1063 
          var_ptr = var_ptr +4;
1064 
          c1 = LCD_HexToAsciiHigh(var);
1065 
          LCD_DisplayChar(RefPage, RefColumn, c1, TextMode);
1066 
          RefColumn+=7;
1067 
          c1 = LCD_HexToAsciiLow(var);
1068 
          LCD_DisplayChar(RefPage, RefColumn, c1, TextMode);
1069 
          RefColumn+=7;
1070 
        }
1071 
        else
1072 
        {
1073 
          /* Display '%' character which is followed by (d, x or w) */
1074 
          ptr--;
1075 
          c1 = *ptr;
1076 
          LCD_DisplayChar(RefPage, RefColumn, c1, TextMode);
1077 
          RefColumn+=7;
1078 
          ptr++;
1079 
          i++;
1080 
          if(i==17)
1081 
          {
1082 
            /* Add missed columns */
1083 
            LCD_DisplayChar(RefPage, RefColumn-1, 0x1f, TextMode);
1084 
            RefColumn = 0;
1085 
            RefPage+=2;
1086 
          }
1087 
        }
1088 
      }
1089 
      else
1090 
      {
1091 
        /* Display characters different from (\r, \n, %) */
1092 
        LCD_DisplayChar(RefPage, RefColumn, c1, TextMode);
1093 
        RefColumn+=7;
1094 
        ptr++;
1095 
        i++;
1096 
        if(i==17)
1097 
        {
1098 
          /* Add missed columns */
1099 
          LCD_DisplayChar(RefPage, RefColumn-1, 0x1f, TextMode);
1100 
          LCD_ClearLine(Line2);
1101 
          RefColumn = 0;
1102 
          RefPage+=2;
1103 
        }
1104 
      }
1105 
    }
1106 
  }
1107 
  /* Display spaces if string doesn't reach the max LCD characters size */
1108 
  while(RefColumn<119)
1109 
  {
1110 
    /* Display Spaces */
1111 
    LCD_DisplayChar(RefPage, RefColumn, 0x20, TextMode);
1112 
    RefColumn+=7;
1113 
    /* Add missed columns */
1114 
    LCD_DisplayChar(RefPage, RefColumn, 0x1f, TextMode);
1115 
  }
1116 
}
1117 
 
1118 
/*******************************************************************************
1119 
* Function Name  : LCD_DrawMasterGraphic
1120 
* Description    : Draw a Graphic image on master LCD.
1121 
* Input          : - Bmp: the pointer of the dot matrix data.
1122 
* Output         : None
1123 
* Return         : None.
1124 
*******************************************************************************/
1125 
void LCD_DrawMasterGraphic(u8 *Bmp)
1126 
{
1127 
  u8 j = 0, k = 0, ActPage = 0;
1128 
 
1129 
  /* Draw graphic on master: 61 Column *4 Pages */
1130 
  while(j<244)
1131 
  {
1132 
    /* Draw on master page by page */
1133 
    LCD_SetMasterPage(ActPage);
1134 
    for(k=0; k<61; k++)
1135 
    {
1136 
      LCD_SetMasterColumn(k);
1137 
      LCD_SendMasterData(*Bmp++);
1138 
      j++;
1139 
    }
1140 
    ActPage++;
1141 
  }
1142 
}
1143 
 
1144 
/*******************************************************************************
1145 
* Function Name  : LCD_DrawSlaveGraphic
1146 
* Description    : Draw a Graphic image on slave LCD.
1147 
* Input          : - Bmp: the pointer of the dot matrix data.
1148 
* Output         : None
1149 
* Return         : None.
1150 
*******************************************************************************/
1151 
void LCD_DrawSlaveGraphic(u8 *Bmp)
1152 
{
1153 
  u8 j = 0, k = 0, ActPage = 0;
1154 
 
1155 
  /* Draw graphic on slave: 61 Column *4 Pages */
1156 
  while(j<244)
1157 
  {
1158 
    /* Draw on slave page by page */
1159 
    LCD_SetSlavePage(ActPage);
1160 
    for(k=0; k<61; k++)
1161 
    {
1162 
      LCD_SetSlaveColumn(k);
1163 
      LCD_SendSlaveData(*Bmp++);
1164 
      j++;
1165 
    }
1166 
    ActPage++;
1167 
  }
1168 
}
1169 
 
1170 
/*******************************************************************************
1171 
* Function Name  : LCD_DrawGraphic
1172 
* Description    : Draw a Graphic image on LCD.
1173 
* Input          : - Bmp: the pointer of the dot matrix data.
1174 
* Output         : None
1175 
* Return         : None.
1176 
*******************************************************************************/
1177 
void LCD_DrawGraphic(u8 *Bmp)
1178 
{
1179 
  u8 Pos = 0, ActPage = 0;
1180 
  u16 j = 0, k = 0;
1181 
 
1182 
  /* Draw graphic on LCD: 122 Column *4 Pages */
1183 
  while(j<488)
1184 
  {
1185 
    if(!Pos)
1186 
    {
1187 
      /* Draw on master page by page */
1188 
      LCD_SetMasterPage(ActPage);
1189 
      for(k=0; k<61; k++)
1190 
      {
1191 
        LCD_SetMasterColumn(k);
1192 
        LCD_SendMasterData(*Bmp++);
1193 
        j++;
1194 
      }
1195 
      Pos=1;
1196 
    }
1197 
    else
1198 
    {
1199 
      /* Draw on slave page by page */
1200 
      LCD_SetSlavePage(ActPage);
1201 
      for(k=0; k<61; k++)
1202 
      {
1203 
        LCD_SetSlaveColumn(k);
1204 
        LCD_SendSlaveData(*Bmp++);
1205 
        j++;
1206 
      }
1207 
      ActPage++;
1208 
      Pos=0;
1209 
    }
1210 
  }
1211 
}
1212 
 
1213 
/*******************************************************************************
1214 
* Function Name  : LCD_ScrollGraphic
1215 
* Description    : Scroll a Graphic image on LCD.
1216 
* Input          : - Bmp: the pointer of the dot matrix data.
1217 
*                  - nCount: specifies the delay time length.
1218 
* Output         : None
1219 
* Return         : None.
1220 
*******************************************************************************/
1221 
void LCD_ScrollGraphic(u8 *Bmp, u32 nCount)
1222 
{
1223 
  u8 Pos = 0, ActPage = 0;
1224 
  u16 j = 0, k = 0;
1225 
  u32 Counter = 0;
1226 
 
1227 
  /* Draw graphic on LCD: 122 Column *4 Pages */
1228 
  while(j<488)
1229 
  {
1230 
    if(!Pos)
1231 
    {
1232 
      /* Draw on master page by page */
1233 
      LCD_SetMasterPage(ActPage);
1234 
      for(k=0; k<61; k++)
1235 
      {
1236 
        LCD_SetMasterColumn(k);
1237 
        LCD_SendMasterData(*Bmp++);
1238 
        Counter = nCount;
1239 
        /* Set a delay */
1240 
        for(; Counter != 0; Counter--);
1241 
        j++;
1242 
      }
1243 
      Pos=1;
1244 
    }
1245 
    else
1246 
    {
1247 
      /* Draw on slave page by page */
1248 
      LCD_SetSlavePage(ActPage);
1249 
      for(k=0; k<61; k++)
1250 
      {
1251 
        LCD_SetSlaveColumn(k);
1252 
        Counter = nCount;
1253 
        /* Set a delay */
1254 
        for(; Counter != 0; Counter--);
1255 
        LCD_SendSlaveData(*Bmp++);
1256 
        j++;
1257 
      }
1258 
      ActPage++;
1259 
      Pos=0;
1260 
    }
1261 
  }
1262 
}
1263 
 
1264 
/*******************************************************************************
1265 
* Function Name  : LCD_DrawPixel
1266 
* Description    : Draw a Graphic image on slave LCD.
1267 
* Input          : - XPos: the dot line number of the pixel.
1268 
*                      - 1->61 : displayed on master LCD
1269 
*                      - 62->122: displayed on slave LCD
1270 
*                  - YPos: column address of the pixel from 1->32.
1271 
*                  - Mode: Dot_On: Pixel turned on (black).
1272 
*                          Dot_Off: Pixel turned off (black).
1273 
* Output         : None
1274 
* Return         : None.
1275 
*******************************************************************************/
1276 
void LCD_DrawPixel(u8 XPos, u8 YPos, DotMode_TypeDef Mode)
1277 
{
1278 
  u8 Page = 0, Position = 0;
1279 
  u16 Mask = 0;
1280 
  u32 MasterDataIn = 0, MasterDataOut = 0, SlaveDataIn = 0, SlaveDataOut = 0;
1281 
 
1282 
  /* Pixel page */
1283 
  Page = (XPos-1)/8;
1284 
  /* Pixel column  */
1285 
  Position = (YPos-1)/61; /* 0:Master, 1:Slave */
1286 
  /* Mask for the pixel */
1287 
  Mask= 1<<((XPos-1)%8);
1288 
  /* If Position=0 draw pixel on master LCD */
1289 
  if(!Position)
1290 
  {
1291 
    LCD_SetMasterPage(Page);
1292 
    LCD_SetMasterColumn(YPos-1);
1293 
    MasterDataIn = LCD_ReadMasterData();
1294 
    MasterDataIn = LCD_ReadMasterData();
1295 
    LCD_SetMasterColumn(YPos-1);
1296 
    if(Mode==Dot_On)
1297 
    {
1298 
      MasterDataOut = MasterDataIn | Mask;
1299 
    }
1300 
    else
1301 
    {
1302 
      MasterDataOut = MasterDataIn & (~Mask);
1303 
    }
1304 
    LCD_SendMasterData(MasterDataOut);
1305 
  }
1306 
  /* If Position=1 draw pixel on slave LCD */
1307 
  else
1308 
  {
1309 
    LCD_SetSlavePage(Page);
1310 
    LCD_SetSlaveColumn(YPos-62);
1311 
    SlaveDataIn = LCD_ReadSlaveData();
1312 
    SlaveDataIn = LCD_ReadSlaveData();
1313 
    LCD_SetSlaveColumn(YPos-62);
1314 
    if(Mode==Dot_On)
1315 
    {
1316 
      SlaveDataOut = SlaveDataIn | Mask;
1317 
    }
1318 
    else
1319 
    {
1320 
      SlaveDataOut = SlaveDataIn & (~Mask);
1321 
    }
1322 
    LCD_SendSlaveData(SlaveDataOut);
1323 
  }
1324 
}
1325 
 
1326 
/*******************************************************************************
1327 
* Function Name  : LCD_DrawLine
1328 
* Description    : Draw a line on master and slave LCDs.
1329 
* Input          : - XPos1: the dot line number of the source point .
1330 
*                  - XPos2: the dot line number of the destination point .
1331 
*                  - YPos1: the dot column number of the source point.
1332 
*                  - YPos2: the dot column number of the destination point.
1333 
* Output         : None
1334 
* Return         : None.
1335 
*******************************************************************************/
1336 
void LCD_DrawLine(u8 XPos1, u8 YPos1, u8 XPos2, u8 YPos2)
1337 
{
1338 
  u8 XPos = 0, YPos = 0;
1339 
 
1340 
  /* Use XPos1, YPos1, XPos2 and YPos2 */
1341 
  if((XPos2>=XPos1)&(YPos2>=YPos1))
1342 
  {
1343 
    for(XPos=XPos1; XPos<=XPos2; XPos++)
1344 
    {
1345 
      for(YPos=YPos1; YPos<=YPos2; YPos++)
1346 
      {
1347 
        LCD_DrawPixel(XPos, YPos, Dot_On);
1348 
      }
1349 
    }
1350 
  }
1351 
  else if((XPos2<XPos1)&(YPos2>=YPos1))
1352 
  {
1353 
    for(XPos=XPos2; XPos<=XPos1; XPos++)
1354 
    {
1355 
      for(YPos=YPos1; YPos<=YPos2; YPos++)
1356 
      {
1357 
        LCD_DrawPixel(XPos, YPos, Dot_On);
1358 
      }
1359 
    }
1360 
  }
1361 
  else if((XPos2>=XPos1)&(YPos2<YPos1))
1362 
  {
1363 
    for(XPos=XPos1; XPos<=XPos2; XPos++)
1364 
    {
1365 
      for(YPos=YPos2; YPos<=YPos1; YPos++)
1366 
      {
1367 
        LCD_DrawPixel(XPos, YPos, Dot_On);
1368 
      }
1369 
    }
1370 
  }
1371 
  else /*if((XPos2<XPos1)&(YPos2<YPos1))*/
1372 
  {
1373 
    for(XPos=XPos2; XPos<=XPos1; XPos++)
1374 
    {
1375 
      for(YPos=YPos2; YPos<=YPos1; YPos++)
1376 
      {
1377 
        LCD_DrawPixel(XPos, YPos, Dot_On);
1378 
      }
1379 
    }
1380 
  }
1381 
}
1382 
 
1383 
/*******************************************************************************
1384 
* Function Name  : LCD_DrawBox
1385 
* Description    : Draw a Box on master and slave LCDs.
1386 
* Input          : - XPos: the dot line number of the source point .
1387 
*                  - YPos: the dot column number of the source point.
1388 
*                  - Dx: Box large.
1389 
*                  - Dy: Box width.
1390 
* Output         : None
1391 
* Return         : None.
1392 
*******************************************************************************/
1393 
void LCD_DrawBox(u8 XPos, u8 YPos, u8 Dx, u8 Dy)
1394 
{
1395 
  /* Use XPos, YPos, Dx and Dy */
1396 
  LCD_DrawLine(XPos, YPos, XPos, YPos+Dy);
1397 
  LCD_DrawLine(XPos, YPos, XPos+Dx, YPos);
1398 
  LCD_DrawLine(XPos+Dx, YPos, XPos+Dx, YPos+Dy);
1399 
  LCD_DrawLine(XPos, YPos+Dy, XPos+Dx, YPos+Dy);
1400 
}
1401 
 
1402 
/******************* (C) COPYRIGHT 2006 STMicroelectronics *****END OF FILE******/
1403 
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.