STM32 12864串行驱动-电子工程世界

分享到: 微博; QQ; 微信; LinkedIn

有些12864没有以下全部功能：

DDRAM：（Data Display Ram），数据显示RAM，往里面写啥，屏幕就会显示啥。

CGROM：（Character Generation ROM）,字符发生ROM。里面存储了中文汉字的字模，也称作中文字库，编码方式有GB2312（中文简体）和BIG5（中文繁体）。

CGRAM：（Character Generation RAM），字符发生RAM，，12864内部提供了64×2B的CGRAM，可用于用户自定义4个16×16字符，每个字符占用32个字节。

GDRAM：（Graphic Display RAM）：图形显示RAM，用于绘图，往里面写啥，屏幕就会显示啥，往GDRAM中写的数据是图形的点阵信息，每个点用1bit来保存其显示与否。

绘图RAM就是给这些点阵置1或置0，可以看到其实它本来是32行×256列的，但是分成了上下两屏显示，每个点对应了屏幕上的一个点。要使用绘图功能需要开启扩展指令。然后写地址，再读写数据。

GDRAM的读写：GDRAM的操作基本单位是一个字，也就是2个字节。

写数据：先开启扩展指令集（0x36）,然后送地址，这里的地址与DDRAM中的略有不同，DDRAM中的地址只有一个，那就是字地址。而GDRAM中的地址有2个，分别是字地址（列地址/水平地址X）和位地址（行地址/垂直地址Y），上图中的垂直地址就是00H~31H，水平地址就是00H~15H,写地址时先写垂直地址（行地址）再写水平地址（列地址），也就是连续写入两个地址，然后再连续写入2个字节的数据。如图中所示，左边为高字节右边为低字节。为1的点被描黑，为0的点则显示空白。这里列举个写地址的例子：写GDRAM地址指令是0x80+地址。被加上的地址就是上面列举的X和Y,假设我们要写第一行的2个字节，那么写入地址就是0x00H(写行地址)然后写0x80H（列地址），之后才连续写入2个字节的数据（先高字节后低字节）。再如写屏幕右下角的2个字节，先写行地址0x9F（0x80+32），再写列地址0x8F(0x80+15)，然后连续写入2个字节的数据。编程中写地址函数中直接用参数（0x+32），而不必自己相加。

读数据：先开启扩展指令集，然后写行地址、写列地址，假读一次，再连续读2字节的数据（先高字节后低字节）。

由于串行下不好读数据，所以画点程序还没弄好：

1 /*yj12864.h*/

2 #ifndef _YJ12864_H

3 #define _YJ12864_H

4 #include "sys.h"

6 //YJ-G12864-97

7 //1=SDA 2=SCK 3=CS 4=CD(RS) 5=RST 6=VDD 7=VSS 8=K 9=A

8 //For STM32F103

10 #define RS PBout(15)

11 #define RST PBout(14)

12 #define CS PBout(13)

13 #define SDA PBout(12)

14 #define SCK PBout(11)

16 extern void Lcd_init(void);

17 extern u8 Read_data(void);

18 extern void Write_data(u8 data);

19 extern void Write_command(u8 com);

21 extern void Lcd_pos(u8 x,u8 y);

22 extern void Clear_screen(void);

23 extern void Disp_char(u8 x, u8 y, u8 z);

24 extern void Disp_string(u8 x,u8 y,u8 *z);

25 extern void Disp_num(u8 x,u8 y,s16 num);

27 extern void Clear_GDRAM(void);

28 extern void Draw_point(u8 x,u8 y,u8 color);

30 #endif

复制代码

1 /*yj12864.c*/

2 #include "yj12864.h"

3 #include "delay.h"

4 #include "stm32f10x_gpio.h"

6 const u8 zimu[][6] =

