begriffs open source - cmsis-freertos/blob - Demo/ARM9_STR91X

2 * File Name : lcd.c

3 * Author : MCD Application Team

4 * Date First Issued : 05/18/2006 : Version 1.0

5 * Description : This file includes the LCD driver for GXM12232-2SL liquid

6 * Crystal Display Module of STR75x-EVAL.

7 ********************************************************************************

8 * History:

9 * 05/24/2006 : Version 1.1

10 * 05/18/2006 : Version 1.0

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 "91x_lib.h"

22 #include "lcd.h"

23 #include "FreeRTOS.h"

24 #include "task.h"

25

26 /* Private typedef -----------------------------------------------------------*/

27 static GPIO_InitTypeDef GPIO_InitStructure;

28

29 /* Private define ------------------------------------------------------------*/

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 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 (P8.0~P8.7) 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_All;

182 if (Mode == Input)

183 {

184 /* Configure D0~D7 lines (P8.0 ->P8.7) as Input */

185 GPIO_InitStructure.GPIO_Direction = GPIO_PinInput;

186 }

187 else

188 {

189 /* Configure D0~D7 lines in Output Push-Pull mode */

190 GPIO_InitStructure.GPIO_Direction = GPIO_PinOutput ;

191 GPIO_InitStructure.GPIO_Type = GPIO_Type_PushPull ;

192 }

193 GPIO_Init(GPIO8, &GPIO_InitStructure);

194 }

195

196 /*******************************************************************************

197 * Function Name : LCD_DataLinesWrite

198 * Description : Write a value on D0~D7 (P8.0~P8.7)

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 GPIOx->DR[0x3FC] = PortVal;

207 }

208

209 /*******************************************************************************

210 * Function Name : LCD_CtrlLinesConfig

211 * Description : Configure control lines E2, E1, RW, DI (P9.4~P9.7) in

212 * Output Push-Pull mode.

213 * Input : None

214 * Output : None

215 * Return : None

216 *******************************************************************************/

217 void LCD_CtrlLinesConfig(void)

218 {

219 /* Configure E2, E1, RW, DI lines (P9.4~P9.7) in Output Push-Pull mode */

220 GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4 | GPIO_Pin_5 | GPIO_Pin_6 | GPIO_Pin_7;

221 GPIO_InitStructure.GPIO_Direction = GPIO_PinOutput ;

222 GPIO_InitStructure.GPIO_Type = GPIO_Type_PushPull ;

223 GPIO_Init(GPIO9, &GPIO_InitStructure);

224 }

225

226 /*******************************************************************************

227 * Function Name : LCD_CtrlLinesWrite

228 * Description : Set or reset control lines E2, E1, RW, DI (P9.4~P9.7).

229 * Input : - GPIOx: where x can be 0,1 or 2 to select the GPIO peripheral.

230 * - CtrlPins: the Control line. This parameter can be:

231 * - CtrlPin_E2: Enabe clock signal for Slave

232 * - CtrlPin_E1: Enabe clock signal for Master

233 * - CtrlPin_RW: Read/Write control line

234 * - CtrlPin_DI:

235 * Output : None

236 * Return : None

237 *******************************************************************************/

238 void LCD_CtrlLinesWrite(GPIO_TypeDef* GPIOx, u32 CtrlPins, BitAction BitVal)

239 {

240 /* Set or Reset the control line */

241 if(BitVal == Bit_SET)

242 {

243 GPIOx->DR[CtrlPins <<2] = CtrlPins;

244 }

245 else

246 {

247 GPIOx->DR[CtrlPins <<2] = 0x00;

248 }

249 }

250

251 /*******************************************************************************

252 * Function Name : LCD_CheckMasterStatus

253 * Description : Check whether master LCD is busy or not

254 * Input : None

255 * Output : None

256 * Return : None

257 *******************************************************************************/

258 void LCD_CheckMasterStatus(void)

259 {

260 u8 MasterStatus = 0;

261

262 /* Configure Data lines as Input */

263 LCD_DataLinesConfig(Input);

264 /* Start the master read sequence */

265 LCD_CtrlLinesWrite(GPIO9, CtrlPin_E1, Bit_RESET); /* E1 = 0 */

266 LCD_CtrlLinesWrite(GPIO9, CtrlPin_RW, Bit_SET); /* RW = 1 */

267 LCD_CtrlLinesWrite(GPIO9, CtrlPin_DI, Bit_RESET); /* DI = 0 */

268 LCD_CtrlLinesWrite(GPIO9, CtrlPin_E1, Bit_SET); /* E1 = 1 */

269 MasterStatus = GPIO_Read(GPIO8);

270 LCD_CtrlLinesWrite(GPIO9, CtrlPin_E1, Bit_RESET); /* E1 = 0 */

271

272 /* Wait until BF is cleared */

273 while ((MasterStatus & 0x80))

274 {

275 vTaskDelay( 1 );

276 LCD_CtrlLinesWrite(GPIO9, CtrlPin_E1, Bit_SET); /* E1 = 1 */

277 MasterStatus = GPIO_Read(GPIO8);

278 LCD_CtrlLinesWrite(GPIO9, CtrlPin_E1, Bit_RESET); /* E1 = 0 */

279 }

280 }

281

282 /*******************************************************************************

283 * Function Name : LCD_CheckSlaveStatus

284 * Description : Check whether slave LCD is busy or not

285 * Input : None

286 * Output : None

287 * Return : None

288 *******************************************************************************/

289 void LCD_CheckSlaveStatus(void)

