开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 其他嵌入式/单片机内容 > 查看源码
Access.~c
资源名称：RTD2523_MTV512.rar　[点击查看]
上传用户：xmyjxjd
上传日期：2013-05-04
资源大小：1517k
文件大小：18k
源码类别：

其他嵌入式/单片机内容

开发平台：

C/C++

Access.~c：源码内容
  1. #define __ACCESS__
  3. #include "reg52.h"
  4. #include "intrins.h"
  6. #include "HeaderMAIN_DEF.H"
  7. #include "HeaderACCESS.h"
  8. #include "HeaderCONFIG.H"
  9. #include "HeaderMTV512.H"
  10. #include "HeaderOSD.H"
  12. #if(MCU_TYPE == MCU_MTV512)
  13. ///////////////////////////////////////////////////////////////////////
  14. // SCL Processor                                                                                                //
  15. ///////////////////////////////////////////////////////////////////////
  16. void MCU_WriteI2cScl(bit Status)
  17. {
  18.        bIIC_SCL = Status;
  19. }
  20. ///////////////////////////////////////////////////////////////////////
  21. // SDA Processor                                                                                               //
  22. ///////////////////////////////////////////////////////////////////////
  23. void MCU_WriteI2cSda(bit Status)
  24. {
  25.        bIIC_SDA = Status;
  26. }
  28. bit MCU_ReadI2cSda(void)
  29. {
  30.        return(bIIC_SDA);
  31. }
  32. ///////////////////////////////////////////////////////////////////////
  33. // RTD Reset Processor                                                                                      //
  34. ///////////////////////////////////////////////////////////////////////
  35. void MCU_WriteRtdReset(bit Status)
  36. {
  37.        bRTD_RST = Status;
  38. }
  40. bit MCU_ReadRtdReset(void)
  41. {
  42.        return(bRTD_RST);
  43. }
  44. ///////////////////////////////////////////////////////////////////////
  45. // RTD SDIO Processor                                                                                       //
  46. ///////////////////////////////////////////////////////////////////////
  47. void MCU_WriteRtdSdio(bit Status)
  48. {
  49.        bRTD_SDO = Status;
  50. }
  52. bit MCU_ReadRtdSdio(void)
  53. {
  54.        return(bRTD_SDI);
  55. }
  56. ///////////////////////////////////////////////////////////////////////
  57. // RTD Sclk Processor                                                                                        //
  58. ///////////////////////////////////////////////////////////////////////
  59. void MCU_WriteRtdSclk(bit Status)
  60. {
  61.        bRTD_SCLK = Status;
  62. }
  63. ///////////////////////////////////////////////////////////////////////
  64. // RTD Scsb Processor                                                                                       //
  65. ///////////////////////////////////////////////////////////////////////
  66. void MCU_WriteRtdScsb(bit Status)
  67. {
  68.        bRTD_SCSB = Status;
  69. }
  70. ///////////////////////////////////////////////////////////////////////
  71. // VIDEO POWER Processor                                                                                //
  72. ///////////////////////////////////////////////////////////////////////
  73. #if (VIDEO_CHIP != VDC_NONE)
  74. void MCU_WriteVideoPower(bit Status)
  75. {
  76.        bVDC_PWR = Status;
  77. }
  78. #endif
  80. ///////////////////////////////////////////////////////////////////////
  81. // PANEL POWER Processor                                                                                 //
  82. ///////////////////////////////////////////////////////////////////////
  83. void MCU_WritePanelPower(bit Status)
  84. {
  85.        bPANEL_PWR = Status;
  86.        bPanel_Status = Status ? 1 : 0;
  87. }
  89. bit MCU_ReadPanelPower(void)
  90. {
  91.        return(bPANEL_PWR);
  92. }
  93. ///////////////////////////////////////////////////////////////////////
  94. // BACKLIGHT POWER Processor                                                                         //
  95. ///////////////////////////////////////////////////////////////////////
  96. void MCU_WriteBacklightPower(bit Status)
  97. {
  98.        bLIGHT_PWR = (Status);
  99. }
  102. ///////////////////////////////////////////////////////////////////////
  103. // VGA CONNECT Processor                                                                                //
  104. ///////////////////////////////////////////////////////////////////////
  105. bit MCU_ReadVgaConnect(void)
  106. {
  107.        return(bVGA_CONNECT);
  108. }
  110. #endif
  112. void BitDly(void)
  113. {
  114.     _nop_(); _nop_(); _nop_(); _nop_(); _nop_(); _nop_(); _nop_(); _nop_();
  115.     _nop_(); _nop_(); _nop_(); _nop_(); _nop_(); _nop_(); _nop_(); _nop_();
  116.     _nop_(); _nop_(); _nop_(); _nop_(); _nop_(); _nop_(); _nop_(); _nop_();
  117.     _nop_(); _nop_(); _nop_(); _nop_(); _nop_(); _nop_(); _nop_(); _nop_();
  118. }
  120. void I2CRead(unsigned char addr, unsigned char index, unsigned char count)
  121. {
  122.     unsigned char   n;
  124.     if (count)
  125.     {
  126.         I2CSendAddr(addr, index, 0);
  127.         
  128.         I2CSendAddr(addr, 0, 1);
  130.         count   = count - 1;
  132.         for (n = 0; n < count; n++)     Data[n] = I2CGetByte(0);
  134.         Data[count] = I2CGetByte(1);
  136.         I2CSendStop();
  137.     }
  138. }
  140. void I2CWrite(unsigned char *array)
  141. {
  142.     unsigned char   n, len;
  144.     if (3 <= array[0])
  145.     {
  146.         len     = array[0];
  147.         I2CSendAddr(array[1], array[2], 0);     
  149.         for (n = 3; n < len; n++)   I2CSendByte(array[n]);
  151.         I2CSendStop();
  152.     }
  153. }
  156. unsigned char I2CGetByte(unsigned char ack) 
  157. {
  158.     unsigned char   r, m;
  160.     r = 0;
  161. #if(MCU_TYPE == MCU_WINBOND)
  162.     for (m = 0; m < 8; m++)         // Each bit at a time, MSB first
  163.     {
  164.         bIIC_SCL    = 1;
  165.         BitDly();                   // Delay
  167.         r   = (r << 1) | bIIC_SDA;
  169.         bIIC_SCL    = 0;
  170.         BitDly();                   // Delay
  171.     }  
  173.     // Send ACK according to 'ack'
  174.     bIIC_SDA    = (bit)(ack & 0x01);
  175.     BitDly();                       // Delay
  176.     
  177.     bIIC_SCL    = 1; 
  178.     BitDly();                       // Delay
  179.     
  180.     bIIC_SCL    = 0; 
  181.     BitDly();                       // Delay
  182.     
  183.     bIIC_SDA    = 1;
  184. #else
  185.    
  186.     for (m = 0; m < 8; m++)         // Each bit at a time, MSB first
  187.     {
  188.         MCU_WriteI2cScl(HIGH);
  189.         BitDly();                   // Delay
  190.         r   = (r << 1) | MCU_ReadI2cSda();
  191.         MCU_WriteI2cScl(LOW);
  192.         BitDly();                   // Delay
  193.     }  
  194.     // Send ACK according to 'ack'
  195.     MCU_WriteI2cSda((bit)(ack & 0x01));
  196.     BitDly();                       // Delay
  197.     MCU_WriteI2cScl(HIGH);
  198.     BitDly();                       // Delay
  199.     MCU_WriteI2cScl(LOW);
  200.     BitDly();                       // Delay
  201.     MCU_WriteI2cSda(HIGH);
  203. #endif
  205.     return (r);
  206. }
  208. void I2CSendByte(unsigned char send)
  209. {
  210.     unsigned char   m;
  211. #if(MCU_TYPE == MCU_WINBOND)    
  212.     for (m = 0; m < 8; m++)
  213.     {
  214.         bIIC_SDA    = (bit)(send & 0x80);   // Send each bit, MSB first
  215.         BitDly();
  217.         bIIC_SCL    = 1;
  218.         BitDly();
  220.         bIIC_SCL    = 0;
  222.         send    = send << 1;
  223.     }
  225.     bIIC_SDA    = 1;
  226.     bIIC_SCL    = 1;
  227.     BitDly();
  229.     bIIC_SCL    = 0;
  230.     BitDly();
  231. #else
  232.     for (m = 0; m < 8; m++)
  233.     {
  234.         MCU_WriteI2cSda((bit)(send & 0x80));   // Send each bit, MSB first
  235.         BitDly();
  236.         MCU_WriteI2cScl(HIGH);
  237.         BitDly();
  238.         MCU_WriteI2cScl(LOW);;
  239.         send    = send << 1;
  240.     }
  241.     MCU_WriteI2cSda(HIGH);
  242.     MCU_WriteI2cScl(HIGH);
  243.     BitDly();
  244.     MCU_WriteI2cScl(LOW);;
  245.     BitDly();
  247. #endif
  248. } 
  250. void I2CSendAddr(unsigned char addr, unsigned char index, unsigned char rd)
  251. {         
  252. #if(MCU_TYPE == MCU_WINBOND)         
  253.     bIIC_SCL    = 1;
  254.     bIIC_SDA    = 0;    // Start
  255.     BitDly();
  257.     bIIC_SCL    = 0;
  258.     I2CSendByte(addr + rd);             // Send address byte
  260.     if (0 == rd)    I2CSendByte(index); // Send index byte  
  261. #else
  262.     MCU_WriteI2cScl(HIGH);
  263.     MCU_WriteI2cSda(LOW);    // Start
  264.     BitDly();
  265.     MCU_WriteI2cScl(LOW);;
  266.     I2CSendByte(addr + rd);             // Send address byte
  267.     if (0 == rd)    I2CSendByte(index); // Send index byte 
  268. #endif
  269. }
  271. void I2CSendStop(void)
  272. {
  273. #if(MCU_TYPE == MCU_WINBOND)
  274.     bIIC_SDA    = 0; 
  275.     BitDly();
  277.     bIIC_SCL    = 1;
  278.     BitDly();
  280.     bIIC_SDA    = 1;
  281.     BitDly();
  282. #else
  283.     MCU_WriteI2cSda(LOW); 
  284.     BitDly();
  285.     MCU_WriteI2cScl(HIGH);
  286.     BitDly();
  287.     MCU_WriteI2cSda(HIGH);
  288.     BitDly();
  289. #endif
  290. }
  292. unsigned char RTDGetByte(void) 
  293. {
  295. #if(PARALLEL_PORT)
  297. #if(1)
  298.    bRTD_SCLK = 1;
  299.    bRTD_SCLK = 0;
  300.    r0        = bRTD_SDIO_0;
  301.    r1        = bRTD_SDIO_1;
  302.    r2        = bRTD_SDIO_2;
  303.    r3        = bRTD_SDIO_3;
  305.    bRTD_SCLK = 1;
  306.    bRTD_SCLK = 0;
  307.    r4        = bRTD_SDIO_0;
  308.    r5        = bRTD_SDIO_1;
  309.    r6        = bRTD_SDIO_2;
  310.    r7        = bRTD_SDIO_3;
  312.    bRTD_SCLK   = 1;
  313. #else
  315.    bRTD_SCLK = 1;
  316.    bRTD_SCLK = 0;
  318.    Reg = P0 & 0x0f;
  320.    bRTD_SCLK = 1;
  321.    bRTD_SCLK = 0;
  323.    Reg = Reg | ((P0 & 0x0f) << 4);
  325.    bRTD_SCLK   = 1;
  327. #endif
  329. #else //serial port
  330.     bRTD_SCLK   = 1;
  331.     bRTD_SCLK   = 0;
  332.     r0          = bRTD_SDIO_0;
  334.     bRTD_SCLK   = 1;
  335.     bRTD_SCLK   = 0;
  336.     r1          = bRTD_SDIO_0;
  338.     bRTD_SCLK   = 1;
  339.     bRTD_SCLK   = 0;
  340.     r2          = bRTD_SDIO_0;
  342.     bRTD_SCLK   = 1;
  343.     bRTD_SCLK   = 0;
  344.     r3          = bRTD_SDIO_0;
  346.     bRTD_SCLK   = 1;
  347.     bRTD_SCLK   = 0;
  348.     r4          = bRTD_SDIO_0;
  350.     bRTD_SCLK   = 1;
  351.     bRTD_SCLK   = 0;
  352.     r5          = bRTD_SDIO_0;
  354.     bRTD_SCLK   = 1;
  355.     bRTD_SCLK   = 0;
  356.     r6          = bRTD_SDIO_0;
  358.     bRTD_SCLK   = 1;
  359.     bRTD_SCLK   = 0;
  360.     r7          = bRTD_SDIO_0;
  362.     bRTD_SCLK   = 1;
  364. #endif
  367.     return Reg;
  368. }
  370. void RTDSendByte(unsigned char send)
  371. {
  374. #if(PARALLEL_PORT)
  376. #if(1)
  377.     bRTD_SDIO_0 = (bit)(send & 0x01);
  378. bRTD_SDIO_1 = (bit)(send & 0x02);
  379. bRTD_SDIO_2 = (bit)(send & 0x04);
  380. bRTD_SDIO_3 = (bit)(send & 0x08);
  381. bRTD_SCLK   = 1;
  382.     bRTD_SCLK   = 0;
  384. bRTD_SDIO_0 = (bit)(send & 0x10);
  385. bRTD_SDIO_1 = (bit)(send & 0x20);
  386. bRTD_SDIO_2 = (bit)(send & 0x40);
  387. bRTD_SDIO_3 = (bit)(send & 0x80);
  388. bRTD_SCLK   = 1;
  389.     bRTD_SCLK   = 0;
  391. bRTD_SDIO_0 = 1;
  392. bRTD_SDIO_1 = 1;
  393. bRTD_SDIO_2 = 1;
  394. bRTD_SDIO_3 = 1;
  395. bRTD_SCLK   = 1;
  396. #else
  397.     unsigned char ucTemp;
  399. ucTemp = P0 & 0xf0;
  401.     P0 = ucTemp | (send & 0x0f);
  402.     bRTD_SCLK   = 1;
  403.     bRTD_SCLK   = 0;
  405.     P0 = ucTemp | (send >> 4);
  407.     bRTD_SCLK   = 1;
  408.     bRTD_SCLK   = 0;
  410.     P0 = ucTemp | 0x0f;
  411.     bRTD_SCLK   = 1;
  413. #endif
  415. #else //serial port
  416.     bRTD_SDIO_0 = (bit)(send & 0x01);
  417.     bRTD_SCLK   = 1;
  418.     bRTD_SCLK   = 0;
  420.     bRTD_SDIO_0 = (bit)(send & 0x02);
  421.     bRTD_SCLK   = 1;
  422.     bRTD_SCLK   = 0;
  424.     bRTD_SDIO_0 = (bit)(send & 0x04);
  425.     bRTD_SCLK   = 1;
  426.     bRTD_SCLK   = 0;
  428.     bRTD_SDIO_0 = (bit)(send & 0x08);
  429.     bRTD_SCLK   = 1;
  430.     bRTD_SCLK   = 0;
  432.     bRTD_SDIO_0 = (bit)(send & 0x10);
  433.     bRTD_SCLK   = 1;
  434.     bRTD_SCLK   = 0;
  436.     bRTD_SDIO_0 = (bit)(send & 0x20);
  437.     bRTD_SCLK   = 1;
  438.     bRTD_SCLK   = 0;
  440.     bRTD_SDIO_0 = (bit)(send & 0x40);
  441.     bRTD_SCLK   = 1;
  442.     bRTD_SCLK   = 0;
  444.     bRTD_SDIO_0 = (bit)(send & 0x80);
  445.     bRTD_SCLK   = 1;
  446.     bRTD_SCLK   = 0;
  448.     bRTD_SDIO_0 = 1;
  449.     bRTD_SCLK   = 1;
  451. #endif
  454. }
  456. void RTDSendAddr(unsigned char addr, unsigned char rd, unsigned char inc)   // rd   : 0 - Write, 1 - Read
  457. {
  459. #if(PARALLEL_PORT)
  461.     RTDSendByte(addr);
  463. bRTD_SDIO_0 = (bit)(rd & 0x01);
  464. bRTD_SDIO_1 = (bit)(inc & 0x01);
  466. bRTD_SCLK = 0;
  468. bRTD_SDIO_0 = 1;
  469. bRTD_SDIO_1 = 1;
  470. bRTD_SCLK = 1;
  471. #else // serial port
  472.     RTDSendByte(addr);
  474.     bRTD_SDIO_0 = 1;
  475.     bRTD_SCLK   = 1;        
  476.     bRTD_SDIO_0 = (bit)(rd & 0x01); 
  477.     bRTD_SCLK   = 1;
  478.     bRTD_SCLK   = 0;
  479.     bRTD_SDIO_0 = (bit)(inc & 0x01); 
  480.     bRTD_SCLK   = 1;
  481.     bRTD_SCLK   = 0;
  482.     bRTD_SDIO_0 = 1;
  483. #endif
  486. }
  488. void RTDSendStop(void)
  489. {
  491.         bRTD_SCLK   = 0;
  492.         bRTD_SCLK   = 1; 
  493.         bRTD_SCSB   = 1;
  495. }
  497. void RTDRead(unsigned char index, unsigned char count, unsigned char inc)
  498. {
  499.     if (count)
  500.     {
  501.         bRTD_SCSB   = 0;
  503.         RTDSendAddr(index, 1, inc);
  505.         index   = 0;
  506.         do
  507.         {
  508.             Data[index++]   = RTDGetByte();
  509.         }
  510.         while (--count);
  512. RTDSendStop();
  514.     }
  515. }
  517. void RTDWrite(unsigned char data *array)
  518. {
  520.     unsigned char   len, m;
  522.     do
  523.     {
  524.         if (0 == (array[0] & 0xfc))     return;
  526.         len     = array[0] - 3;
  527.         array   = array + 1;
  528.         bRTD_SCSB   = 0;
  531.         if (BURST == array[0])
  532.         {
  533.             RTDSendAddr(array[1], 0, N_INC);
  535.             array   = array + 2;
  536.             m       = array[0];
  538.             do
  539.             {
  540.                 RTDSendByte(m);
  541.             }
  542.             while (--len);
  544.             array   = array + 1;
  545.         }
  546.         else
  547.         {
  548.             RTDSendAddr(array[1], 0, array[0]);
  550.             array   = array + 2;
  551.             do
  552.             {
  553.                 RTDSendByte(*array++);
  554.             }
  555.             while (--len);
  556.         }
  557. RTDSendStop();
  558.     }
  559.     while (1);
  560. }
  562. void RTDCodeW(unsigned char code *array)
  563. {
  564.     unsigned char   len, m;
  566.     do
  567.     {
  568.         if (0 == (array[0] & 0xfc))     return;
  570.         len     = array[0] - 3;
  571.         array   = array + 1;
  572.         bRTD_SCSB   = 0;
  574.         if (BURST == array[0])
  575.         {
  576.             RTDSendAddr(array[1], 0, N_INC);
  578.             array   = array + 2;
  579.             m       = array[0];
  580.             
  581.             do
  582.             {
  583.                 RTDSendByte(m);
  584.             }
  585.             while (--len);
  587.             array   = array + 1;
  588.         }
  589.         else
  590.         {
  591.             RTDSendAddr(array[1], 0, array[0]);
  593.             array   = array + 2;
  594.             do
  595.             {
  596.                 RTDSendByte(*array++);
  597.             }
  598.             while (--len);
  599.         }
  600. RTDSendStop();
  602.     }
  603.     while (1);
  604. }
  606. void RTDOSDW(unsigned char code *array)
  607. {
  608.     unsigned char   len;
  609.     do
  610.     {
  611.         if (array[0] == _end_)     return;
  612.     
  613. bRTD_SCSB   = 0;
  614.         RTDSendAddr(OSD_ROW_90,WRITE,Y_INC);
  615.         RTDSendByte(*array++);
  616.         RTDSendByte(*array++);
  618. RTDSendStop();
  620. bRTD_SCSB   = 0;
  621.         RTDSendAddr(OSD_DATA_92,WRITE,N_INC);
  622.         do
  623. {
  624.            if(array[1] == _bb_)
  625.    {
  626.        len = array[2] - 1;
  627.    do
  628.    {
  629.       RTDSendByte(*array);
  630.    }while(len--);
  631.        
  632.    array = array + 3;
  633.    }
  634.    else
  635.        RTDSendByte(*array++);
  638. }while(array[0] != _nn_);
  639. array +=1 ;
  640. RTDSendStop();
  642.     }
  643.     while (1);
  645. }
  648. void RTDSetByte(unsigned char addr, unsigned char val)
  649. {
  650.     // Set Write Address
  651.     bRTD_SCSB   = 0;   
  653.     RTDSendAddr(addr, 0, 1);
  655.     // Write one Byte
  656.     RTDSendByte(val);
  658. RTDSendStop();
  660. }
  662. void RTDSetBit(unsigned char addr, unsigned char and, unsigned char or)
  663. {
  664.     // Set Read Address
  665.     bRTD_SCSB   = 0;
  666.     RTDSendAddr(addr, 1, 1);
  668.     // Read 1 Byte
  669.     or      = (RTDGetByte() & and) | or;
  671. RTDSendStop();
  673.     // Set Write Address
  674.     bRTD_SCSB   = 0;   
  675.     RTDSendAddr(addr, 0, 1);
  677.     // Write one Byte
  678.     RTDSendByte(or);
  680. RTDSendStop();
  683. }
  686. //length represent the number of character
  687. // character number of 1 bit font  = 1
  688. // character number of 2 bit font  = 2
  689. // character number of 4 bit font  = 4
  690. // length = (1 bit font amount) x 1 + (2 bit font amount) x 2 + (4 bit font amount) x 4
  691. void Load_Font(unsigned char code *array, unsigned int start, unsigned int length)
  692. {
  693.     unsigned char   n,m;
  694.     unsigned char   ucTemp[3];
  695. #if(PARALLEL_PORT)
  696. unsigned char ucTemp1;
  697. #endif
  699.     start = start * 9;
  700.     start += FONT_BASE_ADDRESS;
  702. bRTD_SCSB   = 0;   
  703. RTDSendAddr(OSD_ROW_90, WRITE, Y_INC);
  704. ucTemp[0] = (unsigned char)((start >> 8) & 0x000f) | 0xd0;
  705. RTDSendByte(ucTemp[0]);
  706. ucTemp[0] = (unsigned char)(start & 0x00ff);
  707. RTDSendByte(ucTemp[0]);
  709. RTDSendStop();
  711. bRTD_SCSB   = 0;   
  712. RTDSendAddr(OSD_DATA_92, WRITE, N_INC);
  714.     do
  715.     {
  716.         for(m=0; m<9; m++)
  717.         {
  718. //Rearrange the byte order
  720.             ucTemp[0] = (*(array + 1) << 4) | (*(array + 2) & 0x0f);
  721. ucTemp[1] = (*(array + 2) & 0xf0) | (*array & 0x0f);
  722. ucTemp[2] = (*array & 0xf0) | (*(array + 1) >> 4);
  724. for(n=0;n<3;n++)
  725. {
  726. #if(PARALLEL_PORT)
  728. #if(1)
  729. bRTD_SDIO_0 = (bit)(ucTemp[n] & 0x01);
  730. bRTD_SDIO_1 = (bit)(ucTemp[n] & 0x02);
  731. bRTD_SDIO_2 = (bit)(ucTemp[n] & 0x04);
  732. bRTD_SDIO_3 = (bit)(ucTemp[n] & 0x08);
  733.                 bRTD_SCLK   = 1;
  734. bRTD_SCLK   = 0;
  735. bRTD_SDIO_0 = (bit)(ucTemp[n] & 0x10);
  736. bRTD_SDIO_1 = (bit)(ucTemp[n] & 0x20);
  737. bRTD_SDIO_2 = (bit)(ucTemp[n] & 0x40);
  738. bRTD_SDIO_3 = (bit)(ucTemp[n] & 0x80);
  739. bRTD_SCLK   = 1;
  740. bRTD_SCLK   = 0;
  741. bRTD_SDIO_0 = 1;
  742. bRTD_SDIO_1 = 1;
  743. bRTD_SDIO_2 = 1;
  744. bRTD_SDIO_3 = 1;
  745. bRTD_SCLK   = 1;
  746. #else
  747. ucTemp1 = P0 & 0xf0;
  749. P0 = ucTemp1 | (ucTemp[n] & 0x0f);
  750. bRTD_SCLK   = 1;
  751. bRTD_SCLK   = 0;
  752. P0 = ucTemp1 | (ucTemp[n] >> 4);
  753. bRTD_SCLK   = 1;
  754. bRTD_SCLK   = 0;
  755. P0 = ucTemp1 | 0x0f;
  756. bRTD_SCLK   = 1;
  757. #endif
  759. #else
  760. bRTD_SDIO_0 = (bit)(ucTemp[n] & 0x01);
  761. bRTD_SCLK   = 1;
  762. bRTD_SCLK   = 0;
  763. bRTD_SDIO_0 = (bit)(ucTemp[n] & 0x02);
  764. bRTD_SCLK   = 1;
  765. bRTD_SCLK   = 0;
  766. bRTD_SDIO_0 = (bit)(ucTemp[n] & 0x04);
  767. bRTD_SCLK   = 1;
  768. bRTD_SCLK   = 0;
  769. bRTD_SDIO_0 = (bit)(ucTemp[n] & 0x08);
  770. bRTD_SCLK   = 1;
  771. bRTD_SCLK   = 0;
  772. bRTD_SDIO_0 = (bit)(ucTemp[n] & 0x10);
  773. bRTD_SCLK   = 1;
  774. bRTD_SCLK   = 0;
  775. bRTD_SDIO_0 = (bit)(ucTemp[n] & 0x20);
  776. bRTD_SCLK   = 1;
  777. bRTD_SCLK   = 0;
  778. bRTD_SDIO_0 = (bit)(ucTemp[n] & 0x40);
  779. bRTD_SCLK   = 1;
  780. bRTD_SCLK   = 0;
  781. bRTD_SDIO_0 = (bit)(ucTemp[n] & 0x80);
  782. bRTD_SCLK   = 1;
  783. bRTD_SCLK   = 0;
  784. bRTD_SDIO_0 = 1;
  785. bRTD_SCLK   = 1;
  786. #endif
  787.             }
  788.             array += 3;
  789.         }
  790.     }
  791.     while (--length);
  793. RTDSendStop();
  794. }
  798. #if(HDCP_ENABLE)
  799. void KEYCodeW(unsigned char code *array)
  800. {
  801.     unsigned int m;  
  803.    RTDSetBit(DVI_CTRL1_AF, 0x7f,0x00);  //Reset the HDCP key download index
  804.    RTDSetBit(DVI_CTRL1_AF, 0x7f,0x80);
  806.     for(m = 0; m < 320; m++)   //Key 0 ~ Key39   
  807.     {
  808. RTDSetByte(0xb1,array[m]);
  809.     }
  811.     RTDSetBit(DVI_CTRL1_AF, 0x7f,0x00);  //Disable the Key Access Download port
  812.     RTDSetBit(TMDS_INPUT_ENA_A1, 0x7f, 0x00);   // Turn on HDCP DDC channel  
  813. }
  814. #endif