7 {

8 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // sp ASCII = 32

9 { 0x00, 0x00, 0x00, 0x2f, 0x00, 0x00 }, // !

10 { 0x00, 0x00, 0x07, 0x00, 0x07, 0x00 }, // "

11 { 0x00, 0x14, 0x7f, 0x14, 0x7f, 0x14 }, // #

12 { 0x00, 0x24, 0x2a, 0x7f, 0x2a, 0x12 }, // $

13 { 0x00, 0x62, 0x64, 0x08, 0x13, 0x23 }, // %

14 { 0x00, 0x36, 0x49, 0x55, 0x22, 0x50 }, // &

15 { 0x00, 0x00, 0x05, 0x03, 0x00, 0x00 }, // '

16 { 0x00, 0x00, 0x1c, 0x22, 0x41, 0x00 }, // (

17 { 0x00, 0x00, 0x41, 0x22, 0x1c, 0x00 }, // )

18 { 0x00, 0x14, 0x08, 0x3E, 0x08, 0x14 }, // *

19 { 0x00, 0x08, 0x08, 0x3E, 0x08, 0x08 }, // +

20 { 0x00, 0x00, 0x00, 0xA0, 0x60, 0x00 }, // ,

21 { 0x00, 0x08, 0x08, 0x08, 0x08, 0x08 }, // -

22 { 0x00, 0x00, 0x60, 0x60, 0x00, 0x00 }, // .

23 { 0x00, 0x20, 0x10, 0x08, 0x04, 0x02 }, // /

24 { 0x00, 0x3E, 0x51, 0x49, 0x45, 0x3E }, // 0

25 { 0x00, 0x00, 0x42, 0x7F, 0x40, 0x00 }, // 1

26 { 0x00, 0x42, 0x61, 0x51, 0x49, 0x46 }, // 2

27 { 0x00, 0x21, 0x41, 0x45, 0x4B, 0x31 }, // 3

28 { 0x00, 0x18, 0x14, 0x12, 0x7F, 0x10 }, // 4

29 { 0x00, 0x27, 0x45, 0x45, 0x45, 0x39 }, // 5

30 { 0x00, 0x3C, 0x4A, 0x49, 0x49, 0x30 }, // 6

31 { 0x00, 0x01, 0x71, 0x09, 0x05, 0x03 }, // 7

32 { 0x00, 0x36, 0x49, 0x49, 0x49, 0x36 }, // 8

33 { 0x00, 0x06, 0x49, 0x49, 0x29, 0x1E }, // 9

34 { 0x00, 0x00, 0x36, 0x36, 0x00, 0x00 }, // :

35 { 0x00, 0x00, 0x56, 0x36, 0x00, 0x00 }, // ;

36 { 0x00, 0x08, 0x14, 0x22, 0x41, 0x00 }, // <

37 { 0x00, 0x14, 0x14, 0x14, 0x14, 0x14 }, // =

38 { 0x00, 0x00, 0x41, 0x22, 0x14, 0x08 }, // >

39 { 0x00, 0x02, 0x01, 0x51, 0x09, 0x06 }, // ?

40 { 0x00, 0x32, 0x49, 0x59, 0x51, 0x3E }, // @

41 { 0x00, 0x7C, 0x12, 0x11, 0x12, 0x7C }, // A

42 { 0x00, 0x7F, 0x49, 0x49, 0x49, 0x36 }, // B

43 { 0x00, 0x3E, 0x41, 0x41, 0x41, 0x22 }, // C

44 { 0x00, 0x7F, 0x41, 0x41, 0x22, 0x1C }, // D

45 { 0x00, 0x7F, 0x49, 0x49, 0x49, 0x41 }, // E

46 { 0x00, 0x7F, 0x09, 0x09, 0x09, 0x01 }, // F

47 { 0x00, 0x3E, 0x41, 0x49, 0x49, 0x7A }, // G

48 { 0x00, 0x7F, 0x08, 0x08, 0x08, 0x7F }, // H

49 { 0x00, 0x00, 0x41, 0x7F, 0x41, 0x00 }, // I

50 { 0x00, 0x20, 0x40, 0x41, 0x3F, 0x01 }, // J

51 { 0x00, 0x7F, 0x08, 0x14, 0x22, 0x41 }, // K

52 { 0x00, 0x7F, 0x40, 0x40, 0x40, 0x40 }, // L

53 { 0x00, 0x7F, 0x02, 0x0C, 0x02, 0x7F }, // M

54 { 0x00, 0x7F, 0x04, 0x08, 0x10, 0x7F }, // N

55 { 0x00, 0x3E, 0x41, 0x41, 0x41, 0x3E }, // O

56 { 0x00, 0x7F, 0x09, 0x09, 0x09, 0x06 }, // P

57 { 0x00, 0x3E, 0x41, 0x51, 0x21, 0x5E }, // Q

58 { 0x00, 0x7F, 0x09, 0x19, 0x29, 0x46 }, // R

59 { 0x00, 0x46, 0x49, 0x49, 0x49, 0x31 }, // S

60 { 0x00, 0x01, 0x01, 0x7F, 0x01, 0x01 }, // T

61 { 0x00, 0x3F, 0x40, 0x40, 0x40, 0x3F }, // U

62 { 0x00, 0x1F, 0x20, 0x40, 0x20, 0x1F }, // V

63 { 0x00, 0x3F, 0x40, 0x38, 0x40, 0x3F }, // W

64 { 0x00, 0x63, 0x14, 0x08, 0x14, 0x63 }, // X

65 { 0x00, 0x07, 0x08, 0x70, 0x08, 0x07 }, // Y

66 { 0x00, 0x61, 0x51, 0x49, 0x45, 0x43 }, // Z

67 { 0x00, 0x00, 0x7F, 0x41, 0x41, 0x00 }, // [

68 { 0x00, 0x55, 0x2A, 0x55, 0x2A, 0x55 }, // 55

69 { 0x00, 0x00, 0x41, 0x41, 0x7F, 0x00 }, // ]

70 { 0x00, 0x04, 0x02, 0x01, 0x02, 0x04 }, // ^

71 { 0x00, 0x40, 0x40, 0x40, 0x40, 0x40 }, // _

72 { 0x00, 0x00, 0x01, 0x02, 0x04, 0x00 }, // '

73 { 0x00, 0x20, 0x54, 0x54, 0x54, 0x78 }, // a

74 { 0x00, 0x7F, 0x48, 0x44, 0x44, 0x38 }, // b

75 { 0x00, 0x38, 0x44, 0x44, 0x44, 0x20 }, // c

76 { 0x00, 0x38, 0x44, 0x44, 0x48, 0x7F }, // d

77 { 0x00, 0x38, 0x54, 0x54, 0x54, 0x18 }, // e

78 { 0x00, 0x08, 0x7E, 0x09, 0x01, 0x02 }, // f

79 { 0x00, 0x18, 0xA4, 0xA4, 0xA4, 0x7C }, // g

80 { 0x00, 0x7F, 0x08, 0x04, 0x04, 0x78 }, // h

81 { 0x00, 0x00, 0x44, 0x7D, 0x40, 0x00 }, // i

82 { 0x00, 0x40, 0x80, 0x84, 0x7D, 0x00 }, // j

83 { 0x00, 0x7F, 0x10, 0x28, 0x44, 0x00 }, // k

84 { 0x00, 0x00, 0x41, 0x7F, 0x40, 0x00 }, // l

85 { 0x00, 0x7C, 0x04, 0x18, 0x04, 0x78 }, // m

86 { 0x00, 0x7C, 0x08, 0x04, 0x04, 0x78 }, // n

87 { 0x00, 0x38, 0x44, 0x44, 0x44, 0x38 }, // o

88 { 0x00, 0xFC, 0x24, 0x24, 0x24, 0x18 }, // p

89 { 0x00, 0x18, 0x24, 0x24, 0x18, 0xFC }, // q

90 { 0x00, 0x7C, 0x08, 0x04, 0x04, 0x08 }, // r

91 { 0x00, 0x48, 0x54, 0x54, 0x54, 0x20 }, // s

92 { 0x00, 0x04, 0x3F, 0x44, 0x40, 0x20 }, // t

93 { 0x00, 0x3C, 0x40, 0x40, 0x20, 0x7C }, // u

94 { 0x00, 0x1C, 0x20, 0x40, 0x20, 0x1C }, // v

95 { 0x00, 0x3C, 0x40, 0x30, 0x40, 0x3C }, // w

96 { 0x00, 0x44, 0x28, 0x10, 0x28, 0x44 }, // x

97 { 0x00, 0x1C, 0xA0, 0xA0, 0xA0, 0x7C }, // y

98 { 0x00, 0x44, 0x64, 0x54, 0x4C, 0x44 }, // z

99 { 0x14, 0x14, 0x14, 0x14, 0x14, 0x14 } // horiz lines

100 };