290 {

291 u8 SlaveStatus = 0;

292

293 /* Configure Data lines as Input */

294 LCD_DataLinesConfig(Input);

295 /* Start the slave read sequence */

296 LCD_CtrlLinesWrite(GPIO9, CtrlPin_E2, Bit_RESET); /* E2 = 0 */

297 LCD_CtrlLinesWrite(GPIO9, CtrlPin_RW, Bit_SET); /* RW = 1 */

298 LCD_CtrlLinesWrite(GPIO9, CtrlPin_DI, Bit_RESET); /* DI = 0 */

299 LCD_CtrlLinesWrite(GPIO9, CtrlPin_E2, Bit_SET); /* E2 = 1 */

300 SlaveStatus = GPIO_Read(GPIO8);

301 LCD_CtrlLinesWrite(GPIO9, CtrlPin_E2, Bit_RESET); /* E2 = 0 */

302

303 /* Wait until BF is cleared */

304 while ((SlaveStatus & 0x80))

305 {

306 vTaskDelay( 1 );

307 LCD_CtrlLinesWrite(GPIO9, CtrlPin_E2, Bit_SET); /* E2 = 1 */

308 SlaveStatus = GPIO_Read(GPIO8);

309 LCD_CtrlLinesWrite(GPIO9, CtrlPin_E2, Bit_RESET); /* E2 = 0 */

310 }

311 }

312

313 /*******************************************************************************

314 * Function Name : LCD_SendMasterCmd

315 * Description : Send one byte command to master LCD.

316 * Input : - Cmd: the user expected command to send to master LCD

317 * Output : None

318 * Return : None

319 *******************************************************************************/

320 void LCD_SendMasterCmd(u8 Cmd)

321 {

322 /* Check the master status */

323 LCD_CheckMasterStatus();

324 /* Configure Data lines as Output */

325 LCD_DataLinesConfig(Output);

326 /* Start the master send command sequence */

327 LCD_CtrlLinesWrite(GPIO9, CtrlPin_E1, Bit_RESET); /* E1 = 0 */

328 LCD_CtrlLinesWrite(GPIO9, CtrlPin_RW, Bit_RESET); /* RW = 0 */

329 LCD_CtrlLinesWrite(GPIO9, CtrlPin_DI, Bit_RESET); /* DI = 0 */

330 LCD_CtrlLinesWrite(GPIO9, CtrlPin_E1, Bit_SET); /* E1 = 1 */

331 /* Write master command */

332 LCD_DataLinesWrite(GPIO8, (u32)Cmd);

333 LCD_CtrlLinesWrite(GPIO9, CtrlPin_E1, Bit_RESET); /* E1 = 0 */

334 }

335

336 /*******************************************************************************

337 * Function Name : LCD_SendSlaveCmd

338 * Description : Send one byte command to slave LCD

339 * Input : - Cmd: the user expected command to send to slave LCD.

340 * Output : None

341 * Return : None

342 *******************************************************************************/

343 void LCD_SendSlaveCmd(u8 Cmd)

344 {

345 /* Check the slave status */

346 LCD_CheckSlaveStatus();

347 /* Configure Data lines as Output */

348 LCD_DataLinesConfig(Output);

349 /* Start the slave send command sequence */

350 LCD_CtrlLinesWrite(GPIO9, CtrlPin_E2, Bit_RESET); /* E2 = 0 */

351 LCD_CtrlLinesWrite(GPIO9, CtrlPin_RW, Bit_RESET); /* RW = 0 */

352 LCD_CtrlLinesWrite(GPIO9, CtrlPin_DI, Bit_RESET); /* DI = 0 */

353 LCD_CtrlLinesWrite(GPIO9, CtrlPin_E2, Bit_SET); /* E2 = 1 */

354 /* Write slave command */

355 LCD_DataLinesWrite(GPIO8, (u32)Cmd);

356 LCD_CtrlLinesWrite(GPIO9, CtrlPin_E2, Bit_RESET); /* E2 = 0 */

357 }

358

359 /*******************************************************************************

360 * Function Name : LCD_SendMasterData

361 * Description : Display one byte data to master LCD.

362 * Input : - Data: the user expected data to display on master LCD.

363 * Output : None

364 * Return : None

365 *******************************************************************************/

366 void LCD_SendMasterData(u8 Data)

367 {

368 /* Check the master status */

369 LCD_CheckMasterStatus();

370 /* Configure Data lines as Output */

371 LCD_DataLinesConfig(Output);

372 /* Start the master send data sequence */

373 LCD_CtrlLinesWrite(GPIO9, CtrlPin_E1, Bit_RESET); /* E1 = 0 */

374 LCD_CtrlLinesWrite(GPIO9, CtrlPin_RW, Bit_RESET); /* RW = 0 */

375 LCD_CtrlLinesWrite(GPIO9, CtrlPin_DI, Bit_SET); /* DI = 1 */

376 LCD_CtrlLinesWrite(GPIO9, CtrlPin_E1, Bit_SET); /* E1 = 1 */

377 /* Write data to the master */

378 LCD_DataLinesWrite(GPIO8, (u32)Data);

379 LCD_CtrlLinesWrite(GPIO9, CtrlPin_E1, Bit_RESET); /* E1 = 0 */

380 }

381

382 /*******************************************************************************

383 * Function Name : LCD_ReadMasterData

384 * Description : Read master byte data displayed on master LCD.

385 * Input : None

386 * Output : None

387 * Return : None

388 *******************************************************************************/

389 u32 LCD_ReadMasterData(void)

390 {

391 u32 MasterData = 0;

392

393 /* Check the master status */

394 LCD_CheckMasterStatus();

395 /* Configure Data lines as Input */

396 LCD_DataLinesConfig(Input);

397 /* Start the master read data sequence */

398 LCD_CtrlLinesWrite(GPIO9, CtrlPin_E1, Bit_RESET); /* E1 = 0 */

399 LCD_CtrlLinesWrite(GPIO9, CtrlPin_RW, Bit_SET); /* RW = 1 */

400 LCD_CtrlLinesWrite(GPIO9, CtrlPin_DI, Bit_SET); /* DI = 1 */

401 LCD_CtrlLinesWrite(GPIO9, CtrlPin_E1, Bit_SET); /* E1 = 1 */

402 /* Read data from the master */

403 MasterData = (GPIO_Read(GPIO8));

404 LCD_CtrlLinesWrite(GPIO9, CtrlPin_E1, Bit_RESET); /* E1 = 0 */

405 /* Read the master returned data */

406 return MasterData;

407 }

408

409 /*******************************************************************************

410 * Function Name : LCD_SendSlaveData

411 * Description : Display one byte data to slave LCD.

412 * Input : - Data: the user expected data to display on slave LCD.

413 * Output : None

414 * Return : None

415 *******************************************************************************/

