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

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

其他嵌入式/单片机内容

开发平台：

C/C++

Lcd_func.~c：源码内容
  1. #define __FUNC__
  3. #include "reg52.h"
  4. #include "intrins.h"
  6. #include "HeaderMAIN_DEF.H"
  7. #include "HeaderCONFIG.H"
  8. #include "HeaderACCESS.H"
  9. #include "HeaderOSD.H"
  10. #include "HeaderLCD_COEF.H"
  11. #include "HeaderLCD_MAIN.H"
  12. #include "HeaderLCD_AUTO.H"
  13. #include "HeaderLCD_FUNC.H"
  14. #include "HeaderFRAME_SYNC.H"
  15. #include "HeaderLCD_OSD.H"
  18. #if (TV_CHIP != TV_NONE)
  19. #include "TUNER.H"
  20. #endif
  22. void SetVolume()
  23. {
  24.     stGUD3.VOLUME   &= 0x1f;
  26. #if (AUDIO_TYPE == AUDIO_LM4832)
  27.     Data[0] = 10;
  28.     Data[1] = ADDR_LM4832;
  29.     Data[2] = 0x00;
  30.     Data[3] = 0x02;
  31.     Data[4] = 0x00;                     // Input Volume - 0 dB
  32.     Data[5] = 0x26;                     // Bass         - 0 dB
  33.     Data[6] = 0x46;                     // Treble       - 0 dB
  34.     Data[7] = 0x60 | stGUD3.VOLUME;     // Right Volume
  35.     Data[8] = 0x80 | stGUD3.VOLUME;     // Left Volume
  37.     // Mic 1 selected with 20dB when input source is VGA or DVI
  38.     // Both Mic 1 and 2 selected with 20dB when input source is AV or S-Video
  39.     Data[9] = (SOURCE_AV <= (stGUD1.INPUT_SOURCE & 0x07)) ? 0xa6 : 0xa4;
  40.     
  41.     I2CWrite(Data);
  42. #endif
  44. #if (AUDIO_TYPE == AUDIO_PWM2)
  45.     Data[0] = 6;
  46.     Data[1] = Y_INC;
  47.     Data[2] = OSD_ROW_90;
  48.     Data[3] = 0x80;
  49.     Data[4] = 0x01;
  50. #if (INV_VOLUME)
  51.     Data[5] = (0xff -(stGUD3.VOLUME << 3));
  52. #else
  53. Data[5] = (stGUD3.VOLUME << 3);
  54. #endif
  55. Data[6] = 0;
  56.     RTDWrite(Data);
  57. #endif
  60. #if (AUDIO_TYPE == AUDIO_PWM0)
  62.     Data[0] = 6;
  63.     Data[1] = Y_INC;
  64.     Data[2] = OSD_ROW_90;
  65.     Data[3] = 0x00;
  66.     Data[4] = 0x01;
  67. #if (INV_VOLUME)
  68.     Data[5] = (0xff -(stGUD3.VOLUME << 3));
  69. #else
  70. Data[5] = (stGUD3.VOLUME << 3);
  71. #endif
  72. Data[6] = 0;
  73.     RTDWrite(Data);
  74. #endif
  75. }
  77. void WriteGamma(unsigned char code *arrayR, unsigned char code *arrayG, unsigned char code *arrayB)
  78. {
  79.     unsigned char   n   = 0;
  81.     RTDSetBit(COLOR_CTRL_5D, 0xfb, 0x10);   // Disable GAMMA & Enable Access Channel
  82.     
  84.     // GAMMA_RED
  85.     bRTD_SCSB   = 0;
  86.     RTDSendAddr(RED_GAMMA_64, WRITE, N_INC);
  87.     do
  88.     {
  89.         RTDSendByte(arrayR[n]);
  90.     }
  91.     while (++n);    // if n is 0xff, then n will be 0x00 after increased.
  93. #if(MCU_TYPE == MCU_WINBOND)
  94.     bRTD_SCLK   = 0; 
  95.     bRTD_SCLK   = 1;           
  96.     bRTD_SCSB   = 1;
  97.     
  98.     // GAMMA_GREEN
  99.     bRTD_SCSB   = 0;
  100. #else
  101.     MCU_WriteRtdSclk(LOW); 
  102.     MCU_WriteRtdSclk(HIGH);           
  103.     MCU_WriteRtdScsb(HIGH);
  104.     
  105.     // GAMMA_GREEN
  106.     MCU_WriteRtdScsb(LOW);
  107. #endif
  109.     RTDSendAddr(GRN_GAMMA_65, WRITE, N_INC);
  110.     do
  111.     {
  112.         RTDSendByte(arrayG[n]);
  113.     }
  114.     while (++n);
  115. #if(MCU_TYPE == MCU_WINBOND)
  116.     bRTD_SCLK   = 0; 
  117.     bRTD_SCLK   = 1;           
  118.     bRTD_SCSB   = 1;
  119.     
  120.     //GAMMA_BLUE
  121.     bRTD_SCSB   = 0;
  122. #else
  123.     MCU_WriteRtdSclk(LOW); 
  124.     MCU_WriteRtdSclk(HIGH);           
  125.     MCU_WriteRtdScsb(HIGH);
  126.     
  127.     //GAMMA_BLUE
  128.     MCU_WriteRtdScsb(LOW);
  129. #endif
  130.     RTDSendAddr(BLU_GAMMA_66, WRITE, N_INC);
  131.     do
  132.     {
  133.         RTDSendByte(arrayB[n]);
  134.     }
  135.     while (++n);
  137. #if(MCU_TYPE == MCU_WINBOND)
  138.     bRTD_SCLK   = 0; 
  139.     bRTD_SCLK   = 1;           
  140.     bRTD_SCSB   = 1;
  141. #else
  142.     MCU_WriteRtdSclk(_LOW); 
  143.     MCU_WriteRtdSclk(_HIGH);           
  144.     MCU_WriteRtdScsb(_HIGH);
  145. #endif
  147.     
  148.     RTDSetBit(COLOR_CTRL_5D, 0xef, 0x04);   // Enable GAMMA & Diable Access Channel
  149. }
  151. void WriteDither(unsigned char code *array , bit new_dither)
  152. {
  153.     unsigned char   n;
  154.     if(new_dither)
  155.       RTDSetBit(FX_LST_LEN_H_5A,0xff,0x80);
  156.     else
  157.       RTDSetBit(FX_LST_LEN_H_5A,0x7f,0x00);
  159.     RTDSetBit(COLOR_CTRL_5D, 0xb7, 0x68);   // Enable DITHER & Enable Access Channels
  161. #if(MCU_TYPE == MCU_WINBOND)
  162.     bRTD_SCSB   = 0;
  163.     RTDSendAddr(DITHER_PORT_67, WRITE, N_INC);
  165.     for (n = 0; n < 8; n++)     RTDSendByte(array[n]);
  167.     bRTD_SCLK   = 0; 
  168.     bRTD_SCLK   = 1;           
  169.     bRTD_SCSB   = 1;
  170. #else
  171.     MCU_WriteRtdScsb(_LOW);
  172.     RTDSendAddr(DITHER_PORT_67, WRITE, N_INC);
  174.     for (n = 0; n < 8; n++)     RTDSendByte(array[n]);
  176.     MCU_WriteRtdSclk(_LOW); 
  177.     MCU_WriteRtdSclk(_HIGH);           
  178.     MCU_WriteRtdScsb(_HIGH);
  179. #endif
  180.     
  181.     //RTDSetBit(COLOR_CTRL_5D, 0xdf, 0x48);   // Enable DITHER & Disable Access Channels
  182. RTDSetBit(COLOR_CTRL_5D, 0x1f, 0x88);   // Enable DITHER & Disable Access Channels
  183. }
  185. void WriteSU_COEF(unsigned char code *arrayH, unsigned char code *arrayV)
  186. {
  187.     unsigned char   n;
  188.     
  191.     RTDSetBit(FILTER_CTRL1_1C, 0xfc, 0x01);     // Enable H-Coeff access
  192. #if(MCU_TYPE == MCU_WINBOND)
  193.     bRTD_SCSB   = 0;
  194.     RTDSendAddr(FILTER_PORT_1D, WRITE, N_INC);
  195.     for (n = 0; n < 128; n++)    RTDSendByte(arrayH[n]);
  197.     bRTD_SCLK   = 0; 
  198.     bRTD_SCLK   = 1;           
  199.     bRTD_SCSB   = 1;
  201.     RTDSetBit(FILTER_CTRL1_1C, 0xfc, 0x03);     // Enable V-Coeff access
  202.     
  203.     bRTD_SCSB   = 0;
  204.     RTDSendAddr(FILTER_PORT_1D, WRITE, N_INC);
  205.     for (n = 0; n < 128; n++)    RTDSendByte(arrayV[n]);
  207.     bRTD_SCLK   = 0; 
  208.     bRTD_SCLK   = 1;           
  209.     bRTD_SCSB   = 1;
  211. #else
  212.     MCU_WriteRtdScsb(_LOW);
  213.     RTDSendAddr(FILTER_PORT_1D, WRITE, N_INC);
  214.     for (n = 0; n < 128; n++)    RTDSendByte(arrayH[n]);
  216.     MCU_WriteRtdSclk(_LOW); 
  217.     MCU_WriteRtdSclk(_HIGH);           
  218.     MCU_WriteRtdScsb(_HIGH);
  220.     RTDSetBit(FILTER_CTRL1_1C, 0xfc, 0x03);     // Enable V-Coeff access
  221.     
  222.     MCU_WriteRtdScsb(_LOW);
  223.     RTDSendAddr(FILTER_PORT_1D, WRITE, N_INC);
  224.     for (n = 0; n < 128; n++)    RTDSendByte(arrayV[n]);
  226.     MCU_WriteRtdSclk(_LOW); 
  227.     MCU_WriteRtdSclk(_HIGH);           
  228.     MCU_WriteRtdScsb(_HIGH);
  230. #endif
  232.     RTDSetBit(FILTER_CTRL1_1C, 0xfc, 0xc4);     // Disable filter coefficient access
  233. }
  235. void Set_H_Position(void)
  236. {
  237. #if(AS_NON_FRAMESYNC)
  238.     RTDSetBit(ODD_CTRL_8E,0xef,0x00);
  239. #endif
  241.     // if the backporch is far small then the standard one,
  242. // it is possibile that even IHS_Delay decrease to zero still can't correct the H position
  243. // so adjust the usIPH_ACT_STA first and turn back to original value later
  245.     if(stMUD.H_POSITION < ucH_Min_Margin)
  246.     {
  247.        usIPH_ACT_STA = usIPH_ACT_STA - (ucH_Min_Margin - stMUD.H_POSITION);
  248.        stMUD.H_POSITION = ucH_Min_Margin;
  249.     }
  251. #if(ALIGN_LEFT == CLOCK_ALIGN)
  252.     ((unsigned int*)Data)[4] = usIPH_ACT_STA + (stMUD.CLOCK >> 2) - 32;
  253. #else
  254.     ((unsigned int*)Data)[4] = usIPH_ACT_STA + (stMUD.CLOCK >> 1) - 64;
  255. #endif
  258.     Wait_For_Event(EVENT_IEN_STOP);
  259.         
  260.     Data[0] = 5;
  261.     Data[1] = Y_INC;
  262.     Data[2] = IPH_ACT_STA_06;
  263.     Data[3] = (unsigned char)((unsigned int*)Data)[4];
  264.     Data[4] = (unsigned char)(((unsigned int*)Data)[4] >> 8);
  265.     Data[5] = 0;    
  266.     RTDWrite(Data);
  268.     // Update IHS delay according to phase
  269. //    Set_Phase(stMUD.PHASE & 0x7c);
  270.     //Data[0]     = PROGRAM_HDELAY + (stMUD.H_POSITION - ucH_Min_Margin);
  271.      Data[12] = (stMUD.H_POSITION - ucH_Min_Margin) + PROGRAM_HDELAY;
  273. RTDSetByte(IHS_DELAY_8D, Data[12]);
  274.    
  276. #if(AS_NON_FRAMESYNC)
  277.     if(bFrameSync && bStable)
  278.         RTDSetBit(ODD_CTRL_8E,0xef,0x10);
  279. #endif
  280. }
  282. #if(PANEL_TYPE == PANEL_HYUNDAI) //hgxxxx 0522 for Hyundai
  283. #define MAX_MOVE_LINE 2
  284. bit bSTEP_VPOS = 0;
  285. static unsigned char idata ucPre_V_POS = 0x80;
  286. void Set_V_Position4HD(void);
  288. void Set_V_Position(void)
  289. {
  290. unsigned char tempstore;
  291. tempstore = stMUD.V_POSITION;
  292. bSTEP_VPOS = 1;
  293.     do
  294. {
  295. if(stMUD.V_POSITION > ucPre_V_POS)
  296. {
  297. if(stMUD.V_POSITION - ucPre_V_POS > MAX_MOVE_LINE)
  298. stMUD.V_POSITION = ucPre_V_POS + MAX_MOVE_LINE;
  299. }
  300. else
  301. {
  302. if(ucPre_V_POS - stMUD.V_POSITION > MAX_MOVE_LINE)
  303. stMUD.V_POSITION = ucPre_V_POS - MAX_MOVE_LINE;
  304. }
  305. Set_V_Position4HD();
  306. stMUD.V_POSITION = tempstore;
  307. }
  308. while(stMUD.V_POSITION != ucPre_V_POS);
  309. bSTEP_VPOS = 0;
  310. }
  312. void Set_V_Position4HD(void)
  313. #else
  314. void Set_V_Position(void)
  315. #endif
  317. {
  318.     unsigned int    usIV_Temp, usDV_Temp;
  321. #if(AS_NON_FRAMESYNC)
  322.     RTDSetBit(ODD_CTRL_8E,0xef,0x00);
  323. #endif
  325. #if(AS_DV_TOTAL)
  326.     RTDSetBit(DV_BKGD_STA_31,0x7f,0x00);
  327. #endif
  329.     if ((ucV_Max_Margin - 1)  < stMUD.V_POSITION)
  330.     {
  331.        
  332.         RTDSetByte(IVS_DELAY_8C, (PROGRAM_VDELAY + stMUD.V_POSITION - (ucV_Max_Margin - 1)));
  335.         usIV_Temp   = usIPV_ACT_STA + (ucV_Max_Margin - 1) - 128;
  336.         usDV_Temp   = (unsigned int)ucDV_Delay + (ucV_Max_Margin - 1) - 128;
  337.     }
  338.     else
  339.     {
  341.         RTDSetByte(IVS_DELAY_8C, PROGRAM_VDELAY);
  344.         usIV_Temp   = usIPV_ACT_STA + stMUD.V_POSITION - 128;
  345.         usDV_Temp   = (unsigned int)ucDV_Delay + stMUD.V_POSITION - 128;
  346.     }
  348.     Wait_For_Event(EVENT_IEN_START);
  350.     Data[0] = 4;
  351.     Data[1] = N_INC;
  352.     Data[2] = IV_DV_LINES_38;
  353.     Data[3] = (unsigned char)usDV_Temp;
  354.     Data[4] = 5;    
  355.     Data[5] = Y_INC;
  356.     Data[6] = IPV_ACT_STA_0A;
  357.     Data[7] = (unsigned char)usIV_Temp;
  358.     Data[8] = (unsigned char)(usIV_Temp >> 8);
  359.     Data[9] = 0;
  360.     RTDWrite(Data);
  362.     Wait_For_Event(EVENT_IEN_START);
  365. RTDSetByte(STATUS0_01, 0x00);  // Clear status
  366.     RTDSetByte(STATUS1_1F, 0x00);  // Clear status
  369. #if(AS_NON_FRAMESYNC)
  370.     if(bFrameSync && bStable)
  371.         RTDSetBit(ODD_CTRL_8E,0xef,0x10);
  372. #endif
  374. #if(AS_DV_TOTAL)
  375.     if(bFrameSync && bStable)
  376.     {
  377.        RTDSetByte(DV_TOTAL_STATUS_3D,0x00);  //Write once to clear status
  378.        RTDSetBit(DV_BKGD_STA_31,0x7f,0x80);
  379.     }
  380. #endif
  382. #if(PANEL_TYPE == PANEL_HYUNDAI) //hgxxxx 0522 for Hyundai
  383. ucPre_V_POS = stMUD.V_POSITION;
  384. #endif
  385. }
  387. /*
  388. void Set_V_Position(void)
  389. {
  390.     unsigned int    usIV_Temp, usDV_Temp;
  391. #if(PANEL_TYPE == PANEL_HANDAI)
  392. unsigned int usDHT,usDHTc;
  393. unsigned char ucIVD0,ucIVD1;
  394. #endif
  396. #if(AS_NON_FRAMESYNC)
  397.     RTDSetBit(ODD_CTRL_8E,0xef,0x00);
  398. #endif
  401.     if (ucV_Max_Margin < stMUD.V_POSITION)
  402.     {
  404.         RTDSetByte(IVS_DELAY_8C, (PROGRAM_VDELAY + stMUD.V_POSITION - ucV_Max_Margin));
  407.         usIV_Temp   = usIPV_ACT_STA + ucV_Max_Margin - 128;
  408.         usDV_Temp   = (unsigned int)ucDV_Delay + ucV_Max_Margin - 128;
  409.     }
  410.     else
  411.     {
  413.         RTDSetByte(IVS_DELAY_8C, PROGRAM_VDELAY);
  416.         usIV_Temp   = usIPV_ACT_STA + stMUD.V_POSITION - 128;
  417.         usDV_Temp   = (unsigned int)ucDV_Delay + stMUD.V_POSITION - 128;
  418.     }
  420. #if(PANEL_TYPE == PANEL_HANDAI)
  421. //DHT =  xxxxxxxx_xxx00000 (0x22) + 00000000_00xxxxx0 (0x2e)
  422. RTDRead(0x22, 0x02, Y_INC);
  423. usDHT = 256 * (Data[1]&0x07) + Data[0] + 2;
  424. RTDRead(0x2E, 0x01, Y_INC);
  425. //to restore DV_tatal
  426. Data[15] = Data[0];
  427. usDHT = usDHT*32 + ((Data[0]>>2) & 0x3e);
  430. //compensated DH_Total
  431. RTDRead(IVS_DELAY_8C, 0x01, Y_INC);
  432. //original IVS delay
  433. ucIVD0 = Data[0];  
  434. //The IVS delay you are going to set
  435. ucIVD1 = (ucV_Max_Margin < stMUD.V_POSITION) ? (0x80 | (PROGRAM_VDELAY + stMUD.V_POSITION - ucV_Max_Margin)) : (0x80 | PROGRAM_VDELAY);
  436. //original IVS_DVS_Delay
  437. RTDRead(IV_DV_LINES_38, 0x01, Y_INC);
  438. //usDV_Temp  => IVS_DVS_delay you are going to set
  439. usDHTc = (unsigned long)usDHT * (usVsync + usDV_Temp - Data[0] + ucIVD1 - ucIVD0)/usVsync - 0x40;//-2
  440.     
  441.     
  444. //modify DH_Total
  445.     Wait_For_Event(EVENT_IEN_STOP);
  446. Data[0] = 5;
  447.     Data[1] = Y_INC;
  448.     Data[2] = DH_TOTAL_22;
  449.     Data[3] = (unsigned char)((usDHTc>>5) & 0x00fe);
  450. Data[4] = (unsigned char)((usDHTc>>13) & 0x0007);
  451. Data[5] = 4;
  452. Data[6] = Y_INC;
  453. Data[7] = 0x2e;
  454. Data[8] = (Data[15] & 0x07) | (((usDHTc+1)<<2) & 0x00f8);
  455. Data[9] = 0;
  456.     RTDWrite(Data);
  458. #endif
  459.     Wait_For_Event(EVENT_IEN_START);
  461.     Data[0] = 4;
  462.     Data[1] = N_INC;
  463.     Data[2] = IV_DV_LINES_38;
  464.     Data[3] = (unsigned char)usDV_Temp;
  465.     Data[4] = 5;    
  466.     Data[5] = Y_INC;
  467.     Data[6] = IPV_ACT_STA_0A;
  468.     Data[7] = (unsigned char)usIV_Temp;
  469.     Data[8] = (unsigned char)(usIV_Temp >> 8);
  470.     Data[9] = 0;
  471.     RTDWrite(Data);
  474. #if(PANEL_TYPE == PANEL_HANDAI)
  475.     //restore DH_Total
  476. usDHT = usDHT - 0x40;
  477.     Wait_For_Event(EVENT_DEN_STOP);
  478. Data[0] = 5;
  479.     Data[1] = Y_INC;
  480.     Data[2] = 0x22;
  481.     Data[3] = (unsigned char)((usDHT>>5) & 0x00fe);
  482. Data[4] = (unsigned char)((usDHT>>13) & 0x0007);
  483. Data[5] = 4;
  484. Data[6] = Y_INC;
  485. Data[7] = 0x2e;
  486. Data[8] = (Data[15] & 0x07) | ((usDHT<<2) & 0x00f8);
  487. Data[9] = 0;
  488.     RTDWrite(Data);
  489. #endif
  491.     Wait_For_Event(EVENT_IEN_START);
  494. RTDSetByte(STATUS0_01, 0x00);  // Clear status
  495.     RTDSetByte(STATUS1_1F, 0x00);  // Clear status
  498. #if(AS_NON_FRAMESYNC)
  499.     if(bFrameSync && bStable)
  500.         RTDSetBit(ODD_CTRL_8E,0xef,0x10);
  501. #endif
  502. }
  503. */
  504. void Set_Clock(void)
  505. {
  506.     unsigned char   ucM_Code, ucN_Code, ucTemp0, ucTemp1, ucResult;
  508.     // Issac :
  509.     // In this F/W, the frequency of PLL1 is fixed to 24.576*19/2=233.472MHz.
  510.     // Our goal is to find the best M/N settings of PLL2 according to the relationship below
  511.     // Best Fav = 233.472 * 32 / 31 = 241.003Mhz, and pixel rate = Fav * M / N
  512.     // Too small or large N code will cause larger jitter of ADC clock.
  513.     // In this F/W, I limite N code value between 16 and 31.
  515.     unsigned int    usClock = usADC_Clock + (unsigned int)stMUD.CLOCK - 128;    // Pixel clock number
  516.     unsigned long   ulRate  = (unsigned long)24576 * usClock / usStdHS;         // Pixel clock in kHz
  518. #if(AS_PLL_NONLOCK)
  519.     RTDSetBit(ODD_CTRL_8E,0xdf,0x00);
  520. #endif
  522. #if(AS_NON_FRAMESYNC)
  523.     RTDSetBit(ODD_CTRL_8E,0xef,0x00);
  524. #endif
  526. #if (TUNE_APLL)
  527.     RTDSetBit(DV_TOTAL_STATUS_3D, 0xdf, 0x00);//Disable PE Max Measurement
  528.     RTDSetByte(DV_TOTAL_STATUS_3D,0x40); //clear PE Max value
  529.     ucPE_Max = 0;
  530. #endif
  532. /*
  534.     ((unsigned int *)Data)[0]  = 375;
  536.     ucM_Code    = 0;
  537.     ucN_Code    = 0;
  538.     ucResult    = 0;
  539.     ucTemp0     = 7;
  540.     do
  541.     {
  542.         ucTemp1 = ulRate * ucTemp0 / 241003;
  544.         if (2 <= ucTemp1)
  545.         {
  546.             ((unsigned long *)Data)[2]  = ulRate * ucTemp0 / ucTemp1;
  547.             
  548.             ((unsigned int *)Data)[1]   = (unsigned long)3735552000 / ((unsigned long *)Data)[2];
  550.             if (15500 <= ((unsigned int *)Data)[1])
  551.             {
  552.                 if (15700 >= ((unsigned int *)Data)[1])
  553.                 {
  554.                     if (0 != ucResult || (((unsigned long)usClock * ucTemp0 / ucTemp1) * ucTemp1) != ((unsigned long)usClock * ucTemp0))
  555.                     {
  556.                         ucN_Code    = ucTemp0;
  557.                         ucM_Code    = ucTemp1;
  558.                         break;
  559.                     }
  560.                 }
  562.                 ((unsigned int *)Data)[1]   = ((unsigned int *)Data)[1] - 15500;
  563.             }
  564.             else
  565.             {
  566.                 if (15375 <= ((unsigned int *)Data)[1])
  567.                 {
  568.                     if (0 != ucResult || (((unsigned long)usClock * ucTemp0 / ucTemp1) * ucTemp1) != ((unsigned long)usClock * ucTemp0))
  569.                     {
  570.                         ucN_Code    = ucTemp0;
  571.                         ucM_Code    = ucTemp1;
  572.                         break;
  573.                     }
  574.                 }
  575.                 
  576.                 ((unsigned int *)Data)[1]   = 15500 - ((unsigned int *)Data)[1];
  577.             }
  578.             
  579.             if (((unsigned int *)Data)[0] > ((unsigned int *)Data)[1])
  580.             {
  581.                 ((unsigned int *)Data)[0]   = ((unsigned int *)Data)[1];
  583.                 ucN_Code    = ucTemp0;
  584.                 ucM_Code    = ucTemp1;
  585.             }
  586.         }
  588.         ucTemp1 = ucTemp1 + 1;
  590.         if (2 <= ucTemp1)
  591.         {
  592.             ((unsigned long *)Data)[2]  = ulRate * ucTemp0 / ucTemp1;
  594.             ((unsigned int *)Data)[1]   = (unsigned long)3735552000 / ((unsigned long *)Data)[2];
  596.             if (15500 <= ((unsigned int *)Data)[1])
  597.             {
  598.                 if (15700 >= ((unsigned int *)Data)[1])
  599.                 {
  600.                     if (0 != ucResult || (((unsigned long)usClock * ucTemp0 / ucTemp1) * ucTemp1) != ((unsigned long)usClock * ucTemp0))
  601.                     {
  602.                         ucN_Code    = ucTemp0;
  603.                         ucM_Code    = ucTemp1;
  604.                         break;
  605.                     }
  606.                 }
  608.                 ((unsigned int *)Data)[1]   = ((unsigned int *)Data)[1] - 15500;
  609.             }
  610.             else
  611.             {
  612.                 if (15375 <= ((unsigned int *)Data)[1])
  613.                 {
  614.                     if (0 != ucResult || (((unsigned long)usClock * ucTemp0 / ucTemp1) * ucTemp1) != ((unsigned long)usClock * ucTemp0))
  615.                     {
  616.                         ucN_Code    = ucTemp0;
  617.                         ucM_Code    = ucTemp1;
  618.                         break;
  619.                     }
  620.                 }
  621.                 
  622.                 ((unsigned int *)Data)[1]   = 15500 - ((unsigned int *)Data)[1];
  623.             }
  625.             if (((unsigned int *)Data)[0] > ((unsigned int *)Data)[1])
  626.             {
  627.                 ((unsigned int *)Data)[0]   = ((unsigned int *)Data)[1];
  629.                 ucN_Code    = ucTemp0;
  630.                 ucM_Code    = ucTemp1;
  631.             }
  632.         }
  634.         if (0 == ucResult)
  635.         {
  636.             if (43 < ucTemp0 && 60000 < ulRate)
  637.             {
  638.                 ucTemp0     = 10;
  639.                 ucResult    = 1;
  641.                 ((unsigned int *)Data)[0]  = 500;
  642.             }
  643.         }
  644.         else
  645.         {
  646.             if (36 < ucTemp0 && 200 > ((unsigned int *)Data)[0])
  647.             {
  648.                 break;
  649.             }
  650.         }
  651.     }
  652.     while (53 >= ++ucTemp0);
  654.     if (8 >= ucN_Code)
  655.     {
  656.         ucN_Code    = ucN_Code * 3;
  657.         ucM_Code    = ucM_Code * 3;
  658.     }
  659.     else if (12 >= ucN_Code)
  660.     {
  661.         ucN_Code    = ucN_Code * 2;
  662.         ucM_Code    = ucM_Code * 2;
  663.     }
  665.     usClock     = usClock - 1;
  667.     Wait_For_Event(EVENT_IEN_STOP);
  669.     RTDSetByte(I_CODE_MB_CA, 0x18);
  670.     RTDSetByte(I_CODE_LB_C9, 0x00);
  671.     RTDSetByte(P_CODE_CB, 0x18);
  673.     Data[0]     = 5;
  674.     Data[1]     = Y_INC;
  675.     Data[2]     = PLL1_M_D7;
  676.     Data[3]     = 0x11;
  677.     Data[4]     = 0x00;
  678.     Data[5]     = 0;
  679.     RTDWrite(Data);
  681. */
  683.     ((unsigned int *)Data)[0]  = 500;
  685.     ucM_Code    = 0;
  686.     ucN_Code    = 0;
  687.     ucResult    = 0;
  688.     ucTemp0     = 7;
  689.     do
  690.     {
  691.         //Fav * PLL2_M / PLL2_N = ulRate
  692.         //PLL2_M = ulRate * PLL2_N / Fav;
  693.         //ucTemp1 = ulRate * ucTemp0 / 253687;// (20/2 * 24.576 *32/31)
  694.         ucTemp1 = ulRate * ucTemp0 / 215634;// (17/2 * 24.576 *32/31)
  696.         if (2 <= ucTemp1)
  697.         {   //Fav = ulRate * PLL2_N / PLL2_M
  698.             ((unsigned long *)Data)[2]  = ulRate * ucTemp0 / ucTemp1;
  699.                                                         //(20/2 * 24.576 * 16)
  700. //((unsigned int *)Data)[1]   = (unsigned long)393216000 / ((unsigned long *)Data)[2];
  701.             ((unsigned int *)Data)[1]   = (unsigned long)334223600 / ((unsigned long *)Data)[2];
  702.             // > 31/2 = 15.5
  703.             if (1550 <= ((unsigned int *)Data)[1])
  704.             {
  705.                 if (1570 >= ((unsigned int *)Data)[1])
  706.                 {
  707.                     ucN_Code    = ucTemp0;
  708.                     ucM_Code    = ucTemp1;
  709.                     break;
  710.                 }
  712.                 ((unsigned int *)Data)[1]   = ((unsigned int *)Data)[1] - 1550;
  713.             }
  714.             else //