101 void Lcd_init(void)

102 {

103 GPIO_InitTypeDef GPIO_InitStructure;

104 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB,ENABLE);

105

106 GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11|GPIO_Pin_12|GPIO_Pin_13|GPIO_Pin_14|GPIO_Pin_15;

107 GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;

108 GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

109 GPIO_Init(GPIOB, &GPIO_InitStructure);

110

111 RST=0; /*µÍµçÆ½¸´Î»*/

112 delay_ms(20);

113 RST=1; /*¸´Î»Íê±Ï*/

114 delay_ms(20);

115 Write_command(0xe2); /*Èí¸´Î»*/

116 delay_ms(5);

117 Write_command(0x2c); /*ÉýÑ¹²½¾Û1*/

118 delay_ms(5);

119 Write_command(0x2e); /*ÉýÑ¹²½¾Û2*/

120 delay_ms(5);

121 Write_command(0x2f); /*ÉýÑ¹²½¾Û3*/

122 delay_ms(5);

123 Write_command(0x25); /*´Öµ÷¶Ô±È¶È£¬¿ÉÉèÖÃ·¶Î§0x20¡«0x27*/

124 Write_command(0x81); /*Î¢µ÷¶Ô±È¶È*/

125 Write_command(0x1A); /*Î¢µ÷¶Ô±È¶ÈµÄÖµ£¬¿ÉÉèÖÃ·¶Î§0x00¡«0x3f*/