416 void LCD_SendSlaveData(u8 Data)

417 {

418 /* Check the slave status */

419 LCD_CheckSlaveStatus();

420 /* Configure Data lines as Output */

421 LCD_DataLinesConfig(Output);

422 /* Start the slave send data sequence */

423 LCD_CtrlLinesWrite(GPIO9, CtrlPin_E2, Bit_RESET); /* E2 = 0 */

424 LCD_CtrlLinesWrite(GPIO9, CtrlPin_RW, Bit_RESET); /* RW = 0 */

425 LCD_CtrlLinesWrite(GPIO9, CtrlPin_DI, Bit_SET); /* DI = 1 */

426 LCD_CtrlLinesWrite(GPIO9, CtrlPin_E2, Bit_SET); /* E2 = 1 */

427 /* Write data to the slave */

428 LCD_DataLinesWrite(GPIO8, (u32)Data);

429 LCD_CtrlLinesWrite(GPIO9, CtrlPin_E2, Bit_RESET); /* E2 = 0 */

430 }

431

432 /*******************************************************************************

433 * Function Name : LCD_ReadSlaveData

434 * Description : Read slave byte data displayed on slave LCD.

435 * Input : None

436 * Output : None

437 * Return : None

438 *******************************************************************************/

439 u32 LCD_ReadSlaveData(void)

440 {

441 u32 SlaveData = 0;

442

443 /* Check the slave status */

444 LCD_CheckSlaveStatus();

445 /* Configure Data lines as Input */

446 LCD_DataLinesConfig(Input);

447 /* Start the slave read data sequence */

448 LCD_CtrlLinesWrite(GPIO9, CtrlPin_E2, Bit_RESET); /* E2 = 0 */

449 LCD_CtrlLinesWrite(GPIO9, CtrlPin_RW, Bit_SET); /* RW = 1 */

450 LCD_CtrlLinesWrite(GPIO9, CtrlPin_DI, Bit_SET); /* DI = 1 */

451 LCD_CtrlLinesWrite(GPIO9, CtrlPin_E2, Bit_SET); /* E2 = 1 */

452 /* Read data from the slave */

453 SlaveData = GPIO_Read(GPIO8);

454 LCD_CtrlLinesWrite(GPIO9, CtrlPin_E2, Bit_RESET); /* E2 = 0 */

455 /* Read the slave returned data */

456 return SlaveData;

457 }

458

459 /*******************************************************************************

460 * Function Name : LCD_Init

461 * Description : Initialize master and slave LCD.

462 * Input : None

463 * Output : None

464 * Return : None

465 *******************************************************************************/

466 void LCD_Init(void)

467 {

468 /* Enable GPIO Clock */

469

470

471 /* Configure control lines signals as output mode */

472 LCD_CtrlLinesConfig();

473

474 /* Master LCD Init */

475 LCD_SendMasterCmd(SOFTWARE_RESET);

476 LCD_SendMasterCmd(DISPLAY_OFF);

477 LCD_SendMasterCmd(DYNAMIC_DRIVE);

478 LCD_SendMasterCmd(DUTY_CYCLE);

479 LCD_SendMasterCmd(CLOCKWISE_OUTPUT);

480 LCD_SendMasterCmd(READ_MODIFY_WRITE_OFF);

481 LCD_SendMasterCmd(START_COLUMN); /* Set master column address to 0 */

482 LCD_SendMasterCmd(START_LINE); /* Set master display start line to 0 */

483 LCD_SendMasterCmd(DISPLAY_ON );

484

485 /* Slave LCD Init */

486 LCD_SendSlaveCmd(SOFTWARE_RESET);

487 LCD_SendSlaveCmd(DISPLAY_OFF);

488 LCD_SendSlaveCmd(DYNAMIC_DRIVE);

489 LCD_SendSlaveCmd(DUTY_CYCLE);

490 LCD_SendSlaveCmd(CLOCKWISE_OUTPUT);

491 LCD_SendSlaveCmd(READ_MODIFY_WRITE_OFF);

492 LCD_SendSlaveCmd(START_COLUMN ); /* Set slave column address to 0 */

493 LCD_SendSlaveCmd(START_LINE); /* Set slave display start line to 0 */

494 LCD_SendSlaveCmd(DISPLAY_ON);

495

496 /* Clear LCD */

497 LCD_Clear();

498 /* Set current Page to 0 for Master and Slave LCDs */

499 LCD_SetSlavePage(0);

500 LCD_SetMasterPage(0);

501 }

502

503 /*******************************************************************************

504 * Function Name : LCD_SetSlavePage

505 * Description : Set the display page of slave LCD, the page range is 0 to 3,

506 * make sure the input will not exceed this range ,otherwise it

507 * will reach a undecided result.

508 * Input : - Page: specifies the expected display page of slave LCD

509 * Output : None

510 * Return : None

511 *******************************************************************************/

512 void LCD_SetSlavePage(u8 Page)

513 {

514 static u8 ucLastPage = 255;

515

516 /* Set Slave page */

517 if( Page != ucLastPage )

518 {

519 LCD_SendSlaveCmd(0xB8|Page);

520 ucLastPage = Page;

521 }

522 }

523

524 /*******************************************************************************

525 * Function Name : LCD_SetMasterPage

526 * Description : Set the display page of master LCD, the page range is 0 to 3,

527 * make sure the input will not exceed this range ,otherwise it

528 * will reach a undecided result.

529 * Input : - Page: specifies the expected display page of master LCD

530 * Output : None

531 * Return : None

532 *******************************************************************************/

533 void LCD_SetMasterPage(u8 Page)

534 {

535 static u8 ulLastPage = 255;

536

537 /* Set Master page */

538 if( Page != ulLastPage )

539 {

540 LCD_SendMasterCmd(0xB8|Page);

541 ulLastPage = Page;

542 }

543 }

544

545 /*******************************************************************************

546 * Function Name : SetAddress

547 * Description : Set the display column of slave LCD. Column range is 0 to 61.

548 * Input : - Address: specifies the expected display column of slave LCD

549 * Output : None

550 * Return : None

551 *******************************************************************************/

