zhanqingxia
/
card_2.4G_compare_tools
Seguir 1
Destacar 0
Fork 0
Código Incidencias 0 Pull Requests 0 Lanzamientos 0 Wiki Actividad
No puede seleccionar más de 25 temas Los temas deben comenzar con una letra o número, pueden incluir guiones ('-') y pueden tener hasta 35 caracteres de largo.
1 Commit
1 Rama
2.6MB
Rama: master
Ramas Etiquetas
${ item.name }
Crear rama ${ searchTerm }
desde 'master'
${ noResults }
card_2.4G_compare_tools/bsp/LCD.c

927 líneas
24KB
Original Enlace permanente Blame Histórico 

  1. #include "LCD.h"

  2. 

  3. u8 ucDispDT;

  4. 

  5. static const u8 font816[38][16]=

  6. {

  7. 	{0xF8,0xFC,0x04,0xC4,0x24,0xFC,0xF8,0x00,0x07,0x0F,0x09,0x08,0x08,0x0F,0x07,0x00},  // -0-

  8. 	{0x00,0x10,0x18,0xFC,0xFC,0x00,0x00,0x00,0x00,0x08,0x08,0x0F,0x0F,0x08,0x08,0x00},  // -1-

  9. 	{0x08,0x0C,0x84,0xC4,0x64,0x3C,0x18,0x00,0x0E,0x0F,0x09,0x08,0x08,0x0C,0x0C,0x00},  // -2-

  10. 	{0x08,0x0C,0x44,0x44,0x44,0xFC,0xB8,0x00,0x04,0x0C,0x08,0x08,0x08,0x0F,0x07,0x00},  // -3-

  11. 	{0xC0,0xE0,0xB0,0x98,0xFC,0xFC,0x80,0x00,0x00,0x00,0x00,0x08,0x0F,0x0F,0x08,0x00},  // -4-

  12. 	{0x7C,0x7C,0x44,0x44,0xC4,0xC4,0x84,0x00,0x04,0x0C,0x08,0x08,0x08,0x0F,0x07,0x00},  // -5-

  13. 	{0xF0,0xF8,0x4C,0x44,0x44,0xC0,0x80,0x00,0x07,0x0F,0x08,0x08,0x08,0x0F,0x07,0x00},  // -6-

  14. 	{0x0C,0x0C,0x04,0x84,0xC4,0x7C,0x3C,0x00,0x00,0x00,0x0F,0x0F,0x00,0x00,0x00,0x00},  // -7-

  15. 	{0xB8,0xFC,0x44,0x44,0x44,0xFC,0xB8,0x00,0x07,0x0F,0x08,0x08,0x08,0x0F,0x07,0x00},  // -8-

  16. 	{0x38,0x7C,0x44,0x44,0x44,0xFC,0xF8,0x00,0x00,0x08,0x08,0x08,0x0C,0x07,0x03,0x00},  // -9-

  17. 	{0xE0,0xF0,0x98,0x8C,0x98,0xF0,0xE0,0x00,0x0F,0x0F,0x00,0x00,0x00,0x0F,0x0F,0x00},  // -A- 10

  18. 	{0x04,0xFC,0xFC,0x44,0x44,0xFC,0xB8,0x00,0x08,0x0F,0x0F,0x08,0x08,0x0F,0x07,0x00},  // -B- 11

  19. 	{0xF0,0xF8,0x0C,0x04,0x04,0x0C,0x18,0x00,0x03,0x07,0x0C,0x08,0x08,0x0C,0x06,0x00},  // -C- 12

  20. 	{0x04,0xFC,0xFC,0x04,0x0C,0xF8,0xF0,0x00,0x08,0x0F,0x0F,0x08,0x0C,0x07,0x03,0x00},  // -D- 13

  21. 	{0x04,0xFC,0xFC,0x44,0xE4,0x0C,0x1C,0x00,0x08,0x0F,0x0F,0x08,0x08,0x0C,0x0E,0x00},  // -E- 14

  22. 	{0x04,0xFC,0xFC,0x44,0xE4,0x0C,0x1C,0x00,0x08,0x0F,0x0F,0x08,0x00,0x00,0x00,0x00},  // -F- 15	

  23. 	{0xF0,0xF8,0x0C,0x84,0x84,0x8C,0x98,0x00,0x03,0x07,0x0C,0x08,0x08,0x07,0x0F,0x00},  // -G- 16		

  24. 	{0xFC,0xFC,0x40,0x40,0x40,0xFC,0xFC,0x00,0x0F,0x0F,0x00,0x00,0x00,0x0F,0x0F,0x00},  // -H- 17		

  25. 	{0x00,0x00,0x04,0xFC,0xFC,0x04,0x00,0x00,0x00,0x00,0x08,0x0F,0x0F,0x08,0x00,0x00},  // -I- 18	

  26. 	{0x00,0x00,0x00,0x04,0xFC,0xFC,0x04,0x00,0x07,0x0F,0x08,0x08,0x0F,0x07,0x00,0x00},  // -J- 19	

  27. 	{0x04,0xFC,0xFC,0xC0,0xF0,0x3C,0x0C,0x00,0x08,0x0F,0x0F,0x00,0x01,0x0F,0x0E,0x00},  // -K- 20	

  28. 	{0x04,0xFC,0xFC,0x04,0x00,0x00,0x00,0x00,0x08,0x0F,0x0F,0x08,0x08,0x0C,0x0E,0x00},  // -L- 21	

  29. 	{0xFC,0xFC,0x38,0x70,0x38,0xFC,0xFC,0x00,0x0F,0x0F,0x00,0x00,0x00,0x0F,0x0F,0x00},  // -M- 22	

  30. 	{0xFC,0xFC,0x38,0x70,0xE0,0xFC,0xFC,0x00,0x0F,0x0F,0x00,0x00,0x00,0x0F,0x0F,0x00},  // -N- 23	

  31. 	{0xF0,0xF8,0x0C,0x04,0x0C,0xF8,0xF0,0x00,0x03,0x07,0x0C,0x08,0x0C,0x07,0x03,0x00},  // -O- 24		

  32. 	{0x04,0xFC,0xFC,0x44,0x44,0x7C,0x38,0x00,0x08,0x0F,0x0F,0x08,0x00,0x00,0x00,0x00},  // -P- 25		

  33. 	{0xF8,0xFC,0x04,0x04,0x04,0xFC,0xF8,0x00,0x07,0x0F,0x08,0x0E,0x3C,0x3F,0x27,0x00},  // -Q- 26		

  34. 	{0x04,0xFC,0xFC,0x44,0xC4,0xFC,0x38,0x00,0x08,0x0F,0x0F,0x00,0x00,0x0F,0x0F,0x00},  // -R- 27		

  35. 	{0x18,0x3C,0x64,0x44,0xC4,0x9C,0x18,0x00,0x06,0x0E,0x08,0x08,0x08,0x0F,0x07,0x00},  // -S- 28	

  36. 	{0x00,0x1C,0x0C,0xFC,0xFC,0x0C,0x1C,0x00,0x00,0x00,0x08,0x0F,0x0F,0x08,0x00,0x00},  // -T- 29		

  37. 	{0xFC,0xFC,0x00,0x00,0x00,0xFC,0xFC,0x00,0x07,0x0F,0x08,0x08,0x08,0x0F,0x07,0x00},  // -U- 30		

  38. 	{0xFC,0xFC,0x00,0x00,0x00,0xFC,0xFC,0x00,0x01,0x03,0x06,0x0C,0x06,0x03,0x01,0x00},  // -V- 31	

  39. 	{0xFC,0xFC,0x00,0x80,0x00,0xFC,0xFC,0x00,0x03,0x0F,0x0E,0x03,0x0E,0x0F,0x03,0x00},  // -W- 32		

  40. 	{0x0C,0x3C,0xF0,0xC0,0xF0,0x3C,0x0C,0x00,0x0C,0x0F,0x03,0x00,0x03,0x0F,0x0C,0x00},  // -X- 33	

  41. 	{0x00,0x3C,0x7C,0xC0,0xC0,0x7C,0x3C,0x00,0x00,0x00,0x08,0x0F,0x0F,0x08,0x00,0x00},  // -Y- 34		

  42. 	{0x1C,0x0C,0x84,0xC4,0x64,0x3C,0x1C,0x00,0x0E,0x0F,0x09,0x08,0x08,0x0C,0x0E,0x00},  // -Z- 35

  43. 	{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0C,0x0C,0x00,0x00,0x00},  // -.- 36

  44. 	{0x00,0x00,0x00,0x30,0x30,0x00,0x00,0x00,0x00,0x00,0x00,0x06,0x06,0x00,0x00,0x00},  // -:- 37

  45. 

  46. };

  47. void Get_8x16_Font(u16 character ,u8* backbuf)

  48. {

  49. 	if( (character>='0')&&(character<='9'))

  50. 	{

  51. 		character -= '0';

  52. 	}

  53. #if 1

  54. 	else if( (character>='A')&&(character<='Z'))

  55. 	{

  56. 		character = character - 'A' + 10;

  57. 	}

  58. #endif

  59. 	else if(character == ':')

  60. 	{

  61. 		character = 37;

  62. 	}

  63. 	else if(character == '.')

  64. 	{

  65. 		character = 36;

  66. 	}

  67. 	//backbuf = (uint8 *)(Num612[character]);

  68. 	memcpy(backbuf, (u8 *)(font816[character]),sizeof(font816[character]));          

  69. }

  70. #if 1

  71. void HexToDec(u32 tempdata,u8* buf,unsigned char bufLen)

  72. {

  73. 	buf[0]=tempdata/1000000000;

  74. 	buf[1]=tempdata/100000000-(buf[0]*10);

  75. 	buf[2]=tempdata/10000000-(buf[0]*100)-(buf[1]*10);

  76. 	buf[3]=tempdata/1000000-buf[0]*1000-buf[1]*100-buf[2]*10;

  77. 	buf[4]=tempdata/100000-buf[0]*10000-buf[1]*1000-buf[2]*100-buf[3]*10;

  78. 	buf[5]=tempdata/10000-buf[0]*100000-buf[1]*10000-buf[2]*1000-buf[3]*100-buf[4]*10;

  79. 	buf[6]=tempdata/1000-buf[0]*1000000-buf[1]*100000-buf[2]*10000-buf[3]*1000-buf[4]*100-buf[5]*10;

  80. 	buf[7]=tempdata/100-buf[0]*10000000-buf[1]*1000000-buf[2]*100000-buf[3]*10000-buf[4]*1000-buf[5]*100-buf[6]*10;

  81. 	buf[8]=tempdata/10-buf[0]*100000000-buf[1]*10000000-buf[2]*1000000-buf[3]*100000-buf[4]*10000-buf[5]*1000-buf[6]*100-buf[7]*10;

  82. 	buf[9]=tempdata-buf[0]*1000000000-buf[1]*100000000-buf[2]*10000000-buf[3]*1000000-buf[4]*100000-buf[5]*10000-buf[6]*1000-buf[7]*100-buf[8]*10;

  83. }

  84. #endif

  85. 

  86. void AttenuatorConfig(void)

  87. {

  88. 	GPIO_InitTypeDef  GPIO_InitStructure;

  89. 	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;	   //1A		   

  90. 	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;	 

  91. 	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;	 //50MHz

  92. 	GPIO_Init(GPIOA, &GPIO_InitStructure);

  93. 

  94. 	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;	   //2A	   

  95. 	//GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;	 

  96. 	//GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;  //50MHz

  97. 	GPIO_Init(GPIOC, &GPIO_InitStructure);

  98. 

  99. 	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4;	   //3A   

  100. 	//GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;	 

  101. 	//GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;  //50MHz

  102. 	GPIO_Init(GPIOC, &GPIO_InitStructure);

  103. 

  104. 	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5;	   //4A	   

  105. 	//GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;	 

  106. 	//GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;  //50MHz

  107. 	GPIO_Init(GPIOC, &GPIO_InitStructure);

  108. 

  109. 	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_14;	   //5A	   

  110. 	//GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;	 

  111. 	//GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;  //50MHz

  112. 	GPIO_Init(GPIOC, &GPIO_InitStructure);

  113. 

  114. #if 1  //衰减效果最好

  115. 	GPIO_SetBits(GPIOA,GPIO_Pin_8);

  116. 	GPIO_SetBits(GPIOC,GPIO_Pin_8);

  117. 	GPIO_SetBits(GPIOC,GPIO_Pin_4);

  118. 	GPIO_SetBits(GPIOC,GPIO_Pin_5);

  119. 	GPIO_SetBits(GPIOC,GPIO_Pin_14);

  120. #else

  121. 	GPIO_ResetBits(GPIOA,GPIO_Pin_8);

  122. 	GPIO_ResetBits(GPIOC,GPIO_Pin_8);

  123. 	GPIO_ResetBits(GPIOC,GPIO_Pin_4);

  124. 	GPIO_ResetBits(GPIOC,GPIO_Pin_5);

  125. 	GPIO_ResetBits(GPIOC,GPIO_Pin_14);

  126. #endif

  127. 

  128. }

  129. 

  130. void lcd_init(void)

  131. {

  132. 	GPIO_InitTypeDef  GPIO_InitStructure;

  133. 	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;	   //LCD  POWER		   

  134. 	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;	 

  135. 	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;	 //50MHz

  136. 	GPIO_Init(GPIOC, &GPIO_InitStructure);

  137. 

  138. 	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;	   //LCD  CS 	   

  139. 	//GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;	 

  140. 	//GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;	 //50MHz

  141. 	GPIO_Init(GPIOC, &GPIO_InitStructure);

  142. 

  143. 	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;	   //LCD  RES	   

  144. 	//GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;	 

  145. 	//GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;	 //50MHz

  146. 	GPIO_Init(GPIOC, &GPIO_InitStructure);

  147. 

  148. 	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;	   //LCD  AO 	   

  149. 	//GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;	 

  150. 	//GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;	 //50MHz

  151. 	GPIO_Init(GPIOC, &GPIO_InitStructure);

  152. 	

  153. 	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;	   //LCD  SCK 	   

  154. 	//GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;	 

  155. 	//GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;	 //50MHz

  156. 	GPIO_Init(GPIOC, &GPIO_InitStructure);

  157. 	

  158. 	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12;	   //LCD  SDA 不需要 	   

  159. 	//GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;	 

  160. 	//GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;	 //50MHz

  161. 	GPIO_Init(GPIOC, &GPIO_InitStructure);

  162. 	

  163. 	GPIO_SetBits(GPIOC,GPIO_Pin_0);

  164. 

  165. 	vDispInit(0,24);

  166. 	vDispClear();

  167.    

  168. }

  169. 

  170. void _vWriteIR_spi(u8 ucData);	

  171. void _vWriteData_spi(void);

  172. void (* WriteIR)(u8); //20120502 hong   函数指针，指向 _vWriteIR  或者_vWriteIR_spi

  173. void (* WriteData)(void);				//20120502        函数指针，指向_vWriteData或者_vWriteData_spi

  174. 

  175. #if 0

  176. __inline void IRQEnable(void) 

  177. {

  178. 	int tmp;

  179. 	__asm

  180. 	{

  181.     MRS tmp,CPSR       ///读取CPSR的值

  182.     BIC tmp,tmp,#0x80 //将IRQ中断禁止位I清零,即允许IRQ中断 

  183.     MSR CPSR_c,tmp    //设置CPSR的值

  184. 	}

  185. }

  186. 

  187. 

  188. __inline void IRQDisable(void)

  189. {

  190.     int tmp;

  191. 	

  192.     __asm 

  193.     {

  194.         MRS tmp,CPSR       ///读取CPSR的值

  195.         ORR tmp,tmp,#0x80 //将IRQ中断禁止位I清零,即允许IRQ中断 

  196.         MSR CPSR_c,tmp    //设置CPSR的值

  197.     }

  198. }

  199. #endif

  200. 

  201. #if 0

  202. void SetDISPDATA( u8 DISPDATA )

  203. {

  204.     IO2SET = IO2SET | DISPDATA;

  205.     IO2CLR = (~IO2SET) | ((~DISPDATA) &0x000000ff);

  206. }

  207. #endif

  208. u32 vI2cHzkGetStart( u32 addr /*Int32 addr*/ )

  209. {

  210.     //ulong HfcAdd;

  211. 	u32 HfcAdd;

  212.     HfcAdd = addr >> 8;

  213.     HfcAdd *= 264;

  214.     HfcAdd += (addr & 0xff);

  215.     return ( HfcAdd );

  216. 

  217. }

  218. 

  219. /**************************************************************

  220. 功能 液晶屏写命令函数

  221. 参数 ucData--命令内容

  222. 设计 谢红波

  223. 日期 20080710xiehb

  224. *************************************************************/

  225. void _vWriteIR_spi(u8 ucData)

  226. {

  227. 	u8 i;

  228.     // 关中断

  229. 	ucData = ucData;

  230.     //IRQDisable();

  231.     //SPI1_CE = 0;

  232. 	//P2WPin_HIGH(PIN_LCD_SDA);

  233. 	//LCD_SDA_OUTMODE_SET;

  234. 	GPIO_SetBits(GPIOC,GPIO_Pin_12);

  235. 	//WPin(P2, PIN_LCD_CS0, 0);

  236. 	//LCD_CS0_OUTMODE_CLEAR;

  237. 	GPIO_ResetBits(GPIOC,GPIO_Pin_2);	

  238. 	//P2WPin_LOW(PIN_LCD_DC);

  239. 	//LCD_DC_OUTMODE_CLEAR;

  240. 	GPIO_ResetBits(GPIOC,GPIO_Pin_10);	

  241. 	for ( i = 0; i < 8; i++ )

  242. 	{

  243. 		//P2WPin_LOW(PIN_LCD_SCL);

  244. 		//LCD_SCL_OUTMODE_CLEAR;

  245. 		GPIO_ResetBits(GPIOC,GPIO_Pin_11);

  246. 		if ( (ucData & 0x80) == 0 )

  247. 		{

  248. 			//P2WPin_LOW(PIN_LCD_SDA);

  249. 			//LCD_SDA_OUTMODE_CLEAR;

  250. 			GPIO_ResetBits(GPIOC,GPIO_Pin_12);

  251. 		}

  252. 		else

  253. 		{

  254. 			//P2WPin_HIGH(PIN_LCD_SDA);

  255. 			//LCD_SDA_OUTMODE_SET;

  256. 			GPIO_SetBits(GPIOC,GPIO_Pin_12);

  257. 		}

  258. 		ucData = ucData << 1;

  259. 		//P2WPin_HIGH(PIN_LCD_SCL);

  260. 		//LCD_SCL_OUTMODE_SET;

  261. 		GPIO_SetBits(GPIOC,GPIO_Pin_11);

  262. 	}

  263. 	//WPin(P2, PIN_LCD_CS0, 1);   

  264. 	//LCD_CS0_OUTMODE_SET;

  265. 	GPIO_SetBits(GPIOC,GPIO_Pin_2);

  266. 	//P2WPin_HIGH(PIN_LCD_SDA);

  267. 	//LCD_SDA_OUTMODE_SET;

  268. 	GPIO_SetBits(GPIOC,GPIO_Pin_12);  

  269.     // 开中断 

  270.     //IRQEnable();

  271.     //SPI1_CE = 1;

  272. 

  273. }

  274. 

  275. /**************************************************************

  276. 功能 液晶屏写数据函数

  277. 参数 ucDispDT--数据内容

  278. 设计 谢红波

  279. 日期 20080710xiehb

  280. *************************************************************/

  281. void _vWriteData_spi()

  282. {

  283. 	u8 i;

  284.     // 关中断

  285.     //IRQDisable();

  286. 	//SPI1_CE = 0;

  287. 

  288. 	//P2WPin_HIGH(PIN_LCD_SDA);

  289. 	//LCD_SDA_OUTMODE_SET;

  290. 	GPIO_SetBits(GPIOC,GPIO_Pin_12);

  291. 	//WPin(P2, PIN_LCD_CS0, 0);

  292. 	//LCD_CS0_OUTMODE_CLEAR;

  293. 	GPIO_ResetBits(GPIOC,GPIO_Pin_2);

  294. 

  295. 	//P2WPin_HIGH(PIN_LCD_DC);

  296. 	//LCD_DC_OUTMODE_SET;

  297. 	GPIO_SetBits(GPIOC,GPIO_Pin_10);

  298. 	for ( i = 0; i < 8; i++ )

  299. 	{

  300. 		//P2WPin_LOW(PIN_LCD_SCL);

  301. 		//LCD_SCL_OUTMODE_CLEAR;

  302. 		GPIO_ResetBits(GPIOC,GPIO_Pin_11);		

  303. 		if ( (ucDispDT & 0x80) == 0 )

  304. 		{

  305. 			//P2WPin_LOW(PIN_LCD_SDA);

  306. 			//LCD_SDA_OUTMODE_CLEAR;

  307. 			GPIO_ResetBits(GPIOC,GPIO_Pin_12);

  308. 		}

  309. 		else

  310. 		{

  311. 			//P2WPin_HIGH(PIN_LCD_SDA);

  312. 			//LCD_SDA_OUTMODE_SET;

  313. 			GPIO_SetBits(GPIOC,GPIO_Pin_12);

  314. 		}

  315. 		ucDispDT = ucDispDT << 1;

  316. 		//P2WPin_HIGH(PIN_LCD_SCL);

  317. 		//LCD_SCL_OUTMODE_SET;

  318. 		GPIO_SetBits(GPIOC,GPIO_Pin_11);	

  319. 	}

  320. 	//WPin(P2, PIN_LCD_CS0, 1);    

  321. 	//LCD_CS0_OUTMODE_SET;

  322. 	GPIO_SetBits(GPIOC,GPIO_Pin_2);

  323. 	//P2WPin_HIGH(PIN_LCD_SDA);

  324. 	//LCD_SDA_OUTMODE_SET;

  325. 	GPIO_SetBits(GPIOC,GPIO_Pin_12);

  326. 

  327.     // 开中断 

  328.     //IRQEnable();

  329.     //SPI1_CE = 1;

  330. }

  331. 

  332. 

  333. 

  334. /////////////////////////////////////////////////////////////////////////////////////

  335. //******************************************************************

  336. // 名称: void     _vDispAddr(uchar  ucPage,uchar  ucCol)

  337. // 功能: 设置显示地址

  338. // 输入: ucPage－页地址；ucCol－列地址

  339. // 返回值:

  340. //******************************************************************

  341. void   _vDispAddr(u8  ucPage,u8  ucCol)

  342. {	

  343. #if 0

  344. 	if ( GetMainBoardType () == MAINBOARD_TYPE_GENERAL )

  345. 	{

  346. 		ucCol += 1;

  347. 	}

  348. #endif	

  349. 	(*WriteIR)(0xb0+ucPage);			// 设置页地址

  350. 	

  351. 	(*WriteIR)(0x10+(ucCol >> 4));//modify by  ljc20071017	  // 设置显示开始行高4位

  352. 	(*WriteIR)( ucCol & 0x0f);//modify by  ljc20071017	// 设置显示开始行低4位

  353. }

  354. 

  355. //******************************************************************

  356. // 名称: void     vDispOn()

  357. // 功能: 打开显示

  358. // 输入:

  359. // 返回值:

  360. //******************************************************************

  361. void vDispOn(void)

  362. {

  363.     //have adjust

  364.     (*WriteIR)(0xaf); // 设置打开显示

  365. }

  366. 

  367. //******************************************************************

  368. // 名称: void     vDispClear()

  369. // 功能: 清除整个显示屏

  370. // 输入:

  371. // 返回值:

  372. //******************************************************************

  373. void vDispClear(void)

  374. {

  375.     u8 i,j;

  376. 

  377.     //have adjust

  378.     for ( i = 0; i < 8; i++ )

  379.     {

  380.         ucDispDT = 0;

  381.         _vDispAddr(i, 0);

  382.         for ( j = 0; j < 133; j++ )

  383.         {

  384.             // 128

  385.             (*WriteData)();

  386.         }

  387. 

  388.     }

  389.     (*WriteIR)(0xaf); // 打开显示

  390.     (*WriteIR)(0x2f); // Power   //20070913heq //20071108heq

  391.     

  392. }

  393. 

  394. //******************************************************************

  395. // 名称: void     vDispFull()

  396. // 功能: 整个显示屏

  397. // 输入:

  398. // 返回值:

  399. //******************************************************************

  400. void vDispFull ( void )

  401. {

  402. 	u8 i,j;

  403. 

  404. 	//have adjust

  405. 	for ( i = 0; i < 8; i++ )

  406. 	{

  407. 		_vDispAddr(i, 0);

  408. 		for ( j = 0; j < 133; j++ )

  409. 		{

  410. 			ucDispDT = 0xFF;

  411. 			(*WriteData)();

  412. 		}

  413. 	}

  414. 	(*WriteIR)(0xaf); // 打开显示

  415. 	(*WriteIR)(0x2f); // Power	 //20070913heq //20071108heq

  416. 	

  417. }

  418. 

  419. //#ifdef SPI_LCD_ENABLE //20110704 liugz

  420. /********************************************

  421. SPI屏 初始化

  422. 20080710xiehb

  423. *********************************************/

  424. void  vDispInit_spi(u8 mode,u8 contrast) 

  425. {

  426.    if ( mode )

  427.    {

  428. 	   //LCD_SDA_OUTMODE_SET;

  429. 	   GPIO_SetBits(GPIOC,GPIO_Pin_12);

  430. 	   delay_5us(1);

  431. 	   //LCD_RST_OUTMODE_SET;

  432. 	   GPIO_SetBits(GPIOC,GPIO_Pin_3);

  433. 

  434. 	   //LCD_CS0_OUTMODE_CLEAR;

  435. 	   GPIO_ResetBits(GPIOC,GPIO_Pin_2);

  436. 

  437. 	   //vDelayMS(5);

  438. 	   delay_ms(5);

  439. 	   //LCD_RST_OUTMODE_CLEAR;

  440. 	   GPIO_ResetBits(GPIOC,GPIO_Pin_3);

  441. 

  442. 	   //vDelayMS(30);	

  443. 	   delay_ms(30);

  444. 	   //LCD_RST_OUTMODE_SET;

  445. 	   GPIO_SetBits(GPIOC,GPIO_Pin_3);

  446. 

  447. 	   //vDelayMS(19);

  448. 	   delay_ms(19);

  449.    }

  450.    //LCD_CS0_OUTMODE_CLEAR;

  451.    GPIO_ResetBits(GPIOC,GPIO_Pin_2);

  452. 

  453.    //LCD_SDA_OUTMODE_SET;

  454.    GPIO_SetBits(GPIOC,GPIO_Pin_12);

  455. 

  456.    //LCD_RST_OUTMODE_SET;

  457.    GPIO_SetBits(GPIOC,GPIO_Pin_3);

  458. 

  459.    (*WriteIR)(0xe2);

  460.    delay_ms(10);

  461.    (*WriteIR)(0xa2); 						/* 1/9bias */

  462.    (*WriteIR)(0xa0); 						/* ADC select , Normal */

  463.    (*WriteIR)(0xc8); 						/* Common output reverse */

  464.    (*WriteIR)(0xa6); 						/* normal display 1=on */

  465. #if 0

  466.    if ( GetMainBoardType () != MAINBOARD_TYPE_GENERAL )

  467.    {

  468.    	  (*WriteIR)(0x2C); 

  469. 	  DeyNop(10);

  470. 	  (*WriteIR)(0x2E); 

  471. 	  DeyNop(10);

  472.    }

  473. #endif

  474.    (*WriteIR)(0x2F); 						/* V/C off, V/R off, V/F on */

  475.    //DeyNop(10);

  476.    delay_5us(2);

  477.    (*WriteIR)(0xf8); 						/* Common output reverse */

  478.    (*WriteIR)(0x01); 						/* normal display 1=on */

  479.    //(*WriteIR)(0x2F); 						/* V/C off, V/R off, V/F on */

  480.    (*WriteIR)(0x24); 						/* internal resistor ratio */

  481. #if 0

  482.    if ( contrast > MAX_CONTRAST )

  483.    {

  484. 	  contrast = 0x24;

  485.    }

  486.    if ( contrast < MIN_CONTRAST )

  487.    {

  488. 	  contrast = 0x24;	

  489.    }

  490. #else

  491. 	contrast = 0x27;   //24

  492. #endif   

  493.    (*WriteIR)(0x81); 						/* electronic volume mode set */	

  494.    (*WriteIR)(contrast);                    /*0x31*/

  495.    (*WriteIR)(0xaf); 						/* display on */

  496.    (*WriteIR)(0x40); 						/* Start line Set 40-7fh  默认40 */ //20110720 liugz  //60

  497. }

  498. 

  499. ///20120925 hong 智能识别屏

  500. void  vDispInit( u8 mode,u8 contrast )

  501. {

  502. 	WriteIR = _vWriteIR_spi;

  503. 	WriteData = _vWriteData_spi;

  504. 	vDispInit_spi(mode,contrast);

  505. }

  506. 

  507. #if 1

  508. /*****************************************************************

  509. 函数：E_MAINBOARD_TYPE GetMainBoardType ( void )

  510. 功能：主板类型

  511. 参数：

  512. 注意：

  513. 设计：吴伟聪

  514. 时间：2014.06.28

  515. 返回：

  516. ******************************************************************/

  517. void  SetLcdRow ( u8 * ucRow )

  518. {

  519. 	//if ( GetMainBoardType () != MAINBOARD_TYPE_GENERAL )

  520. 	{

  521. 		if ( *ucRow < 3 )

  522. 		{

  523. 			*ucRow += 2;

  524. 		}

  525. 		else

  526. 		{

  527. 			*ucRow -= 2;

  528. 		}

  529. 	}

  530. }

  531. #endif

  532. 

  533. //******************************************************************

  534. // 名称: void     vDispClearLine(uchar  ucRow)

  535. // 功能: 清除LCD屏的一行

  536. // 输入: ucRow－行号

  537. // 返回值:

  538. //******************************************************************

  539. void vDispClearLine(u8 ucRow)

  540. {

  541.     u8 i,j;

  542. 

  543.     SetLcdRow(&ucRow);

  544. 	

  545.     if ( --ucRow >= 4 )

  546.     {

  547.         return ;

  548.     }

  549. 	

  550.     ucRow += ucRow;

  551.     for ( i = 0; i < 2; i++ )

  552.     {

  553.         _vDispAddr(ucRow, 0);

  554.         ucDispDT = 0;

  555.         for ( j = 0; j < 128; j++ )

  556.         {

  557.             (*WriteData)();

  558.         }

  559.         _vDispAddr(ucRow + 1, 0);

  560.         ucDispDT = 0;

  561.         for (j = 0; j < 128; j++)

  562.         {

  563.             (*WriteData)();

  564.         }

  565.     }

  566. }

  567. 

  568. void Display_Icon16(u8 ucRow, u8 ucCol, unsigned char *icon)

  569. {

  570. 	u8 pZiMo;

  571. 

  572. 	SetLcdRow(&ucRow);

  573. 	

  574. 	if ( --ucRow >= 4 )

  575. 	{

  576. 		return ;

  577. 	}

  578. 	if ( --ucCol > 16 )

  579. 	{

  580. 		return ;

  581. 	}

  582. 

  583. 	ucRow += ucRow;

  584. 	ucCol <<= 3; 

  585. 

  586. 	_vDispAddr(ucRow, ucCol);

  587. 	ucDispDT = 0x00;

  588. 	for ( pZiMo = 0; pZiMo < 8; pZiMo++ )

  589. 	{

  590. 		if ( icon != 0 )

  591. 		{

  592. 			ucDispDT = icon[pZiMo];

  593. 		}

  594. 		(*WriteData)();

  595. 	}

  596. 	

  597. 	_vDispAddr(ucRow+1, ucCol);

  598. 	for ( ; pZiMo < 16; pZiMo++ )

  599. 	{

  600. 		if ( icon != 0 )

  601. 		{

  602. 			ucDispDT = icon[pZiMo];

  603. 		}

  604. 		(*WriteData)();

  605. 	}

  606. 

  607.     (*WriteIR)(0xaf);     // 打开显示//20070913heq

  608.     (*WriteIR)(0x2f);     // Power   //20070913heq

  609. }

  610. 

  611. void Display_Icon(u8 ucRow, u8 ucCol, unsigned char *icon,u8 size)

  612. {

  613. 	u8 pZiMo;

  614. 

  615. 	SetLcdRow(&ucRow);

  616. 	

  617. 	if ( --ucRow >= 4 )

  618. 	{

  619. 		return ;

  620. 	}

  621. 	if ( --ucCol >= 16 )

  622. 	{

  623. 		return ;

  624. 	}

  625. 

  626. 	ucRow += ucRow;

  627. 	ucCol <<= 3; 

  628. 

  629. 	_vDispAddr(ucRow, ucCol);

  630. 	ucDispDT = 0x00;

  631. 	//for ( pZiMo = 0; pZiMo < 16; pZiMo++ )

  632. 	for ( pZiMo = 0; pZiMo < size; pZiMo++ )

  633. 	{

  634. 		if ( icon != 0 )

  635. 		{

  636. 			ucDispDT = icon[pZiMo];

  637. 		}

  638. 		(*WriteData)();

  639. 	}

  640. 

  641. 	_vDispAddr(ucRow + 1, ucCol);

  642. 	//for ( ; pZiMo < 32; pZiMo++ )

  643. 	for ( ; pZiMo < (2*size); pZiMo++ )

  644. 	{

  645. 		if ( icon != 0 )

  646. 		{

  647. 			ucDispDT = icon[pZiMo];

  648. 		}

  649. 		(*WriteData)();

  650. 	}

  651. 

  652.     (*WriteIR)(0xaf);     // 打开显示//20070913heq

  653.     (*WriteIR)(0x2f);     // Power   //20070913heq

  654. }

  655. 

  656. #if 0

  657. ///AntiColor = 1   反式显示

  658. ///AntiColor = 0   正常显示

  659. void vDispStr_light(u8 ucRow, u8 ucCol, char *szData, u8 AntiColor)

  660. {

  661. 	u8 ZiMo[32], pZiMo;

  662. 	u8 ucDispT1, ucDispT2, ucDispT4;

  663. 	u32  uiDispT;

  664. 	u32  uiDispT1;

  665. 

  666. 	//SetMayWatchDog();

  667. 	IWDG_Feed();

  668. 

  669. 	//SetLcdRow(&ucRow);

  670. 	

  671.     if ( --ucRow >= 4 )

  672.     {

  673.         return ;

  674.     }

  675.     if ( --ucCol >= 16 )

  676.     {

  677.         return ;

  678.     }

  679. 	

  680.     ucRow += ucRow;

  681.     ucCol <<= 3; // *8

  682.     while ( (*szData != 0) && (ucCol < 128) )

  683.     {

  684.         ucDispT1 = *szData;

  685.         szData++;

  686.         if ( ucDispT1 == 0xff )

  687.         {

  688.             return ;

  689.         }

  690. 		

  691.         //没有0XFF开始的汉字

  692.         if ( ucDispT1 < 0x80 )

  693.         {

  694.             //ASC

  695.             uiDispT = ucDispT1 << 4;

  696.             //uiDispT <<= 4;

  697.             pZiMo = 0;

  698.             vI2cRead(vI2cHzkGetStart( uiDispT + 222080l),16,(char *)ZiMo);

  699. 

  700.             _vDispAddr(ucRow, ucCol);

  701. 			if ( AntiColor )

  702. 			{

  703.                 for ( ucDispT4 = 0; ucDispT4 < 8; ucDispT4++ )

  704.                 {

  705.                     ucDispDT = ZiMo[pZiMo++] ^ 0xFF;

  706.                     (*WriteData)();

  707.                 }

  708. 

  709.                 _vDispAddr(ucRow + 1, ucCol);

  710.                 for ( ucDispT4 = 8; ucDispT4 < 16; ucDispT4++ )

  711.                 {

  712.                     ucDispDT = ZiMo[pZiMo++] ^ 0xFF;

  713.                     (*WriteData)();

  714.                 }

  715. 			}

  716. 			else

  717. 			{

  718.                 for ( ucDispT4 = 0; ucDispT4 < 8; ucDispT4++ )

  719.                 {

  720.                     ucDispDT = ZiMo[pZiMo++];

  721.                     (*WriteData)();

  722.                 }

  723. 

  724.                 _vDispAddr(ucRow + 1, ucCol);

  725.                 for ( ucDispT4 = 8; ucDispT4 < 16; ucDispT4++ )

  726.                 {

  727.                     ucDispDT = ZiMo[pZiMo++];

  728.                     (*WriteData)();

  729.                 }

  730. 			}

  731.             ucCol += 8;

  732.         }

  733.         else

  734.         {

  735.             ucDispT2 =  *szData;

  736.             szData++;

  737.             if ( ucCol > 112 )

  738.             {

  739.                 break;

  740.             }

  741.             if ( ucDispT1 >= 0xB0 )

  742.             {

  743.                 //B0A1~F7FF

  744.                 ucDispT1 -= 0xAE;

  745.             }

  746.             else if ( ucDispT1 == 0xA1 )

  747.             {

  748.                 //A1A1~A1FF

  749.                 ucDispT1 = 0;

  750.             }

  751.             else if ( ucDispT1 == 0xA3 )

  752.             {

  753.                 //A3A1~A3FF

  754.                 ucDispT1 = 1;

  755.             }

  756.             else

  757.             {

  758.                 continue;

  759.             }

  760.             ucDispT2 -= 0xA1;

  761. 

  762.             ucDispT1 <<= 1; //*2;   47

  763.             uiDispT = ucDispT1 << 4;

  764.             uiDispT1 = uiDispT;

  765.             uiDispT <<= 1;

  766.             uiDispT += uiDispT1;

  767.             uiDispT -= ucDispT1;

  768.             uiDispT += ucDispT2;

  769.             pZiMo = 0;

  770.             vI2cRead(vI2cHzkGetStart(uiDispT<<5),32,(char *)ZiMo);

  771. 

  772.             _vDispAddr(ucRow, ucCol);

  773. 			if ( AntiColor )

  774. 			{

  775.                 for ( ucDispT4 = 0; ucDispT4 < 8; ucDispT4++ )

  776.                 {

  777.                     ucDispDT = ZiMo[pZiMo++] ^ 0xFF;

  778.                     (*WriteData)();

  779.                 }

  780. 			}

  781. 			else

  782. 			{

  783.                 for ( ucDispT4 = 0; ucDispT4 < 8; ucDispT4++ )

  784.                 {

  785.                     ucDispDT = ZiMo[pZiMo++];

  786.                     (*WriteData)();

  787.                 }

  788. 			}

  789.             if ( ucCol < 56 )

  790.             {

  791. 				if ( AntiColor )

  792. 				{

  793. 	                for ( ucDispT4 = 8; ucDispT4 < 16; ucDispT4++ )

  794. 	                {

  795. 	                    ucDispDT = ZiMo[pZiMo++] ^ 0xFF;

  796. 	                    (*WriteData)();

  797. 	                }

  798. 				}

  799. 				else

  800. 				{

  801. 	                for ( ucDispT4 = 8; ucDispT4 < 16; ucDispT4++ )

  802. 	                {

  803. 	                    ucDispDT = ZiMo[pZiMo++];

  804. 	                    (*WriteData)();

  805. 	                }

  806. 				}

  807.             }

  808.             else

  809.             {

  810.                 if ( ucCol == 56 )

  811.                 {

  812.                     _vDispAddr(ucRow, 64);

  813.                 }

  814. 				if ( AntiColor )

  815. 				{

  816. 	                for ( ucDispT4 = 8; ucDispT4 < 16; ucDispT4++ )

  817. 	                {

  818. 	                    ucDispDT = ZiMo[pZiMo++] ^ 0xFF;

  819. 	                    (*WriteData)();

  820. 	                }

  821. 				}

  822. 				else

  823. 				{

  824. 	                for ( ucDispT4 = 8; ucDispT4 < 16; ucDispT4++ )

  825. 	                {

  826. 	                    ucDispDT = ZiMo[pZiMo++];

  827. 	                    (*WriteData)();

  828. 	                }

  829. 				}

  830.             }

  831.             _vDispAddr(ucRow + 1, ucCol);

  832. 			if ( AntiColor )

  833. 			{

  834.                 for ( ucDispT4 = 16; ucDispT4 < 24; ucDispT4++ )

  835.                 {

  836.                     ucDispDT = ZiMo[pZiMo++] ^ 0xFF;

  837.                     (*WriteData)();

  838.                 }

  839. 			}

  840. 			else

  841. 			{

  842.                 for ( ucDispT4 = 16; ucDispT4 < 24; ucDispT4++ )

  843.                 {

  844.                     ucDispDT = ZiMo[pZiMo++];

  845.                     (*WriteData)();

  846.                 }

  847. 			}

  848.             if ( ucCol < 56 )

  849.             {

  850. 				if ( AntiColor )

  851. 				{

  852. 	                for ( ucDispT4 = 24; ucDispT4 < 32; ucDispT4++ )

  853. 	                {

  854. 	                    ucDispDT = ZiMo[pZiMo++] ^ 0xFF;

  855. 	                    (*WriteData)();

  856. 	                }

  857. 				}

  858. 				else

  859. 				{

  860. 	                for ( ucDispT4 = 24; ucDispT4 < 32; ucDispT4++ )

  861. 	                {

  862. 	                    ucDispDT = ZiMo[pZiMo++];

  863. 	                    (*WriteData)();

  864. 	                }

  865. 				}

  866.             }

  867.             else

  868.             {

  869.                 if ( ucCol == 56 )

  870.                 {

  871.                     _vDispAddr(ucRow + 1, 64);

  872.                 }

  873. 				if ( AntiColor )

  874. 				{

  875. 	                for ( ucDispT4 = 24; ucDispT4 < 32; ucDispT4++ )

  876. 	                {

  877. 	                    //vI2cGetHzk();

  878. 	                    ucDispDT = ZiMo[pZiMo++] ^ 0xFF;

  879. 	                    (*WriteData)();

  880. 	                }

  881. 				}

  882. 				else

  883. 				{

  884. 	                for ( ucDispT4 = 24; ucDispT4 < 32; ucDispT4++ )

  885. 	                {

  886. 	                    //vI2cGetHzk();

  887. 	                    ucDispDT = ZiMo[pZiMo++];

  888. 	                    (*WriteData)();

  889. 	                }

  890. 				}

  891.             }

  892.             ucCol += 16;

  893.         }

  894.     }

  895.     (*WriteIR)(0xaf);     // 打开显示//20070913heq  //20071108heq

  896.     (*WriteIR)(0x2f);     // Power   //20070913heq //20071108heq

  897. }

  898. 

  899. void vDispStr(u8 ucRow, u8 ucCol, char *szData)

  900. {

  901. 	vDispStr_light(ucRow,ucCol,szData,0);

  902. }

  903. #else

  904. void vDispStr(u8 ucRow, u8 ucCol, char *szData,unsigned char datalen)

  905. {

  906. 	u16 i;

  907. 	u16 temHz;

  908. 	u8 buf[16];

  909. 	if(datalen<=0)

  910. 	{

  911. 		return ;

  912. 	}		

  913. 	for(i=0;i<datalen;)

  914. 	{	   

  915. 		temHz = *(szData+i);

  916. 		i +=1;

  917. 		Get_8x16_Font(temHz,buf);

  918. 		Display_Icon(ucRow,ucCol,buf,8);

  919. 		ucCol += 1;

  920. 	}

  921. 

  922. }

  923. 

  924. 

  925. #endif