126 Write_command(0xa2); /*1/9 Æ«Ñ¹±È£¨bias£©*/

127 Write_command(0xc8); /*ÐÐÉ¨ÃèË³Ðò£º´ÓÉÏµ½ÏÂ*/

128 Write_command(0xa0); /*ÁÐÉ¨ÃèË³Ðò£º´Ó×óµ½ÓÒ*/

129 Write_command(0x40); /*ÆðÊ¼ÐÐ£ºµÚÒ»ÐÐ¿ªÊ¼*/

130 Write_command(0xaf); /*¿ªÏÔÊ¾*/

131 delay_ms(10);

132 Write_command(0x30);

133 delay_ms(5);

134 Write_command(0x30);

135 delay_ms(10);

136 Write_command(0x0c);

137

138 Clear_screen();

139 }

140 void Write_command(u8 com)

141 {

142 u8 i;

143 CS=0;

144 RS=0;

145 for(i=0;i<8;i++)

146 {

147 SCK=0;

148 if(com&0x80) SDA=1;

149 else SDA=0;

150 delay_ms(2);

151 SCK=1;

152 delay_ms(2);

153 com=com<<=1;

154 }

155 }

156 void Write_data(u8 data)

157 {

158 u8 i;

159 CS=0;

160 RS=1;

161 for(i=0;i<8;i++)

162 {

163 SCK=0;

164 if(data&0x80) SDA=1;

165 else SDA=0;

166 SCK=1;

167 data=data<<=1;

168 }

169 }

170 void Lcd_pos(u8 x,u8 y)

171 {

172 Write_command(0xb0+y);

173 Write_command(((x&0xf0)>>4)|0x10);

174 Write_command((x&0x0f)|0x01);

175 }

176 void Clear_screen(void)

177 {

178 u8 i,j;

179 for(i=0;i<9;i++)

180 {

181 CS=0;

182 Write_command(0xb0+i);

183 Write_command(0x10);

184 Write_command(0x01);

185 for(j=0;j<132;j++)

186 Write_data(0x00);

187 }

188 }

189 void Disp_char(u8 x, u8 y, u8 z)

190 {

191

192 u8 j;

193 z -=32;

194 Lcd_pos(x,y);

195 for(j=0;j<6;j++)

196 {

197 Write_data(zimu[z][j]);

198 }

199 }

200 void Disp_string(u8 x,u8 y,u8 *z)