552 void LCD_SetSlaveColumn(u8 Address)

553 {

554 /* Set Slave column address */

555 LCD_SendSlaveCmd(Address&0x7F);

556 }

557

558 /*******************************************************************************

559 * Function Name : LCD_SetMasterColumn

560 * Description : Set the display column of master LCD. Column range is 0 to 61.

561 * Input : - Address: specifies the expected display column of slave LCD

562 * Output : None

563 * Return : None

564 *******************************************************************************/

565 void LCD_SetMasterColumn(u8 Address)

566 {

567 /* Set Master column address */

568 LCD_SendMasterCmd(Address&0x7F);

569 }

570

571 /*******************************************************************************

572 * Function Name : LCD_SetTextColor

573 * Description : Set the text color for LCD.

574 * Input : - TextColor: BlackText: character on black, bottom on white.

575 * WhiteText: character on white, bottom on black.

576 * Output : None

577 * Return : None

578 *******************************************************************************/

579 void LCD_SetTextColor(TextColorMode_TypeDef TextColor)

580 {

581 if(TextColor)

582 {

583 /* Set White Text color */

584 TextMode=WhiteText;

585 }

586 else

587 {

588 /* Set Black Text color */

589 TextMode=BlackText;

590 }

591 }

592

593 /*******************************************************************************

594 * Function Name : LCD_Clear

595 * Description : Clear the Master and Slave LCDs display.

596 * Input : None

597 * Output : None

598 * Return : None

599 *******************************************************************************/

600 void LCD_Clear(void)

601 {

602 u8 Page = 0, Column = 0;

603

604 /* Clear master and slave LCDs page by page */

605 for (Page=0; Page<4; Page++)

606 {

607 /* Set master and slave page by page */

608 LCD_SetMasterPage(Page);

609 LCD_SetSlavePage(Page);

610 /* Set master and slave column address */

611 LCD_SetMasterColumn(0);

612 LCD_SetSlaveColumn(0);

613 /* Send empty data to master and slave column address on the selected page */

614 for (Column=0; Column<61; Column++)

615 {

616 LCD_SendSlaveData(0);

617 LCD_SendMasterData(0);

618 }

619 }

620 }

621

622 /*******************************************************************************

623 * Function Name : LCD_ClearLine

624 * Description : Clear the selected line of the LCD.

625 * Input : - Line: the Line to clear.

626 * - Line1 (Page0&1): clear the first line

627 * - Line2 (Page2&3): clear the second line

628 * Output : None

629 * Return : None

630 *******************************************************************************/

631 void LCD_ClearLine(u8 Line)

632 {

633 u8 Page = 0, Column = 0;

634

635 /* Clear the slected master and slave line */

636 for (Page=Line; Page<Line+2; Page++)

637 {

638 /* Set master and slave page by page */

639 LCD_SetMasterPage(Page);

640 LCD_SetSlavePage(Page);

641 /* Set master and slave column address */

642 LCD_SetMasterColumn(0);

643 LCD_SetSlaveColumn(0);

644 /* Send empty data to master and slave column address on the selected page */

645 for (Column=0; Column<61; Column++)

646 {

647 LCD_SendSlaveData(0);

648 LCD_SendMasterData(0);

649 }

650 }

651 }

652

653 /*******************************************************************************

654 * Function Name : LCD_ClearMaster

655 * Description : Clear the master LCD.

656 * Input : None

657 * Output : None

658 * Return : None

659 *******************************************************************************/

660 void LCD_ClearMaster(void)

661 {

662 u8 Page = 0, Column = 0;

663

664 /* Clear all master LCD pages */

665 for (Page=0; Page<4; Page++)

666 {

667 /* Set master page by page */

668 LCD_SetMasterPage(Page);

669 /* Set master column address */

670 LCD_SetMasterColumn(0);

671 /* Send empty data to master column address on the selected page */

672 for (Column=0; Column<61; Column++)

673 {

674 LCD_SendMasterData(0);

675 }

676 }

677 }

678

679 /*******************************************************************************

680 * Function Name : LCD_ClearSlave

681 * Description : Clear the slave LCD.

682 * Input : None

683 * Output : None

684 * Return : None

685 *******************************************************************************/

686 void LCD_ClearSlave()

687 {

688 u8 Page = 0, Column = 0;

689

690 /* Clear all slave LCD pages */

691 for (Page=0; Page<4; Page++)

692 {

693 /* Set slave page by page */

694 LCD_SetSlavePage(Page);

695 /* Set slave column address */

696 LCD_SetSlaveColumn(0);

697 /* Send empty data to slave column address on the selected page */

698 for (Column=0; Column<61; Column++)

699 {

700 LCD_SendSlaveData(0);

701 }

702 }

703 }

704

705 /*******************************************************************************

706 * Function Name : LCD_DrawChar

707 * Description : Draw a character in LCD.

708 * Note:

709 * the LCD can only display two line character,so page 0 and 1

710 * is to display the first line, page2 and page 3 is to display

711 * the second line.

712 * Input : - Line: the Line where to display the character shape .

713 * - Line1 (Page0&1): display character on the first line

714 * - Line2 (Page2&3): display character on the second line

715 * - Column: start column address.

716 * - Width: the number of column (dots) of a character width.

717 * - Bmp: the pointer of the dot matrix data.

718 * Output : None

719 * Return : None

720 *******************************************************************************/

721 void LCD_DrawChar(u8 Line, u8 Column, u8 Width, u8 *Bmp)

