Category

Development Platform
Home > SourceCode/Document > Multimedia program > DVD > View Code
led.c
Package: ST_5105DTV.rar　[view]
Upload User: fy98168
Upload Date: 2015-06-26
Package Size: 13771k
Code Size: 16k
Category:

DVD

Development Platform:

C/C++

led.c：Code Content
  1. /****************************************************************************
  2. ** Notice: Copyright (c) 2007 Keybridge Co.Ltd. - All Rights Reserved
  3. **
  4. ** File Name: led.C
  5. **
  6. **
  7. **
  8. **
  9. ** Description:
  10. ** GPIO Driver source file.
  11. **
  12. ****************************************************************************/
  13. #include "stpio.h"
  14. #include "sti5105.h"
  15. #include "stddefs.h"
  16. #include "gendef.h"
  17. #include "rckeymap.h"
  18. #include "timeclk.h"
  19. #include "Sr_time.h"
  20. #include "led.h"
  21. #include "kb_machblue_client_task.h"
  23. static volatile unsigned int *PIO0_BASE = (volatile unsigned int *)0x20820000;
  24. static volatile unsigned int *PIO1_BASE = (volatile unsigned int *)0x20821000;
  25. static volatile unsigned int *PIO2_BASE = (volatile unsigned int *)0x20822000;
  26. static volatile unsigned int *PIO3_BASE = (volatile unsigned int *)0x20823000;
  28. #define PIO_OUT 0 
  29. #define PIO_OUT_SET (1 << 2)
  30. #define PIO_OUT_CLR (2 << 2)
  31. #define PIO_IN (4 << 2)
  33. #define PIO_BIT_0    1
  34. #define PIO_BIT_1    2
  35. #define PIO_BIT_2    4
  36. #define PIO_BIT_3    8
  37. #define PIO_BIT_4    16
  38. #define PIO_BIT_5    32
  39. #define PIO_BIT_6    64
  40. #define PIO_BIT_7    128
  42. #define PIO0(x, value)
  43. {
  44. if (value)
  45. PIO0_BASE[PIO_OUT_CLR] &= ~(1 << x);
  46. else
  47. PIO0_BASE[PIO_OUT_CLR] |= (1 << x);
  48. }
  49. #define PIO1(x, value)
  50. {
  51. if (value)
  52. PIO1_BASE[PIO_OUT_CLR] &= ~(1 << x);
  53. else
  54. PIO1_BASE[PIO_OUT_CLR] |= (1 << x);
  55. }
  56. #define PIO2(x, value)
  57. {
  58. if (value)
  59. PIO2_BASE[PIO_OUT_CLR] &= ~(1 << x);
  60. else
  61. PIO2_BASE[PIO_OUT_CLR] |=(1 << x);
  62. }
  63. #define PIO3(x, value)
  64. {
  65. if (value)
  66. PIO3_BASE[PIO_OUT_CLR] &= ~(1 << x);
  67. else
  68. PIO3_BASE[PIO_OUT_CLR] |= (1 << x);
  69. }
  72. #define FPIO_CLK(value) PIO2(7, value)
  73. #define FPIO_DATA(value) PIO0(1, value)
  75. #define FPIO_COM0(value) PIO2(2, value)
  76. #define FPIO_COM1(value) PIO2(3, value)
  77. #define FPIO_COM2(value) PIO2(5, value)
  78. #define FPIO_COM3(value) PIO2(6, value)
  80. #define FPIO_LOCK(value) PIO3(4, value)
  81. //#define FPIO_POWER(value)        PIO3(4, value)
  82. //#define FPIO_KYESCAN PIO_BIT_7
  84. //#define READ_KEY_BITS (*(PIO3_BASE + PIO_IN) & FPIO_KYESCAN)
  85. #define READ_KEY_BITS (*(PIO0_BASE + 4) & PIO_BIT_6)
  87. #define KEYBOARD_BOUNCE_SETTLE_TIME  (ST_GetClocksPerSecond()/ 10) /* 100 mSec */
  88. #define KEYBOARD_SCAN_LINE_SETTLE_TIME  (ST_GetClocksPerSecond() / 1000) /* 1 mSec */
  89. #define KEYBOARD_SCAN_FREQ 100 /*** 1000s/(5ms*100) = 2Hz ***/
  92. static UINT32 LED_TaskID;
  93. void FP_KeyCheck(void);
  95. //static char iLedData[4] = {0xBF, 0xBF, 0xBF, 0xBF};
  96. static char iLedData[4] = {0xC0, 0xC0, 0xC0, 0xC0};
  99. unsigned short KeyBuffer = 0;
  101. #define LED_DISP_CHAR_MAX 32
  102. T_LED_CODE LED_CODE[LED_DISP_CHAR_MAX] = 
  103. {
  104. {'M', 0xff}, /* 00 */  
  105. {'1', 0xF9}, /* 01 */  
  106. {'2', 0xA4}, /* 02 */  
  107. {'3', 0xB0}, /* 03 */  
  108. {'4', 0x99}, /* 04 */  
  109. {'5', 0x92}, /* 05 */  
  110. {'6', 0x82}, /* 06 */  
  111. {'7', 0xD8}, /* 07 */  
  112. {'8', 0x80}, /* 08 */  
  113. {'9', 0x90}, /* 09 */  
  114. {'0', 0xC0}, /* 10 */  
  115. {'A', 0x88}, /* 11 */  
  116. {'b', 0x83}, /* 12 */  
  117. {'C', 0xC6}, /* 13 */  
  118. {'c', 0xA7}, /* 14 */  
  119. {'d', 0xA1}, /* 15 */  
  120. {'E', 0x86}, /* 16 */  
  121. {'F', 0x8e}, /* 17 */  
  122. {'H', 0x89}, /* 18 */  
  123. {'h', 0x8B}, /* 19 */  
  124. {'J', 0xf0}, /* 20 */  
  125. {'L', 0xc7}, /* 21 */  
  126. {'n', 0xAB}, /* 22 */  
  127. {'O', 0xc0}, /* 23 */  
  128. {'o', 0xA3}, /* 24 */  
  129. {'P', 0x8C}, /* 25 */  
  130. {'q', 0x98}, /* 26 */ 
  131. {'r', 0xaf}, /* 27 */  
  132. {'t', 0x87}, /* 28 */  
  133. {'U', 0xc1}, /* 29 */  
  134. {'v', 0xE3}, /* 30 */  
  135. {'-', 0xBF} /* 31 */
  136. };
  139. void LED_PioComSet(UINT8 comNum, char value)
  140. {
  141. switch (comNum)
  142. {
  143. case 0:
  144. FPIO_COM0(value);
  145. break;
  147. case 1:
  148. FPIO_COM1(value);
  149. break;
  151. case 2:
  152. FPIO_COM2(value);
  153. break;
  155. case 3:
  156. FPIO_COM3(value);
  157. break;
  159. default:
  160. break;
  161. }
  162. }
  165. /*========================================================================= 
  166.  * PROTOTYPE :  
  167.  * void LED_LedGreen(int flag)
  168.  * 
  169.  * PURPOSE:
  170.  * on/of the green led
  171.  *==========================================================================*/
  172. void LED_LedGreen(int flag)
  173. {
  174. if (flag)
  175. {
  176. /* 亮*/
  177. FPIO_LOCK(1);
  178.      //PIO3_BASE[8]  |= 4; 
  179. }
  180. else
  181. {
  182. /* 灭*/
  183. FPIO_LOCK(0);
  184. //PIO3_BASE[8]  &= ~4;
  185. }
  186. }
  188. /*========================================================================= 
  189.  * PROTOTYPE :  
  190.  * void LED_DispDataSet(char *dispStr)
  191.  * 
  192.  * PURPOSE:
  193.  * get the ASC2 value.
  194.  *==========================================================================*/
  195. void LED_DispDataSet(char *dispStr)
  196. {
  197. unsigned char ucLEDData ;
  198. unsigned char i, iLedNo;
  200. for (iLedNo=0; iLedNo<4; iLedNo++)
  201. {
  202. ucLEDData = dispStr[iLedNo];
  203. i = 0;
  204. while (1)
  205. {
  206. if (LED_CODE[i].show_code == ucLEDData)
  207. {
  208. iLedData[iLedNo] = LED_CODE[i].led_code;
  209. break;
  210. }
  212. if (i++ >= LED_DISP_CHAR_MAX)
  213. {
  214. //printf("nr===the char not found:%d ,error!!!", ucLEDData);
  215. iLedData[iLedNo] = 0xff;
  216. break;
  217. }
  218. }
  219. }
  220. }
  222. /*========================================================================= 
  223.  * PROTOTYPE :  
  224.  * void LED_ShowNum(int i )
  225.  * 
  226.  * PURPOSE:
  227.  * Show Number
  228.  *==========================================================================*/
  229. void LED_ShowNum(int i)
  230. {
  231. char str[10];
  233. //str[3] = (i)%10;
  234. //str[2] = (i/10)%10;
  235. //str[1] = (i/100)%10;
  236. //str[0] = (i/1000)%10;
  237. memset(str, 0x00, 10);
  238. sprintf(str, "%d", i);
  240. LED_DispDataSet(str);
  241. }
  243. /*========================================================================= 
  244.  * PROTOTYPE :  
  245.  * void LED_ShowString(char *str)
  246.  * 
  247.  * PURPOSE:
  248.  * Show String
  249.  *==========================================================================*/
  250. void LED_ShowString(char *str)
  251. {
  252. LED_DispDataSet(str);
  253. }
  256. /*========================================================================= 
  257.  * PROTOTYPE :  
  258.  * void LED_ShowTime()
  259.  * 
  260.  * PURPOSE:
  261.  * Display system time
  262.  *==========================================================================*/
  263. void LED_ShowTime()
  264. {
  265. time_t  plTime;
  266. char out[8];
  267. char dispStr[4];
  268. U8 i;
  270. KB_TimeGetCurTime(&plTime);
  271. ConvertTimeStampToTimeString((U32)plTime, out);
  273. dispStr[0] = out[0];
  274. dispStr[1] = out[1];
  275. dispStr[2] = out[3];
  276. dispStr[3] = out[4];
  277. LED_DispDataSet(dispStr);
  279. for (i=0; i<4; i++)
  280. {
  281. iLedData[i] &= 0x7F;
  282. }
  283. }
  286. /*========================================================================= 
  287.  * PROTOTYPE :  
  288.  * void LEDProcess(void)
  289.  * 
  290.  * PURPOSE:
  291.  * Led driver & display process
  292.  *==========================================================================*/
  293. #if 1//ndef IO_USE_API
  294. void LEDProcess(void)
  295. {
  296. static U8 DigitSelected = 0;
  297. static U8 oldDigitSelected = 0;
  298. static U16 LedDotShineCount = 0;
  299. static U8 LedDotFlag = 0;
  300. U8 i=0;
  301. U8 ledCode;
  303. #if 1
  304. ledCode = iLedData[DigitSelected];
  306. if((ledCode & 0x80) == 0) /* disp. time */
  307. {
  308. LedDotShineCount++;
  309. if(LedDotShineCount == 250)
  310. {
  311. LedDotShineCount = 0;
  312. LedDotFlag = 1-LedDotFlag;
  313. }
  314. }
  316. if (LedDotFlag)
  317. {
  318. ledCode |= 0x80;
  319. }
  321. /* 1. clear the led display */
  322. LED_PioComSet(oldDigitSelected, 0);
  324. if (ledCode != 0xff)
  325. {
  326. /* 2. send the data to segment */
  327. FPIO_CLK(1);
  328. for (i=0; i<8; i++)
  329. {
  330. if (((0x80>>i) & ledCode) != 0)
  331. {
  332. FPIO_DATA(1);
  334. FPIO_CLK(0);
  335. FPIO_CLK(1);
  336. }
  337. else
  338. {
  339. FPIO_DATA(0);
  341. FPIO_CLK(0);
  342. FPIO_CLK(1);
  343. }
  344. task_delay(1); /* Very important here, can't be deleted */
  345. }
  347. /* 3. Display it */
  348. LED_PioComSet(DigitSelected, 1);
  349. }
  351. oldDigitSelected = DigitSelected;
  352. if (++DigitSelected > 3)
  353. {
  354. DigitSelected = 0 ;
  355. }
  356. #else
  357. /*1. clear all the led display*/
  358. PIO2_BASE[PIO_OUT_CLR]  |= PIO_BIT_2; 
  359. PIO2_BASE[PIO_OUT_CLR]  |= PIO_BIT_3; 
  360. PIO2_BASE[PIO_OUT_CLR]  |= PIO_BIT_5; 
  361. PIO2_BASE[PIO_OUT_CLR]  |= PIO_BIT_6; 
  363. if (++ucLEDNo > 3)
  364. {
  365. ucLEDNo = 0 ;
  366. }
  367. ucLEDData = LED_font[iLedData[ucLEDNo]] ;
  369. PIO2_BASE[PIO_OUT_CLR]  &= ~PIO_BIT_7; 
  371. for(i=0;i<8;i++)
  372. {
  373. if(((test_value>>i)&ucLEDData)!=0)
  374. {
  375. PIO0_BASE[PIO_OUT_CLR]  &= ~PIO_BIT_1; 
  377. PIO2_BASE[PIO_OUT_CLR]  |= PIO_BIT_7; 
  378. PIO2_BASE[PIO_OUT_CLR]  &= ~PIO_BIT_7; 
  379. }
  380. else
  381. {
  382. PIO0_BASE[PIO_OUT_CLR]  |= PIO_BIT_1; 
  384.              PIO2_BASE[PIO_OUT_CLR]  |= PIO_BIT_7; 
  385.              PIO2_BASE[PIO_OUT_CLR]  &= ~PIO_BIT_7; 
  386. }
  387. task_delay(1);
  388. }
  390. /*3.Display it*/
  391. switch (ucLEDNo)
  392. {
  393. case 0:
  394. PIO2_BASE[PIO_OUT_CLR]  &= ~PIO_BIT_2; 
  395. break;
  397. case 1:
  398. PIO2_BASE[PIO_OUT_CLR]  &= ~ PIO_BIT_3; 
  399. break;
  401. case 2:
  402. PIO2_BASE[PIO_OUT_CLR]  &= ~PIO_BIT_5; 
  403. break;
  405. case 3:
  406. PIO2_BASE[PIO_OUT_CLR]  &= ~PIO_BIT_6; 
  407. break;
  408. }
  409. #endif
  410. }
  414. #else
  415. STPIO_Handle_t   PIO0Handle = (STPIO_Handle_t)NULL ; /*PIO0Handle STPCM_ResetCIchip*/
  416. STPIO_Handle_t     PIO1Handle = (STPIO_Handle_t)NULL ; /*Flash Protect*/
  417. STPIO_Handle_t     PIO3Handle = (STPIO_Handle_t)NULL ; /*Led data and clock*/
  418. STPIO_Handle_t     PIO2Handle = (STPIO_Handle_t)NULL ; /*Led data and clock*/
  419. STPIO_Handle_t     PIO4Handle = (STPIO_Handle_t)NULL ; /*led select bit,Diseqc,LNB Over,LNB On/Off,H/V*/
  420. STPIO_Handle_t     PIO5Handle = (STPIO_Handle_t)NULL ; /*led select bit,Diseqc,LNB Over,LNB On/Off,H/V*/
  421. void LEDProcess(void)
  422. {
  423. ST_ErrorCode_t   error ;
  424. static BYTE      ucLEDNo = 1 ;
  425. BYTE             ucLEDData ;
  426. int              iLED_Bit_Count ;
  427. const unsigned char LED_font [ 39 ] =
  428. { 
  429. 0x18, 0xdb, 0x2a, 0x4a, 0xc9,
  430. 0x4c, 0x0c, 0xda, 0x08, 0x48,
  431. 0xa8, 0xef, 0x7f, 0xff,
  432. 0xef,0xad,0x2c,0x8f,0x0b,0x09,0x88,0xbc,0xac,
  433. 0xfe,  0xef, 0x7f, 0xbd, 0xdb, 0xf7, 
  434. 0x18&0xf7, 0xdb&0xf7, 0x2a&0xf7, 0x4a&0xf7, 0xc9&0xf7,
  435. 0x4c&0xf7, 0x0c&0xf7, 0xda&0xf7, 0x08&0xf7, 0x48&0xf7,
  436. };
  438. error =  STPIO_Set(PIO3Handle, PIO_BIT_2);
  439. printf("STPIO_Set========n");
  440. task_delay(30000000);
  441. STPIO_Clear( PIO3Handle, PIO_BIT_2);
  442. #if 0
  443. /*1. clear all the led display*/
  444. error =  STPIO_Set( PIO4Handle, FP_SELECT0 );
  445. error |= STPIO_Set( PIO4Handle, FP_SELECT1 );
  446. error |= STPIO_Set( PIO4Handle, FP_SELECT2 );
  447. error |= STPIO_Set( PIO4Handle, FP_SELECT3 );
  448. if ( error != ST_NO_ERROR )
  449. {
  450. STTBX_Print(("STPIO_Set errorn"));
  451. }
  452. if( ++ucLEDNo > 3 )
  453. ucLEDNo = 0 ;
  454. ucLEDData = LED_font[ iLedData[ ucLEDNo ] ] ;
  456. for(iLED_Bit_Count = 8;iLED_Bit_Count > 0;iLED_Bit_Count--) 
  457. {
  458. error  =  STPIO_Set( PIO2Handle, FP_DATA );
  459. error |=  STPIO_Set( PIO2Handle, FP_CLK );
  460. error |=  STPIO_Clear(PIO2Handle, FP_CLK );
  461. }
  462. for( iLED_Bit_Count = 8; iLED_Bit_Count > 0; iLED_Bit_Count--)
  463. {
  464. if ( ucLEDData & 0x80 )
  465. error =  STPIO_Set( PIO2Handle, FP_DATA );
  466. else
  467. error =  STPIO_Clear(PIO2Handle, FP_DATA );
  469. error  =  STPIO_Set( PIO2Handle,  FP_CLK );
  470. error |=  STPIO_Clear(PIO2Handle, FP_CLK );
  471. ucLEDData <<= 1;
  472. }
  473. /*3.Display it*/
  474. switch ( ucLEDNo )
  475. {
  476. case 0:
  477. error =  STPIO_Clear( PIO4Handle, FP_SELECT2 );
  478. break;
  479. case 1:
  480. error =  STPIO_Clear( PIO4Handle, FP_SELECT0 );
  481. break;
  482. case 2:
  483. error =  STPIO_Clear( PIO4Handle, FP_SELECT1 );
  484. break;
  485. case 3:
  486. error =  STPIO_Clear( PIO4Handle, FP_SELECT3 );
  487. break;
  488. }
  489. #endif
  490. }
  492. void SEGInit(void)
  493. {
  494. ST_ErrorCode_t        error;
  495. STPIO_OpenParams_t OpenParams;
  497. OpenParams.ReservedBits = PIO_BIT_2; 
  498. OpenParams.BitConfigure[2] = STPIO_BIT_OUTPUT; 
  499. OpenParams.IntHandler = NULL;
  500.    error = STPIO_Open("PIO3", &OpenParams, &PIO3Handle) ;
  501.    if ( error != ST_NO_ERROR )
  502.    {
  503.    printf("ERROR: SEGInitn");
  504.    }
  505.   
  506. }
  507. #endif
  509. #if 0 //WT, test pio STAPI
  510. #define PIO_NUM              3       /*PIO3 */
  511. #define PIO_BIT                 PIO_BIT_2        /*pin 2 */
  512. #define PIO_TYPE             STPIO_BIT_OUTPUT
  513. extern ST_DeviceName_t PIO_DeviceName[] ;
  514. static ST_ErrorCode_t PIO_TestHL(void)
  515. {
  516. ST_ErrorCode_t error;
  518. static STPIO_Handle_t TnrResetHandle;
  520. STPIO_OpenParams_t OpenParams;
  521. ///ST_DeviceName_t PIO_DeviceName[] = {"PIO0","PIO1","PIO2","PIO3"};
  522. static int init_flag=0;
  526. if (init_flag == 0)
  527. {
  528. OpenParams.ReservedBits = PIO_BIT;
  529. OpenParams.BitConfigure[3] = PIO_TYPE;
  530. OpenParams.IntHandler = NULL;
  532. error = STPIO_Open(PIO_DeviceName[PIO_NUM], &OpenParams, &TnrResetHandle);
  534. if(error != ST_NO_ERROR)
  535. {
  536. STTBX_Print(("Error!! STPIO_Open: %dn", (error)));
  537. return error;
  538. }
  539. init_flag = 1;
  540.          }
  542. printf("nr Green led  PIO_TestHL  nr");
  544. STPIO_Clear(TnrResetHandle, PIO_BIT);
  546. task_delay(10000);
  548. task_delay(10000000);
  550. STPIO_Set(TnrResetHandle, PIO_BIT);
  552. task_delay(10000);
  553. task_delay(10000000);
  556.  
  558.          return ST_NO_ERROR;
  560. }
  561. #endif
  563. void LED_TEST_SegdispProcess (void)
  564. {
  565. #if 0//test green led
  566. Led_Green(1);
  567. task_delay(30000000);
  568. Led_Green(0);
  569. task_delay(30000000);
  570. #endif 
  572. printf("-2x-xx----n");
  574. #if 0
  575. //pio_init_led();
  576. while (1)
  577. {
  578. pio_SetORClear(1);
  579. task_delay(ST_GetClocksPerSecond()/460);
  580. pio_SetORClear(0);
  581. task_delay(ST_GetClocksPerSecond()/460);
  582. }
  583. #endif
  586. while(1)
  587. {
  588. #if 1
  589. PIO3_BASE[PIO_OUT_CLR]  |= PIO_BIT_4; 
  590. PIO3_BASE[PIO_OUT_CLR]  |= PIO_BIT_3; 
  591. PIO3_BASE[PIO_OUT_CLR]  |= PIO_BIT_2; 
  593. PIO2_BASE[PIO_OUT_CLR]  |= PIO_BIT_5; 
  594. PIO0_BASE[PIO_OUT_CLR]  |= PIO_BIT_1; 
  595. PIO2_BASE[PIO_OUT_CLR]  |= PIO_BIT_6; 
  596. PIO2_BASE[PIO_OUT_CLR]  |= PIO_BIT_7; 
  597. PIO2_BASE[PIO_OUT_CLR]  |= PIO_BIT_2; 
  598. PIO2_BASE[PIO_OUT_CLR]  |= PIO_BIT_3; 
  599. //printf("-x-xx----n");
  600. task_delay(ST_GetClocksPerSecond()/460);
  601. PIO3_BASE[PIO_OUT_CLR]  &= ~PIO_BIT_4; 
  602. PIO3_BASE[PIO_OUT_CLR]  &= ~PIO_BIT_3;  
  603. PIO3_BASE[PIO_OUT_CLR]  &= ~PIO_BIT_2; 
  605. PIO2_BASE[PIO_OUT_CLR]  &= ~PIO_BIT_5; 
  606. PIO0_BASE[PIO_OUT_CLR]  &= ~PIO_BIT_1; 
  607. PIO2_BASE[PIO_OUT_CLR]  &= ~PIO_BIT_6; 
  608. PIO2_BASE[PIO_OUT_CLR]  &= ~PIO_BIT_7; 
  609. PIO2_BASE[PIO_OUT_CLR]  &= ~PIO_BIT_2; 
  610. PIO2_BASE[PIO_OUT_CLR]  &= ~PIO_BIT_3; 
  612. task_delay(ST_GetClocksPerSecond()/460);
  613. #else
  614. LEDProcess(); 
  615. //printf("-1x-xx----n");
  616. //task_delay(500);
  617. //wt_test();
  618. #endif
  619. task_delay(ST_GetClocksPerSecond()/460);
  620. //printf("-x-----n");
  621. }
  622. }
  625. /*========================================================================= 
  626.  * PROTOTYPE :  
  627.  * static void LED_SegmentProcess(void)
  628.  * 
  629.  * PURPOSE:
  630.  * Led task created
  631.  *==========================================================================*/
  632. static void LED_SegmentProcess(void)
  633. {
  634. U8 fKeyCheck;
  636. LED_LedGreen(1);
  638. while (1) 
  639. {
  640. if(fKeyCheck++ >= 100)
  641. {
  642. fKeyCheck = 0;
  643. FP_KeyCheck();
  644. task_delay(10);
  645. }
  647. LEDProcess(); 
  648. task_delay(ST_GetClocksPerSecond()/300);
  649. }
  650. }
  652. /*========================================================================= 
  653.  * PROTOTYPE :  
  654.  * void LED_Init(void)
  655.  * 
  656.  * PURPOSE:
  657.  * Led init
  658.  *==========================================================================*/
  659. void LED_Init(void)
  660. {
  661.     //setup_pio();
  663.     KB_OSPTaskInit("LED", 1024, (void (*)(void*))LED_SegmentProcess, MENU_PRIORITY, NULL, &LED_TaskID);
  664. }
  666. /*========================================================================= 
  667.  * PROTOTYPE :  
  668.  * void FP_KeyCheck(void)
  669.  * 
  670.  * PURPOSE:
  671.  * Front panel key check
  672.  *==========================================================================*/
  673. void FP_KeyCheck(void)
  674. {
  675. unsigned char i, j;
  676. unsigned char fp_key_data[7] = {0xFE, 0xFD, 0xFB, 0xF7, 0xEF, 0xDF, 0xBF};
  678. unsigned char Key_Value;
  679. BYTE ucKeyRead;
  681. for (j = 0; j < 7; j++)
  682. {
  683. FPIO_CLK(1);
  685. for (i = 0; i < 8; i++)
  686. {
  687. if (((0x80 >> i) & fp_key_data[j]) != 0)
  688. {
  689. FPIO_DATA(1);
  690. FPIO_CLK(0);
  691. FPIO_CLK(1);
  692. }
  693. else
  694. {
  695. FPIO_DATA(0);
  696. FPIO_CLK(0);
  697. FPIO_CLK(1);
  698. }
  699. task_delay(1);
  700. }
  702. Key_Value = READ_KEY_BITS;
  703. if (Key_Value == 0)
  704. {
  705. switch (j)
  706. {
  707. case 0:
  708. ucKeyRead = rc_KeyRight;
  709. break;
  711. case 1:
  712. ucKeyRead = rc_KeyDown;
  713. break;
  715. case 2:
  716. ucKeyRead = rc_KeyLeft;
  717. break;
  719. case 3:
  720. ucKeyRead = rc_KeyUp;
  721. break;
  723. case 4:
  724. ucKeyRead = rc_KeyMenu;
  725. break;
  727. case 5:
  728. ucKeyRead = rc_KeyOK;
  729. break;
  731. case 6:
  732. ucKeyRead = rc_KeyPower;
  733. break;   
  735. }  /* END SWITCH */
  737. {
  738. KB_OSPMsgNode movie_msg;
  740. movie_msg.Word1=KB_MOVIE_KEY_REQUEST;
  741. movie_msg.Word2=ucKeyRead;
  742. kb_machblue_task_post(&movie_msg);
  743. }
  745. }
  746. }
  747. }