201 {

202 while(*z)

203 {

204 Disp_char(x, y, *z);

205 z++;

206 x +=6;

207 if(x>126)

208 {

209 x=0;

210 y++;

211 }

212 }

213 }

214 void Disp_num(u8 x,u8 y,s16 num)

215 {//s16 = signed int

216 u8 c,i,j,n[7]={0};

217 if(num<0)

218 {

219 Disp_char(x,y,'-');

220 x +=6;

221 num=-num;

222 }

223 if(num==0)

224 {

225 Disp_char(x,y,'0');

226 }

227 else

228 {

229 for(i=0;num>0;i++)

230 {

231 n[i]=num%10;

232 num/=10;

233 }

234 while(i--)

235 {

236 c=n[i]+16;

237 Lcd_pos(x,y);

238 for(j=0;j<6;j++)

239 {

240 Write_data(zimu[c][j]);

241 }

242 x+=6;

243 }

244 }

245 }

246 void Clear_GDRAM(void)

247 {

248 u8 j,k;

249 Write_command(0x34);

250 for( j = 0 ; j < 32 ; j++ )

251 {

252 Write_command(0x80 + j); // Y

253 Write_command(0x80); // X

254 for( k = 0 ; k < 32 ; k++ )

255 {// address auto ++

256 Write_data(0x00);

257 }

258 }

259 Write_command(0x30);

260 }

261 void Draw_point(u8 x,u8 y,u8 color)

262 {//color = 0, 1

263 u8 X,Y,k,DH=0x00,DL=0x00;

264 Write_command(0x34);

265 if(y >= 0 && y <= 63 && x >= 0 && x <= 127)

266 {

267 if(y < 32)

268 {

269 X = 0x80 + (x >> 4); // x/16 128/16=8

270 Y = 0x80 + y;

271 }

272 else

273 {

274 X = 0x88 + (x >> 4);

275 Y = 0x80 + (y - 32);

276 }

277 }

278 k = x%16;

279 switch(color)

280 {

281 case 0: if(k < 8)

282 DH = ~(0x01 << (7 - k));

283 else

284 DL = ~(0x01 << (7 - (k % 8)));

285 break;

286 case 1: if(k < 8)

287 DH = (0x01 << (7 - k));

288 else

289 DL = (0x01 << (7 - (k % 8)));

290 break;

291 default: break;

292 }

293 Write_command(Y);

294 Write_command(X);

295 Write_data(DH);

296 Write_data(DL);

297 Write_command(0x36);

298 Write_command(0x30);

299 }

关键字：STM32 串行驱动引用地址：STM32 12864串行驱动

上一篇：STM32中常见错误的处理方法
下一篇：STM32小知识笔记

推荐阅读最新更新时间：2024-03-16 15:29

关于STM32的存储器映像

1. 外设存储器映像外设的基地址：响应外设的存储器起始地址+地址偏移（参见STM32参考手册存储器影响部分和相应的外设存储器） 2. SRAM STM32F10xxx 内置20K 字节的静态SRAM。它可以以字节、半字(16 位)或全字 (32 位)访问。SRAM 的起始地址是0x2000 0000。 3. 位段 4. 嵌入式闪存

[单片机]

stm32发脉冲

发脉冲两种目的 1）速度控制 2）位置控制速度控制目的和模拟量一样，没有什么需要关注的地方发送脉冲方式为PWM，速率稳定而且资源占用少 stm32位置控制需要获得发送的脉冲数，有下面4种手段 1）每发送一个脉冲，做一次中断计数 2）根据发送的频率发送的时间，获得脉冲数量，对于变速的脉冲，可以累计积分的方法来获得总脉冲 3）一个定时器作为主发送脉冲，另外一个定时器作为从，对发送的脉冲计数 4）使用DMA方式，例如共发送1000个脉冲，那么定义u16 per ,每发送一个脉冲，dma会从数组中更新下一个占空比字，数组最后一个字为0，表示停发脉冲上面4种方法的用途和特点 1）对于低速率脉冲比较好，可以说低速发脉冲的首

[单片机]

STM32单片机的八种IO口模式解析