722 {

723 u8 X = 0, ActualColumn = 0, Window = 0, i = 0;

724

725 /* Draw the character column by column: width times */

726 for(X = Column; X<(Column+Width); X++)

727 {

728 if(X > 121)

729 {

730 /* Return if column exceeded 121 */

731 return;

732 }

733 if (X > 60)

734 {

735 /* To be displayed on slave LCD (Window = 1) */

736 Window = 1;

737 /* Get the Slave relative start column */

738 // ActualColumn = X%61;

739 ActualColumn = X - 61;

740 }

741 else

742 {

743 /* To be displayed on master LCD (Window = 0) */

744 ActualColumn = X;

745 }

746

747 /* Switch window, display the character upper part */

748 if (Window)

749 {

750 /* Display it on slave LCD */

751 LCD_SetSlavePage(Line);

752 LCD_SetSlaveColumn(ActualColumn);

753 LCD_SendSlaveData(Bmp[i]);

754 }

755 else

756 {

757 /* Display it on master LCD */

758 LCD_SetMasterPage(Line);

759 LCD_SetMasterColumn(ActualColumn);

760 LCD_SendMasterData(Bmp[i]);

761 }

762 /* Switch window, diplay the character lower part */

763 if (Window)

764 {

765 /* Display it on slave LCD */

766 LCD_SetSlavePage(Line+1);

767 LCD_SetSlaveColumn(ActualColumn);

768 LCD_SendSlaveData(Bmp[i+1]);

769 }

770 else

771 {

772 /* Display it on master LCD */

773 LCD_SetMasterPage(Line+1);

774 LCD_SetMasterColumn(ActualColumn);

775 LCD_SendMasterData(Bmp[i+1]);

776 }

777 /* Increment by 2 the character table index */

778 i+=2;

779 }

780 }

781

782 /*******************************************************************************

783 * Function Name : LCD_DisplayChar

784 * Description : Display one character (7dots large, 16dots high).

785 * Note:

786 * the LCD can only display two line character,so page 0 and 1

787 * is to display the first line, page2 and page 3 is to display

788 * the second line.

789 * Input : - Line: the Line where to display the character.

790 * - Line1 (Page0&1): display character on the first line

791 * - Line2 (Page2&3): display character on the second line

792 * - Column: start column address.

793 * - Ascii: character ascii code.

794 * - CharMode: BlackText: character on black, bottom on white.

795 * WhiteText: character on white, bottom on black.

796 * Output : None

797 * Return : None

798 *******************************************************************************/

799 void LCD_DisplayChar(u8 Line, u8 Column, u8 Ascii, TextColorMode_TypeDef CharMode)

800 {

801 u8 DotBuffer[14], i = 0;

802

803 /* Display the character lower and upper 8bit parts (2*7columns) */

804 for (i=0;i<14;i++)

805 {

806 /* Character displayed as white Text on black buttom */

807 if(CharMode)

808 {

809 if( i & 0x01 )

810 {

811 DotBuffer[i] = ~AsciiDotsTable[Ascii*14+i-1];

812 }

813 else

814 {

815 DotBuffer[i] = ~AsciiDotsTable[Ascii*14+i+1];

816 }

817 }

818 /* Character displayed as black Text on white buttom */

819 else

820 {

821 if( ( u8 ) i & 0x01 )

822 {

823 DotBuffer[i] = AsciiDotsTable[Ascii*14+i-1];

824 }

825 else

826 {

827 DotBuffer[i] = AsciiDotsTable[Ascii*14+i+1];

828 }

829 }

830 }

831 /* Display the asc code after conversion */

832 LCD_DrawChar(Line, Column, 7, DotBuffer);

833 }

834

835 /*******************************************************************************

836 * Function Name : LCD_HexToAsciiLow

837 * Description : This function is used to convert the low nibble of an

838 * unsigned byte (0-F hex) to ASCII.

839 * Input : - byte: byte to convert to ASCII.

840 * Output : None

841 * Return : ASCII value result of the conversion.

842 *******************************************************************************/

843 char LCD_HexToAsciiLow(u8 byte)

844 {

845 /* Keep lower nibble only */

846 byte = byte & 0x0F;

847 /* If the ascii is a number */

848 if (byte <= 0x09)

849 {

850 /* Add 0x30 to its ascii */

851 return(byte + 0x30);

852 }

853 else

854 {

855 /* Add 0x37 to its ascii */

856 return (byte + 0x37);

857 }

858 }

859

860 /*******************************************************************************

861 * Function Name : LCD_HexToAsciiHigh

862 * Description : This function is used to convert the high nibble of an

863 * unsigned byte (0-F hex) to ASCII.

864 * Input : - byte: byte to convert to ASCII.

865 * Output : None

866 * Return : ASCII value result of the conversion.

867 *******************************************************************************/

868 char LCD_HexToAsciiHigh(u8 byte)

869 {

870 /* Keep upper nibble only */

871 byte = byte & 0xF0;

872 byte = byte >> 4;

873 /* If the ascii is a number */

874 if (byte <= 0x09)

875 {

876 /* Add 0x30 to display its ascii */

877 return(byte + 0x30);

878 }

879 else

880 {

881 /* Add 0x37 to display its ascii */

882 return (byte + 0x37);

883 }

884 }

885

886 /*******************************************************************************

887 * Function Name : LCD_DisplayString

888 * Description : This function is used to display a 17char max string of

889 * characters on the LCD display on the selected line.

890 * Note:

891 * this function is the user interface to use the LCD driver.

892 * Input : - *ptr: pointer to string to display on LCD.

893 * - Line: the Line where to display the character.

894 * - Line1 (Page0&1): display character on the first line

895 * - Line2 (Page2&3): display character on the second line

896 * Output : None

897 * Return : None

898 *******************************************************************************/

899 void LCD_DisplayString(u8 Line, u8 *ptr, TextColorMode_TypeDef CharMode)

900 {

901 u8 RefColumn = 0, i = 0;

902

903 /* Send the string character by character on lCD */

904 while ((*ptr!=0)&(i<17))

905 {

906 vTaskDelay( 1 );

907

908 /* Display one character on LCD */

909 LCD_DisplayChar(Line, RefColumn, *ptr, CharMode);

910

911 /* Increment the column position by 7 */

912 RefColumn+=7;

913 /* Point on the next character */

914 ptr++;

915 /* Increment the character counter */

916 i++;

917 /* If we reach the maximum Line character */

918 if(i==17)

919 {

920 LCD_DisplayChar(Line, RefColumn-1, 0x1f, CharMode); /* Add missed columns */

921 }

922 }

923 }

924

925 /*******************************************************************************

926 * Function Name : LCD_Printf

927 * Description : This function is used to display a string of characters

928 * on the LCD display.

929 * Note:

930 * this function is the user interface to use the LCD driver.

931 * Input : - *ptr: pointer to string to display on LCD.

932 * Output : None

933 * Return : None

934 *******************************************************************************/

935 void LCD_Printf(u8 *ptr, ...)

936 {

937 u8 RefColumn = 0, RefPage = 0, i = 0, c1 = 0;

938 u16 var = 0, c2 = 0, c3 = 0, c4 = 0, c5 = 0;

939 u32 WordVar = 0;

940

941 /* Store pointer on LCD_Printf second parameter (String) */

942 u8 *var_ptr=(u8 *)(&ptr+1);

943

944 /* Send String */

945 while (*ptr != 0)

946 {

947 c1 = *ptr;

948 /* Limited to AsciiDotsTable code table */

949 if(c1 <= 128)

950 {

951 /* Carriage return */

952 if ( *ptr == '\r')

953 {

954 ptr++;

955 RefColumn = 0;

956 }

957 /* Jump to Line2 */

958 else if( *ptr == '\n')

959 {

960 /* Point on the string to display */

961 ptr++;

962 /* Clear Line2 */

963 LCD_ClearLine(Line2);

964 /* Point on first Line2 column */

965 RefColumn = 0;

966 /* Increment RefPage by 2 */

967 RefPage+=2;

968 }

969 /* Display value on the passed format */

970 else if( *ptr == '%')

971 {

972 ptr++;

973 /* Display decimal value */

974 if (*ptr == 'd')

975 {

976 ptr++;

977 /* Get the word value to display */

978 WordVar = ((*var_ptr)|(*(var_ptr+1)<<8)|(*(var_ptr+2)<<16));

979 c1=WordVar/10000;

980 c2=(WordVar%10000)/1000;

981 c3=(WordVar%1000)/100;

982 c4=(WordVar%100)/10;

983 c5=(WordVar%10);

984 /* Display the ten miles digit */

985 if (c1!=0)

986 {

987 LCD_DisplayChar(RefPage, RefColumn, c1+0x30, TextMode);

988 RefColumn+=7;

989 }

990 /* Display the miles digit */

991 if (!((c1==0)&(c2==0)))

992 {

993 LCD_DisplayChar(RefPage, RefColumn, c2+0x30, TextMode);

994 RefColumn+=7;

995 }

996 /* Display the hundred digit */

997 if (!((c1==0)&(c2==0)&(c3==0)))

998 {

999 LCD_DisplayChar(RefPage, RefColumn, c3+0x30, TextMode);

1000 RefColumn+=7;

1001 }

1002 /* Display the tens digit */

1003 if (!((c1==0)&(c2==0)&(c3==0)&(c4==0)))

1004 {

1005 LCD_DisplayChar(RefPage, RefColumn, c4+0x30, TextMode);

1006 RefColumn+=7;

1007 }

1008 /* Display the rest */

1009 LCD_DisplayChar(RefPage, RefColumn, c5+0x30, TextMode);

1010 RefColumn+=7;

1011 }

1012 /* Display 16bits Hex value */

1013 else if (*ptr == 'x')

1014 {

1015 ptr++;

1016 /* Display 8bits MSB */

1017 var_ptr = var_ptr +1;

1018 var = *var_ptr;

1019 c1 = LCD_HexToAsciiHigh(var);

1020 LCD_DisplayChar(RefPage, RefColumn, c1, TextMode);

1021 RefColumn+=7;

1022 c1 = LCD_HexToAsciiLow(var);

1023 LCD_DisplayChar(RefPage, RefColumn, c1, TextMode);

1024 RefColumn+=7;

1025 /* Display 8bits LSB */

1026 var_ptr = var_ptr -1;

1027 var = *var_ptr;

1028 var_ptr = var_ptr +4;

1029 c1 = LCD_HexToAsciiHigh(var);

1030 LCD_DisplayChar(RefPage, RefColumn, c1, TextMode);

1031 RefColumn+=7;

1032 c1 = LCD_HexToAsciiLow(var);

1033 LCD_DisplayChar(RefPage, RefColumn, c1, TextMode);

1034 RefColumn+=7;

1035 }

1036 /* Display 32bits Hex value */

1037 else if (*ptr == 'w')

1038 {

1039 ptr++;

1040 /* Display 16bits MSB */

1041 var_ptr = var_ptr +3;

1042 var = *var_ptr;

1043 c1 = LCD_HexToAsciiHigh(var);

1044 LCD_DisplayChar(RefPage, RefColumn, c1, TextMode);

1045 RefColumn+=7;

1046 c1 = LCD_HexToAsciiLow(var);

1047 LCD_DisplayChar(RefPage, RefColumn, c1, TextMode);

1048 RefColumn+=7;

1049 var_ptr = var_ptr -1;

1050 var = *var_ptr;

1051 c1 = LCD_HexToAsciiHigh(var);

1052 LCD_DisplayChar(RefPage, RefColumn, c1, TextMode);

1053 RefColumn+=7;

1054 c1 = LCD_HexToAsciiLow(var);

1055 LCD_DisplayChar(RefPage, RefColumn, c1, TextMode);

1056 RefColumn+=7;

1057 /* Display 16bits LSB */

1058 var_ptr = var_ptr -1;

1059 var = *var_ptr;

1060 var_ptr = var_ptr +4;

1061 c1 = LCD_HexToAsciiHigh(var);

1062 LCD_DisplayChar(RefPage, RefColumn, c1, TextMode);

1063 RefColumn+=7;

1064 c1 = LCD_HexToAsciiLow(var);

1065 LCD_DisplayChar(RefPage, RefColumn, c1, TextMode);

1066 RefColumn+=7;

1067 var_ptr = var_ptr -5;

1068 var = *var_ptr;

1069 var_ptr = var_ptr +4;

1070 c1 = LCD_HexToAsciiHigh(var);

1071 LCD_DisplayChar(RefPage, RefColumn, c1, TextMode);

1072 RefColumn+=7;

1073 c1 = LCD_HexToAsciiLow(var);

1074 LCD_DisplayChar(RefPage, RefColumn, c1, TextMode);

1075 RefColumn+=7;

1076 }

1077 else

1078 {

1079 /* Display '%' character which is followed by (d, x or w) */

1080 ptr--;

1081 c1 = *ptr;

1082 LCD_DisplayChar(RefPage, RefColumn, c1, TextMode);

1083 RefColumn+=7;

1084 ptr++;

1085 i++;

1086 if(i==17)

1087 {

1088 /* Add missed columns */

1089 LCD_DisplayChar(RefPage, RefColumn-1, 0x1f, TextMode);

1090 RefColumn = 0;

1091 RefPage+=2;

1092 }

1093 }

1094 }

1095 else

1096 {

1097 /* Display characters different from (\r, \n, %) */

1098 LCD_DisplayChar(RefPage, RefColumn, c1, TextMode);

1099 RefColumn+=7;

1100 ptr++;

1101 i++;

1102 if(i==17)

1103 {

1104 /* Add missed columns */

1105 LCD_DisplayChar(RefPage, RefColumn-1, 0x1f, TextMode);

1106 LCD_ClearLine(Line2);

1107 RefColumn = 0;

1108 RefPage+=2;

1109 }

1110 }

1111 }

1112 }

1113 /* Display spaces if string doesn't reach the max LCD characters size */

1114 while(RefColumn<119)

1115 {

1116 /* Display Spaces */

1117 LCD_DisplayChar(RefPage, RefColumn, 0x20, TextMode);

1118 RefColumn+=7;

1119 /* Add missed columns */

1120 LCD_DisplayChar(RefPage, RefColumn, 0x1f, TextMode);

1121 }

1122 }