STM32八种IO口模式区别（1）GPIO_Mode_AIN模拟输入（2）GPIO_Mode_IN_FLOATING浮空输入（3）GPIO_Mode_IPD下拉输入（4）GPIO_Mode_IPU上拉输入（5）GPIO_Mode_Out_OD开漏输出（6）GPIO_Mode_Out_PP推挽输出（7）GPIO_Mode_AF_OD复用开漏输出（8）GPIO_Mode_AF_PP复用推挽输出以下是详细讲解（1）GPIO_Mode_AIN模拟输入即关闭施密特触发器，将电压信号传送到片上外设模块（不接上、下拉电阻）（2）GPIO_Mode_IN_FLOATING浮空输入浮空输入状态下，IO的电平状态是不确定

[单片机]

cortex_m3_STM32嵌入式学习笔记18之DAC实验

STM32 的 DAC 模块(数字/模拟转换模块)是 12 位数字输入，电压输出型的 DAC。 DAC可以配置为 8 位或 12 位模式，也可以与 DMA 控制器配合使用。 DAC 工作在 12 位模式时，数据可以设置成左对齐或右对齐。 DAC 模块有 2 个输出通道，每个通道都有单独的转换器。在双 DAC 模式下， 2 个通道可以独立地进行转换，也可以同时进行转换并同步地更新 2 个通道的输出。本节实验，我们将利用按键（或 USMART）控制 STM32 内部 DAC1来输出电压，通过 ADC1的通道1 采集 DAC的输出电压，在 LCD 模块上面显示 ADC 获取到的电压值以及 DAC 的设定输出电压值等信息。 S

[单片机]

STM32中如何使用printf（）函数

STM32串口通信中使用printf发送数据配置方法(开发环境 Keil RVMDK 在STM32串口通信程序中使用printf发送数据，非常的方便。可在刚开始使用的时候总是遇到问题，常见的是硬件访真时无法进入main主函数，其实只要简单的配置一下就可以了。下面就说一下使用printf需要做哪些配置。有两种配置方法：一、对工程属性进行配置，详细步骤如下 1、首先要在你的main 文件中包含 stdio.h （标准输入输出头文件）。 2、在main文件中重定义 fputc 函数如下： // 发送数据 int fputc(int ch, FILE *f) { USART_SendData(USART1,

[单片机]

一种无OS的STM32实用软件框架编程案例

一种无OS的STM32实用软件框架，包括任务轮询管理，命令管理器、低功耗管理、环形缓冲区等实用模块。系统中广泛利用自定义段技术减少各个模块间的耦合关系，大大提供程序的可维护性。主要功能支持模块自动化管理，并提供不同优先等级初始化声明接口。支持任务轮询管理，通过简单的宏声明即可实现，不需要复杂的声明调用。支持低功耗管理，休眠与唤醒通知。支持命令行解析，命令注册与执行。 blink设备支持，统一管理LED、震动马达、蜂鸣器使用说明点击STM32嵌入式开发公众号文末的“阅读原文”，可以完整的工程代码，系统开发平台如下： MCU：STM32F401RET6 IDE：IAR 7.4或者K

[单片机]

STM32adc采集的一些bug

调试过程如下：进行调试发现这个卡死在 while(!ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC ));1 等待转换结束。一般的卡在这个地方主要是初始化没有做好，需要进行初始化的检查，去看初始化的代码。

[单片机]

怎样用STM32 中的 I2C读写EEPROM(二)

假设硬件电路如下图 EEPROM芯片的设备地址一共有 7 位，其中高 4 位固定为：1010 b，低 3 位则由 A0/A1/A2 信号线的电平决定，图中的 R/W是读写方向位，与地址无关。按照我们此处的连接，A0/A1/A2均为0，所以EEPROM的7位设备地址是：101 0000b ，即 0x50。由于 I2C 通讯时常常是地址跟读写方向连在一起构成一个 8 位数，且当 R/W 位为 0 时，表示写方向，所以加上 7 位地址，其值为“0xA0”，常称该值为 I2C 设备的“写地址”；当 R/W 位为 1 时，表示读方向，加上 7 位地址，其值为“0xA1”，常称该值为“读地址”。 EEPROM 芯片

[单片机]