1123

1124 /*******************************************************************************

1125 * Function Name : LCD_DrawMasterGraphic

1126 * Description : Draw a Graphic image on master LCD.

1127 * Input : - Bmp: the pointer of the dot matrix data.

1128 * Output : None

1129 * Return : None.

1130 *******************************************************************************/

1131 void LCD_DrawMasterGraphic(u8 *Bmp)

1132 {

1133 u8 j = 0, k = 0, ActPage = 0;

1134

1135 /* Draw graphic on master: 61 Column *4 Pages */

1136 while(j<244)

1137 {

1138 /* Draw on master page by page */

1139 LCD_SetMasterPage(ActPage);

1140 for(k=0; k<61; k++)

1141 {

1142 LCD_SetMasterColumn(k);

1143 LCD_SendMasterData(*Bmp++);

1144 j++;

1145 }

1146 ActPage++;

1147 }

1148 }

1149

1150 /*******************************************************************************

1151 * Function Name : LCD_DrawSlaveGraphic

1152 * Description : Draw a Graphic image on slave LCD.

1153 * Input : - Bmp: the pointer of the dot matrix data.

1154 * Output : None

1155 * Return : None.

1156 *******************************************************************************/

1157 void LCD_DrawSlaveGraphic(u8 *Bmp)

1158 {

1159 u8 j = 0, k = 0, ActPage = 0;

1160

1161 /* Draw graphic on slave: 61 Column *4 Pages */

1162 while(j<244)

1163 {

1164 /* Draw on slave page by page */

1165 LCD_SetSlavePage(ActPage);

1166 for(k=0; k<61; k++)

1167 {

1168 LCD_SetSlaveColumn(k);

1169 LCD_SendSlaveData(*Bmp++);

1170 j++;

1171 }

1172 ActPage++;

1173 }

1174 }

1175

1176 /*******************************************************************************

1177 * Function Name : LCD_DrawGraphic

1178 * Description : Draw a Graphic image on LCD.

1179 * Input : - Bmp: the pointer of the dot matrix data.

1180 * Output : None

1181 * Return : None.

1182 *******************************************************************************/

1183 void LCD_DrawGraphic(u8 *Bmp)

1184 {

1185 u8 Pos = 0, ActPage = 0;

1186 u16 j = 0, k = 0;

1187

1188 /* Draw graphic on LCD: 122 Column *4 Pages */

1189 while(j<488)

1190 {

1191 if(!Pos)

1192 {

1193 /* Draw on master page by page */

1194 LCD_SetMasterPage(ActPage);

1195 for(k=0; k<61; k++)

1196 {

1197 LCD_SetMasterColumn(k);

1198 LCD_SendMasterData(*Bmp++);

1199 j++;

1200 }

1201 Pos=1;

1202 }

1203 else

1204 {

1205 /* Draw on slave page by page */

1206 LCD_SetSlavePage(ActPage);

1207 for(k=0; k<61; k++)

1208 {

1209 LCD_SetSlaveColumn(k);

1210 LCD_SendSlaveData(*Bmp++);

1211 j++;

1212 }

1213 ActPage++;

1214 Pos=0;

1215 }

1216 }

1217 }

1218

1219 /*******************************************************************************

1220 * Function Name : LCD_ScrollGraphic

1221 * Description : Scroll a Graphic image on LCD.

1222 * Input : - Bmp: the pointer of the dot matrix data.

1223 * - nCount: specifies the delay time length.

1224 * Output : None

1225 * Return : None.

1226 *******************************************************************************/

1227 void LCD_ScrollGraphic(u8 *Bmp, u32 nCount)

1228 {

1229 u8 Pos = 0, ActPage = 0;

1230 u16 j = 0, k = 0;

1231 u32 Counter = 0;

1232

1233 /* Draw graphic on LCD: 122 Column *4 Pages */

1234 while(j<488)

1235 {

1236 if(!Pos)

1237 {

1238 /* Draw on master page by page */

1239 LCD_SetMasterPage(ActPage);

1240 for(k=0; k<61; k++)

1241 {

1242 LCD_SetMasterColumn(k);

1243 LCD_SendMasterData(*Bmp++);

1244 Counter = nCount;

1245 /* Set a delay */

1246 for(; Counter != 0; Counter--);

1247 j++;

1248 }

1249 Pos=1;

1250 }

1251 else

1252 {

1253 /* Draw on slave page by page */

1254 LCD_SetSlavePage(ActPage);

1255 for(k=0; k<61; k++)

1256 {

1257 LCD_SetSlaveColumn(k);

1258 Counter = nCount;

1259 /* Set a delay */

1260 for(; Counter != 0; Counter--);

1261 LCD_SendSlaveData(*Bmp++);

1262 j++;

1263 }

1264 ActPage++;

1265 Pos=0;

1266 }

1267 }

1268 }

1269

1270 /*******************************************************************************

1271 * Function Name : LCD_DrawPixel

1272 * Description : Draw a Graphic image on slave LCD.

1273 * Input : - XPos: the dot line number of the pixel.

1274 * - 1->61 : displayed on master LCD

1275 * - 62->122: displayed on slave LCD

1276 * - YPos: column address of the pixel from 1->32.

1277 * - Mode: Dot_On: Pixel turned on (black).

1278 * Dot_Off: Pixel turned off (black).

1279 * Output : None

1280 * Return : None.

1281 *******************************************************************************/

1282 void LCD_DrawPixel(u8 XPos, u8 YPos, DotMode_TypeDef Mode)

1283 {

1284 u8 Page = 0, Position = 0;

1285 u16 Mask = 0;

1286 u32 MasterDataIn = 0, MasterDataOut = 0, SlaveDataIn = 0, SlaveDataOut = 0;

1287

1288 /* Pixel page */

1289 Page = (XPos-1)/8;

1290 /* Pixel column */

1291 Position = (YPos-1)/61; /* 0:Master, 1:Slave */

1292 /* Mask for the pixel */

1293 Mask= 1<<((XPos-1)%8);

1294 /* If Position=0 draw pixel on master LCD */

1295 if(!Position)

1296 {

1297 LCD_SetMasterPage(Page);

1298 LCD_SetMasterColumn(YPos-1);

1299 MasterDataIn = LCD_ReadMasterData();

1300 MasterDataIn = LCD_ReadMasterData();

1301 LCD_SetMasterColumn(YPos-1);

1302 if(Mode==Dot_On)

1303 {

1304 MasterDataOut = MasterDataIn | Mask;

1305 }

1306 else

1307 {

1308 MasterDataOut = MasterDataIn & (~Mask);

1309 }

1310 LCD_SendMasterData(MasterDataOut);

1311 }

1312 /* If Position=1 draw pixel on slave LCD */

1313 else

1314 {

1315 LCD_SetSlavePage(Page);

1316 LCD_SetSlaveColumn(YPos-62);

1317 SlaveDataIn = LCD_ReadSlaveData();

1318 SlaveDataIn = LCD_ReadSlaveData();

1319 LCD_SetSlaveColumn(YPos-62);

1320 if(Mode==Dot_On)

1321 {

1322 SlaveDataOut = SlaveDataIn | Mask;

1323 }

1324 else

1325 {

1326 SlaveDataOut = SlaveDataIn & (~Mask);

1327 }

1328 LCD_SendSlaveData(SlaveDataOut);

1329 }

1330 }

1331

1332 /*******************************************************************************

1333 * Function Name : LCD_DrawLine

1334 * Description : Draw a line on master and slave LCDs.

1335 * Input : - XPos1: the dot line number of the source point .

1336 * - XPos2: the dot line number of the destination point .

1337 * - YPos1: the dot column number of the source point.

1338 * - YPos2: the dot column number of the destination point.

1339 * Output : None

1340 * Return : None.

1341 *******************************************************************************/

1342 void LCD_DrawLine(u8 XPos1, u8 YPos1, u8 XPos2, u8 YPos2)

1343 {

1344 u8 XPos = 0, YPos = 0;

1345

1346 /* Use XPos1, YPos1, XPos2 and YPos2 */

1347 if((XPos2>=XPos1)&(YPos2>=YPos1))

1348 {

1349 for(XPos=XPos1; XPos<=XPos2; XPos++)

1350 {

1351 for(YPos=YPos1; YPos<=YPos2; YPos++)

1352 {

1353 LCD_DrawPixel(XPos, YPos, Dot_On);

1354 }

1355 }

1356 }

1357 else if((XPos2<XPos1)&(YPos2>=YPos1))

1358 {

1359 for(XPos=XPos2; XPos<=XPos1; XPos++)

1360 {

1361 for(YPos=YPos1; YPos<=YPos2; YPos++)

1362 {

1363 LCD_DrawPixel(XPos, YPos, Dot_On);

1364 }

1365 }

1366 }

1367 else if((XPos2>=XPos1)&(YPos2<YPos1))

1368 {

1369 for(XPos=XPos1; XPos<=XPos2; XPos++)

1370 {

1371 for(YPos=YPos2; YPos<=YPos1; YPos++)

1372 {

1373 LCD_DrawPixel(XPos, YPos, Dot_On);

1374 }

1375 }

1376 }

1377 else /*if((XPos2<XPos1)&(YPos2<YPos1))*/

1378 {

1379 for(XPos=XPos2; XPos<=XPos1; XPos++)

1380 {

1381 for(YPos=YPos2; YPos<=YPos1; YPos++)

1382 {

1383 LCD_DrawPixel(XPos, YPos, Dot_On);

1384 }

1385 }

1386 }

1387 }

1388

1389 /*******************************************************************************

1390 * Function Name : LCD_DrawBox

1391 * Description : Draw a Box on master and slave LCDs.

1392 * Input : - XPos: the dot line number of the source point .

1393 * - YPos: the dot column number of the source point.

1394 * - Dx: Box large.

1395 * - Dy: Box width.

1396 * Output : None

1397 * Return : None.

1398 *******************************************************************************/

1399 void LCD_DrawBox(u8 XPos, u8 YPos, u8 Dx, u8 Dy)

1400 {

1401 /* Use XPos, YPos, Dx and Dy */

1402 LCD_DrawLine(XPos, YPos, XPos, YPos+Dy);

1403 LCD_DrawLine(XPos, YPos, XPos+Dx, YPos);

1404 LCD_DrawLine(XPos+Dx, YPos, XPos+Dx, YPos+Dy);

1405 LCD_DrawLine(XPos, YPos+Dy, XPos+Dx, YPos+Dy);

1406 }

1407

1409