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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > DVD > 查看源码
UartTxd.c
资源名称：8202s_8281s_050405_dvd_622.rar　[点击查看]
上传用户：caisangzi8
上传日期：2013-10-25
资源大小：15756k
文件大小：41k
源码类别：

DVD

开发平台：

C/C++

UartTxd.c：源码内容
  1. //Kenny 2002/7/16 for UART to communicate with external MCU
  3. #include "global.h"
  4. #include "uart.h"
  5. #include "uartfifo.h"
  6. #include "osd.h"
  7. #include "iop.h"
  8. #include "setup.h"
  9. #include "UartTxd.h"
  10. #include "func.h"
  11. #include "user_init.h"
  13. //#define OSD_DBG_TXD
  14. //#define UART_DBG_TXD
  16. /////////////////////////////////////////////////////////////
  17. // Maybe software UART would be used to communicate with 8051.
  18. // Now I use it to print debug message.
  20. #ifdef SOFT_UART_OUT
  21. extern int PutSoftUartChar(BYTE *, int);
  22. extern int GetSoftUartChar(BYTE *, int);
  24. #define PutString(x, y) PutSoftUartChar(x, y)
  25. #define GetString(x, y) GetSoftUartChar(x, y)
  27. #else
  29. #define PutString(x, y) 0
  30. #define PutString(x, y) 0
  32. #endif
  33. //////////////////////////////////////////////////////
  34. #ifdef SERVO_UART
  35. extern UINT8 gcRS232Data[5];
  36. extern UINT8 gwWPtr;
  37. extern UINT8 cReveiveRs232,cTranRs232;
  39. void reset_uart_servo(void)
  40. {
  41.     UART1_set_baudrate(UART_BAUD_88200);
  42.     //UART1_set_baudrate(UART_BAUD_44100);
  43. }
  46. extern void RS232SevoLink(UINT8 cmd);
  48. int pollingUARTServo(void)
  49. {
  51. #if 0
  52. if ( cTranRs232==1 )
  53. {
  54.      cTranRs232 = 0;
  56.          gcParam0 = 0x00;//UL_BYTE3(dwTargetPBA);
  57.          gcParam1 = 0x0a;//UL_BYTE2(dwTargetPBA);
  58.          gcParam2 = 0x00;//UL_BYTE1(dwTargetPBA);
  59.          gcParam3 = 0x00;//UL_BYTE0(dwTargetPBA);
  60.  
  61.  //RS232SevoLink(55);  // Start-Up
  62.  RS232SevoLink(11);  // Seek
  64.  return 0;
  65. }
  66. #endif
  68.   while (UART1_rx_rdy())
  69.   {
  70.       gcRS232Data[gwWPtr] = (regs0->uart1_data);
  71.   //printf("Rcv : %xn",gcRS232Data[gwWPtr]);
  72.   //io_write("R");  
  73.   if (gwWPtr >= 2)
  74.   {
  75. cReveiveRs232 = 1;
  76. gwWPtr = 0;
  77. //io_write("U2n");  
  78.   }
  79.   else
  80.   {
  81. cReveiveRs232 = 0;
  82.     gwWPtr ++;
  83.   }
  84.   }
  86. return 0;
  87. }
  88. #endif   
  91. #ifdef SUPPORT_UART_COMMAND
  93. #ifndef NEW_UART_COMMAND   //CONTROL VALUE
  94. int nInputLevel = 0;
  95. BYTE aryCommandBuf[UART_REV_MAX_BYTE];
  96. BYTE aryTXDBuf[UART_TXD_MAX_BYTE];
  98. int nCommandIndex = 0;
  99. int nCommandSize;
  101. // for sending
  102. #ifdef UART_DBG_TXD
  103. BYTE aryDbgBuf[UART_REV_MAX_BYTE];
  104. #endif
  106. // temporary initialize some global variables here. The values should be set from 51
  107. BYTE nCurrentDVDMode = MODE_DVD;
  108. BYTE nCurrentVolMode = VOL_MODE_MAIN;
  109. BYTE nMainVol = 8;
  110. BYTE nFrontVol = 8;
  111. BYTE nCenterVol = 8;
  112. BYTE nRearVol = 8;
  113. int nMainLRBalance = 0;
  114. int nSurLRBalance = 0;
  115. BYTE nQSEffect = 4;
  116. BYTE nTreble = 8;
  117. BYTE nBass = 8;
  119. #else    //NEW UART CONTROL VALUE
  121. int nInputLevel = 0;
  122. BYTE aryCommandBuf[UART_REV_MAX_BYTE];
  123. BYTE aryTXDBuf[UART_TXD_MAX_BYTE];
  125. int nCommandIndex = 0;
  126. int nCommandSize;
  128. // for sending
  129. #ifdef UART_DBG_TXD
  130. BYTE aryDbgBuf[UART_REV_MAX_BYTE];
  131. #endif
  133. // temporary initialize some global variables here. The values should be set from 51
  134. BYTE nCurrentDVDMode = MODE_DVD;
  135. BYTE nCurrentVolMode = VOL_MODE_MAIN;
  136. BYTE nMainVol = MAINVOL;
  137. int  nFrontVol = FRONTVOL;
  138. int  nCenterVol = CENTERVOL;
  139. int  nRearVol = REARVOL;
  140. int  nSubwooferVol=SUBWOOFERVOL;
  141. int nMainBalance_L= MAINBALANCE_L;
  142. int nMainBalance_R= MAINBALANCE_R;
  143. int nSurBalance_L= SURBALANCE_L;
  144. int nSurBalance_R= SURBALANCE_R;
  145. BYTE nQSEffect = QSEFFECT;
  146. int nTreble = TREBLEVOL;
  147. int nBass = BASSVOL;
  148. #endif       //END IF DEFINE VALUE
  149. void uart_io_write_wait(const char *s);
  151. #define hex2asc(x) (((x)>=10)?(x)+'A'-10:(x)+'0')
  153. char asc2hex(char c)
  154. {
  155.     if ((c >= '0') && (c < '9' + 1))
  156.         return c - '0';
  157.     if ((c >= 'A') && (c < 'F' + 1))
  158.         return c - 'A' + 10;
  159.     if ((c >= 'a') && (c < 'f' + 1))
  160.         return c - 'a' + 10;
  161.     return 0;
  162. }
  165. void uart_io_write_wait(const char *s)
  166. {
  167.     int  c;
  168.     while ((c = *s++) != 0)
  169.     {
  170.         IO_PUTC_WAIT(c);
  171.     }
  172. }
  175. #define UART_PUTS(s...) 
  176. do { 
  177.    psprintf(linebuf, ##s); uart_io_write_wait(linebuf); 
  178. } while (0)
  180. #define TO_8051_PUTS(s...) 
  181. do { 
  182.    psprintf(linebuf, "X %s",##s); uart_io_write_wait(linebuf); 
  183. } while (0)
  186. void putdec(char c)
  187. {
  188.     if (c >= 100)
  189.     {
  190.         UART_PUTC(hex2asc(c / 100));
  191.         c = c % 100;
  192.     }
  193.     if (c >= 10)
  194.     {
  195.         UART_PUTC(hex2asc(c / 10));
  196.         c = c % 10;
  197.     }
  198.     else
  199.         UART_PUTC('0');
  200.     UART_PUTC(hex2asc(c));
  201. }
  203. void puthex(BYTE b)
  204. {
  205.     UART_PUTS(" 0x");
  206. UART_PUTC(hex2asc(b >> 4));
  207. UART_PUTC(hex2asc(b & 0xF));
  208. UART_PUTC(' ');
  209. }
  211. void reset_uart(void)
  212. {
  213.     //UART1_set_baudrate(UART_BAUD_115200);
  214.     UART1_set_baudrate(UART_BAUD_9600);
  215. }
  217. void Inform_MCUOK(void)
  218. {// send power-on command to 8051
  219. //BYTE i;           //we send 10 times
  220. // for(i=0;i<5;i++)
  221.     // {  
  222. UART_PUTC_EXACT(COMMAND_START);
  223. UART_PUTC_EXACT(POWER_ON);
  224. UART_PUTC_EXACT(POWER_ON_OK);
  225. UART_PUTC_EXACT(COMMAND_END);     
  226. //delay_1ms(10);
  227.     //} 
  228. } 
  229. int pollingUART51(void)
  230. {
  231.     while (!IsUARTRxEmpty())
  232.     {
  233.         BYTE c = UART_GETC();
  235.         PutString(&c, 1);
  237.         switch (nInputLevel)
  238.         {
  239.         case 0:
  240.             if (COMMAND_START == c)
  241.             {
  242.                 nInputLevel = 1;
  243.                 nCommandIndex = 0;
  244.                 nCommandSize = 0;
  245.             }
  246.             break;
  248.         case 1:
  249.             if ((COMMAND_END == c) || (nCommandIndex >= UART_REV_MAX_BYTE))
  250.             {
  251.                 nInputLevel = 0;
  252.                 nCommandSize = nCommandIndex;
  253.                 return 1;
  254.             }
  255.             else
  256.                 aryCommandBuf[nCommandIndex++] = c;
  258.         default:
  259.             break;
  260.         }
  261.     }
  262.     return 0;
  263. }
  265. void do_uart_command(void)
  266. {
  267.     int i;
  269. #ifdef UART_DBG_TXD
  270.     PutString("nrEXC--", 7);
  271. #endif
  273. #ifdef UART_DBG_TXD
  274.     for (i = 0; i < nCommandSize; i++)
  275.     {
  276.         puthex(aryCommandBuf[i]);
  277.         PutString(" ", 1);
  278.     }
  279.     PutString("nr", 2);
  280. #endif
  282. #ifdef OSD_DBG_TXD
  283. /*
  284.     for (i = nCommandSize; i < UART_REV_MAX_BYTE; i++)
  285. aryCommandBuf[i] = 0;
  286.     
  287.   if((aryCommandBuf[0] == 0x01) && (aryCommandBuf[1] == 0x02) && (aryCommandBuf[2] == 0x03) && (aryCommandBuf[3] == 0x04) && 
  288.   (aryCommandBuf[4] == 0x05) && (aryCommandBuf[5] == 0x06) && (aryCommandBuf[6] == 0x07) && (aryCommandBuf[7] == 0x08) && 
  289.   (aryCommandBuf[8] == 0x09) && (aryCommandBuf[9] == 0x0a) && (aryCommandBuf[10] == 0x0b) && (aryCommandBuf[11] == 0x0c) &&
  290.   (aryCommandBuf[12] == 0x0d) && (aryCommandBuf[13] == 0x0e) && (aryCommandBuf[14] == 0x0f))
  291.   {
  292.   //psprintf(RegionValStr[REGION1],"EXC %02x:%02x:%02x:%02x:%02x",aryCommandBuf[1],aryCommandBuf[2],aryCommandBuf[3],aryCommandBuf[4],aryCommandBuf[5]);
  293.   psprintf(RegionValStr[REGION1], "OK");
  294.   PrintOsdMsg(STR_OS_SPACE,REGION1, 1, 1);
  295.   }
  296.   else
  297.   {
  298.   //psprintf(RegionValStr[REGION1],"EXC %02x:%02x:%02x:%02x:%02x",aryCommandBuf[1],aryCommandBuf[2],aryCommandBuf[3],aryCommandBuf[4],aryCommandBuf[5]);
  299.   psprintf(RegionValStr[REGION1], "NG");
  300.   PrintOsdMsg(STR_OS_SPACE,REGION1, 1, 1);
  301.   }
  302. */
  303. #endif
  305.     switch (aryCommandBuf[0])
  306.     {
  307.     case DIGI_ELEC_VAL:
  308.         // show aryCommandBuf[1] (volume value) on VFD for 3 seconds
  309.         nCurrentVolMode=VOL_MODE_MAIN;
  310.         nMainVol = aryCommandBuf[1];
  311.         psprintf(RegionValStr[REGION1], "MAIN VOL %d",aryCommandBuf[1]);
  312.         PrintOsdMsg(STR_OS_SPACE, REGION1, 2, 1);
  313.         do_updata_vfd_vol();
  314.         break;
  316.     case ELEC_VOL:
  317.         // get aryCommandBuf[1] (TOTAL_VOL), aryCommandBuf[2] (FRONT_VOL), aryCommandBuf[3] (CENT_VOL),
  318.         // aryCommandBuf[4] (REAR_VOL), aryCommandBuf[5] (FRONT_BALANCE), aryCommandBuf[6] (READ_BALANCE),
  319.         // aryCommandBuf[7] (QS_EFFECT), aryCommandBuf[8] (TREBLE_EFFECT), aryCommandBuf[9] (BASS_EFFECT)
  320.         nMainVol = aryCommandBuf[1];
  321. #ifndef  NEW_UART_COMMAND  
  322.         nFrontVol = aryCommandBuf[2];
  323.         nCenterVol = aryCommandBuf[3];
  324.         nRearVol = aryCommandBuf[4];
  325.         nMainLRBalance = aryCommandBuf[5];
  326.         nSurLRBalance = aryCommandBuf[6];
  327.         nQSEffect = aryCommandBuf[7];
  328.         nTreble = aryCommandBuf[8];
  329.         nBass = aryCommandBuf[9];
  330. #else
  331.         if(aryCommandBuf[2]&0x80)
  332. nFrontVol=(0-(aryCommandBuf[2]&0x0f));
  333.         else
  334. nFrontVol=((aryCommandBuf[2]&0x0f));
  335.         if(aryCommandBuf[3]&0x80)
  336. nCenterVol=(0-(aryCommandBuf[3]&0x0f));
  337.         else
  338. nCenterVol=((aryCommandBuf[3]&0x0f));
  339.         if(aryCommandBuf[4]&0x80)
  340. nRearVol=(0-(aryCommandBuf[4]&0x0f));
  341.         else
  342. nRearVol=((aryCommandBuf[4]&0x0f));   
  343.         
  344.         if(aryCommandBuf[5]&0x80)
  345. nSubwooferVol= (0-(aryCommandBuf[5]&0x0f));
  346.         else
  347. nSubwooferVol= (aryCommandBuf[5]&0x0f);
  348.         if(aryCommandBuf[6]&0x80)
  349. nMainBalance_L= (0-(aryCommandBuf[6]&0x0f));
  350.         else
  351. nMainBalance_L= (aryCommandBuf[6]&0x0f);
  352.         if(aryCommandBuf[7]&0x80)
  353. nMainBalance_R= (0-(aryCommandBuf[7]&0x0f));
  354.         else
  355. nMainBalance_R= (aryCommandBuf[7]&0x0f);
  356.         if(aryCommandBuf[8]&0x80)
  357. nSurBalance_L= (0-(aryCommandBuf[8]&0x0f));
  358.         else
  359. nSurBalance_L= (aryCommandBuf[8]&0x0f);
  360.         if(aryCommandBuf[9]&0x80)
  361. nSurBalance_R= (0-(aryCommandBuf[9]&0x0f));
  362.         else
  363. nSurBalance_R= (aryCommandBuf[9]&0x0f);
  364.         nQSEffect = aryCommandBuf[10];
  365.         if(aryCommandBuf[11]&0x80)
  366. nTreble=(0-(aryCommandBuf[11]&0x0f));
  367.         else
  368. nTreble = (aryCommandBuf[11]&0x0f);
  369.         if(aryCommandBuf[12]&0x80)
  370. nBass=(0-(aryCommandBuf[12]));
  371.         else
  372. nBass = (aryCommandBuf[12]&0x0f);
  373. #endif
  374. #if 1
  375.         psprintf(RegionValStr[REGION3], "%d %d %d %d %d %d %d %d %d %d %d %d",
  376. nMainVol, nFrontVol, nCenterVol,
  377. nRearVol, nSubwooferVol, nMainBalance_L,
  378. nMainBalance_R, nSurBalance_L, nSurBalance_R,
  379. nQSEffect,nTreble,nBass);
  380.         PrintOsdMsg(STR_OS_SPACE, REGION3, 2, 1);
  381. #endif
  382.         break;
  384.     default:
  385.         break;
  386.     }
  387. }
  388. #ifndef NEW_UART_COMMAND
  389. void IRSwitchMode()
  390. {
  391.     BYTE bModeChanged = 0;
  393.     if (action_click)
  394.     {
  395.         bModeChanged = 1;
  396.         if (MODE_DVD == nCurrentDVDMode)
  397.             nCurrentDVDMode = MODE_AV1;
  398.         else
  399.             nCurrentDVDMode++;
  400.     }
  402.     switch (nCurrentDVDMode)
  403.     {
  404.     case MODE_AV1:
  405.         psprintf(RegionValStr[REGION1], "AV1 MODE");
  406.         // send mode command to 8051
  407.         if (bModeChanged)
  408.         {
  409.             UART_PUTC_EXACT(COMMAND_START);
  410.             UART_PUTC_EXACT(AV_MODE);
  411.             UART_PUTC_EXACT(AV1_MODE);
  412.             UART_PUTC_EXACT(COMMAND_END);
  413. //            aryDbgBuf[0] = COMMAND_START;
  414. //            aryDbgBuf[1] = AV_MODE;
  415. //            aryDbgBuf[2] = AV1_MODE;
  416. //            aryDbgBuf[3] = COMMAND_END;
  417. //            PutString(aryDbgBuf, 4);
  419. #ifdef OSD_DBG_TXD
  420.             psprintf(RegionValStr[REGION3], "SEND 8051 AV1_MODE");
  421.             PrintOsdMsg(STR_OS_SPACE, REGION3, 1, 1);
  422. #endif
  423.         }
  424.         break;
  426.     case MODE_AV2:
  427.         psprintf(RegionValStr[REGION1], "AV2 MODE");
  428.         // send mode command to 8051
  429.         if (bModeChanged)
  430.         {
  431.             UART_PUTC_EXACT(COMMAND_START);
  432.             UART_PUTC_EXACT(AV_MODE);
  433.             UART_PUTC_EXACT(AV2_MODE);
  434.             UART_PUTC_EXACT(COMMAND_END);
  436. #ifdef OSD_DBG_TXD
  437.             psprintf(RegionValStr[REGION3], "SEND 8051 AV2_MODE");
  438.             PrintOsdMsg(STR_OS_SPACE, REGION3, 1, 1);
  439. #endif
  440.         }
  441.         break;
  443.     case MODE_TUNER:
  444.         psprintf(RegionValStr[REGION1], "TUNER MODE");
  445.         // send mode command to 8051
  446.         if (bModeChanged)
  447.         {
  448.             UART_PUTC_EXACT(COMMAND_START);
  449.             UART_PUTC_EXACT(AV_MODE);
  450.             UART_PUTC_EXACT(TUNER_MODE);
  451.             UART_PUTC_EXACT(COMMAND_END);
  453. #ifdef OSD_DBG_TXD
  454.             psprintf(RegionValStr[REGION3], "SEND 8051 TUNER_MODE");
  455.             PrintOsdMsg(STR_OS_SPACE, REGION3, 1, 1);
  456. #endif
  457.         }
  458.         break;
  460.     case MODE_DVD:
  461.         psprintf(RegionValStr[REGION1], "DVD MODE");
  462.         // send mode command to 8051
  463.         if (bModeChanged)
  464.         {
  465.             UART_PUTC_EXACT(COMMAND_START);
  466.             UART_PUTC_EXACT(AV_MODE);
  467.             UART_PUTC_EXACT(DVD_MODE);
  468.             UART_PUTC_EXACT(COMMAND_END);
  470. #ifdef OSD_DBG_TXD
  471.             psprintf(RegionValStr[REGION3], "SEND 8051 DVD_MODE");
  472.             PrintOsdMsg(STR_OS_SPACE, REGION3, 1, 1);
  473. #endif
  474.         }
  475.         break;
  477.     default:
  478.         return;
  479.     }
  480.     PrintOsdMsg(STR_OS_SPACE, REGION1, 3, 1);
  481. }
  483. void IRSwitchVolMode()
  484. {
  485.     BYTE bModeChanged = 0;
  487.     if (action_click)
  488.     {
  489.         bModeChanged = 1;
  490.         if (VOL_MODE_BASS == nCurrentVolMode)
  491.             nCurrentVolMode = VOL_MODE_MAIN;
  492.         else
  493.             nCurrentVolMode++;
  494.     }
  496.     switch (nCurrentVolMode)
  497.     {
  498.     case VOL_MODE_MAIN:
  499.         psprintf(RegionValStr[REGION1], "VOLUME MODE MAIN: %d", nMainVol);
  500.         break;
  502.     case VOL_MODE_FRONT:
  503.         psprintf(RegionValStr[REGION1], "VOLUME MODE FRONT: %d", nFrontVol);
  504.         break;
  506.     case VOL_MODE_CENTER:
  507.         psprintf(RegionValStr[REGION1], "VOLUME MODE CENTER: %d", nCenterVol);
  508.         break;
  510.     case VOL_MODE_REAR:
  511.         psprintf(RegionValStr[REGION1], "VOLUME MODE REAR: %d", nRearVol);
  512.         break;
  514.     case VOL_MODE_MAIN_LR_BALANCE:
  515.         psprintf(RegionValStr[REGION1], "MAIN_LR_BALANCE: %d", nMainLRBalance);
  516.         break;
  518.     case VOL_MODE_SUR_LR_BALANCE:
  519.         psprintf(RegionValStr[REGION1], "SUR_LR_BALANCE: %d", nSurLRBalance);
  520.         break;
  522.     case VOL_MODE_QS_EFFECT:
  523.         psprintf(RegionValStr[REGION1], "QS EFFECT: %d", nQSEffect);
  524.         break;
  526.     case VOL_MODE_TREBLE:
  527.         psprintf(RegionValStr[REGION1], "TREBLE: %d", nTreble);
  528.         break;
  530.     case VOL_MODE_BASS:
  531.         psprintf(RegionValStr[REGION1], "BASS: %d", nBass);
  532.         break;
  534.     default:
  535.         return;
  536.     }
  537.     PrintOsdMsg(STR_OS_SPACE, REGION1, 3, 1);
  538. }
  540. void IRAdjustVol(int nUpOrDown) // 1:up, 0:down
  541. {
  542.     BYTE bVolChanged = 0;
  544.     if (action_click)
  545.         bVolChanged = 1;
  547.     switch (nCurrentVolMode)
  548.     {
  549.     case VOL_MODE_MAIN:
  550.         if (bVolChanged)
  551.         {
  552.             if ((1 == nUpOrDown) && (nMainVol < VOL_MAX))
  553.                 nMainVol++;
  554.             else if ((0 == nUpOrDown) && (nMainVol > VOL_MIN))
  555.                 nMainVol--;
  556.             else
  557.                 break;
  559.             // send volume change command to 8051
  560.             UART_PUTC_EXACT(COMMAND_START);
  561.             UART_PUTC_EXACT(TOTAL_VOL);
  562.             UART_PUTC_EXACT(nMainVol);
  563.             UART_PUTC_EXACT(COMMAND_END);
  565. #ifdef OSD_DBG_TXD
  566.             psprintf(RegionValStr[REGION3], "SEND 8051 MAIN VOL: -%d", nMainVol);
  567.             PrintOsdMsg(STR_OS_SPACE, REGION3, 1, 1);
  568. #endif
  569.         }
  570.         psprintf(RegionValStr[REGION1], "VOLUME MODE MAIN: -%d", nMainVol);
  571.         break;
  573.     case VOL_MODE_FRONT:
  574.         if (bVolChanged)
  575.         {
  576.             if ((1 == nUpOrDown) && (nFrontVol < VOL_MAX))
  577.                 nFrontVol++;
  578.             else if ((0 == nUpOrDown) && (nFrontVol > VOL_MIN))
  579.                 nFrontVol--;
  580.             else
  581.                 break;
  583.             // send volume change command to 8051
  584.             UART_PUTC_EXACT(COMMAND_START);
  585.             UART_PUTC_EXACT(FRONT_VOL);
  586.             UART_PUTC_EXACT(nFrontVol);
  587.             UART_PUTC_EXACT(COMMAND_END);
  589. #ifdef OSD_DBG_TXD
  590.             psprintf(RegionValStr[REGION3], "SEND 8051 FRONT VOL: -%d", nFrontVol);
  591.             PrintOsdMsg(STR_OS_SPACE, REGION3, 1, 1);
  592. #endif
  593.         }
  594.         psprintf(RegionValStr[REGION1], "VOLUME MODE FRONT: -%d", nFrontVol);
  595.         break;
  597.     case VOL_MODE_CENTER:
  598.         if (bVolChanged)
  599.         {
  600.             if ((1 == nUpOrDown) && (nCenterVol < VOL_MAX))
  601.                 nCenterVol++;
  602.             else if ((0 == nUpOrDown) && (nCenterVol > VOL_MIN))
  603.                 nCenterVol--;
  604.             else
  605.                 break;
  607.             // send volume change command to 8051
  608.             UART_PUTC_EXACT(COMMAND_START);
  609.             UART_PUTC_EXACT(CENT_VOL);
  610.             UART_PUTC_EXACT(nCenterVol);
  611.             UART_PUTC_EXACT(COMMAND_END);
  613. #ifdef OSD_DBG_TXD
  614.             psprintf(RegionValStr[REGION3], "SEND 8051 CENTER VOL: -%d", nCenterVol);
  615.             PrintOsdMsg(STR_OS_SPACE, REGION3, 1, 1);
  616. #endif
  617.         }
  618.         psprintf(RegionValStr[REGION1], "VOLUME MODE CENTER: -%d", nCenterVol);
  619.         break;
  621.     case VOL_MODE_REAR:
  622.         if (bVolChanged)
  623.         {
  624.             if ((1 == nUpOrDown) && (nRearVol < VOL_MAX))
  625.                 nRearVol++;
  626.             else if ((0 == nUpOrDown) && (nRearVol > VOL_MIN))
  627.                 nRearVol--;
  628.             else
  629.                 break;
  631.             // send volume change command to 8051
  632.             UART_PUTC_EXACT(COMMAND_START);
  633.             UART_PUTC_EXACT(REAR_VOL);
  634.             UART_PUTC_EXACT(nRearVol);
  635.             UART_PUTC_EXACT(COMMAND_END);
  637. #ifdef OSD_DBG_TXD
  638.             psprintf(RegionValStr[REGION3], "SEND 8051 REAR VOL: -%d", nRearVol);
  639.             PrintOsdMsg(STR_OS_SPACE, REGION3, 1, 1);
  640. #endif
  641.         }
  642.         psprintf(RegionValStr[REGION1], "VOLUME MODE REAR: -%d", nRearVol);
  643.         break;
  645.     case VOL_MODE_MAIN_LR_BALANCE:
  646.         if (bVolChanged)
  647.         {
  648.             if ((1 == nUpOrDown) && (nMainLRBalance < BALANCE_MAX))
  649.                 nMainLRBalance++;
  650.             else if ((0 == nUpOrDown) && (nMainLRBalance > BALANCE_MIN))
  651.                 nMainLRBalance--;
  652.             else
  653.                 break;
  655.             // send volume change command to 8051
  656.             UART_PUTC_EXACT(COMMAND_START);
  657.             UART_PUTC_EXACT(FRONT_BALANCE);
  658.             switch (nMainLRBalance)
  659.             {
  660.             case -1:
  661.                 UART_PUTC_EXACT(0x81);
  662.                 break;
  664.             case -2:
  665.                 UART_PUTC_EXACT(0x82);
  666.                 break;
  668.             case -3:
  669.                 UART_PUTC_EXACT(0x83);
  670.                 break;
  672.             default:
  673.                 UART_PUTC_EXACT((BYTE)nMainLRBalance);
  674.                 break;
  675.             }
  676.             UART_PUTC_EXACT(COMMAND_END);
  678. #ifdef OSD_DBG_TXD
  679.             psprintf(RegionValStr[REGION3], "SEND 8051 FRONT LR BAL: %d", nMainLRBalance);
  680.             PrintOsdMsg(STR_OS_SPACE, REGION3, 1, 1);
  681. #endif
  682.         }
  683.         psprintf(RegionValStr[REGION1], "MAIN_LR_BALANCE: %d", nMainLRBalance);
  684.         break;
  686.     case VOL_MODE_SUR_LR_BALANCE:
  687.         if (bVolChanged)
  688.         {
  689.             if ((1 == nUpOrDown) && (nSurLRBalance < BALANCE_MAX))
  690.                 nSurLRBalance++;
  691.             else if ((0 == nUpOrDown) && (nSurLRBalance > BALANCE_MIN))
  692.                 nSurLRBalance--;
  693.             else
  694.                 break;
  696.             // send volume change command to 8051
  697.             UART_PUTC_EXACT(COMMAND_START);
  698.             UART_PUTC_EXACT(REAR_BALANCE);
  699.             switch (nSurLRBalance)
  700.             {
  701.             case -1:
  702.                 UART_PUTC_EXACT(0x81);
  703.                 break;
  705.             case -2:
  706.                 UART_PUTC_EXACT(0x82);
  707.                 break;
  709.             case -3:
  710.                 UART_PUTC_EXACT(0x83);
  711.                 break;
  713.             default:
  714.                 UART_PUTC_EXACT((BYTE)nSurLRBalance);
  715.                 break;
  716.             }
  717.             UART_PUTC_EXACT(COMMAND_END);
  719. #ifdef OSD_DBG_TXD
  720.             psprintf(RegionValStr[REGION3], "SEND 8051 SUR LR BAL: %d", nSurLRBalance);
  721.             PrintOsdMsg(STR_OS_SPACE, REGION3, 1, 1);
  722. #endif
  723.         }
  724.         psprintf(RegionValStr[REGION1], "SUR_LR_BALANCE: %d", nSurLRBalance);
  725.         break;
  727.     case VOL_MODE_QS_EFFECT:
  728.         if (bVolChanged)
  729.         {
  730.             if ((1 == nUpOrDown) && (nQSEffect < QS_MAX))
  731.                 nQSEffect++;
  732.             else if ((0 == nUpOrDown) && (nQSEffect > QS_MIN))
  733.                 nQSEffect--;
  734.             else
  735.                 break;
  737.             // send volume change command to 8051
  738.             UART_PUTC_EXACT(COMMAND_START);
  739.             UART_PUTC_EXACT(QS_EFFECT);
  740.             UART_PUTC_EXACT(nQSEffect);
  741.             UART_PUTC_EXACT(COMMAND_END);
  743. #ifdef OSD_DBG_TXD
  744.             psprintf(RegionValStr[REGION3], "SEND 8051 QS: %d", nQSEffect);
  745.             PrintOsdMsg(STR_OS_SPACE, REGION3, 1, 1);
  746. #endif
  747.         }
  748.         psprintf(RegionValStr[REGION1], "QS EFFECT: %d", nQSEffect);
  749.         break;
  751.     case VOL_MODE_TREBLE:
  752.         if (bVolChanged)
  753.         {
  754.             if ((1 == nUpOrDown) && (nTreble < VOL_MAX))
  755.                 nTreble++;
  756.             else if ((0 == nUpOrDown) && (nTreble > VOL_MIN))
  757.                 nTreble--;
  758.             else
  759.                 break;
  761.             // send volume change command to 8051
  762.             UART_PUTC_EXACT(COMMAND_START);
  763.             UART_PUTC_EXACT(TREBLE_EFFECT);
  764.             UART_PUTC_EXACT(nTreble);
  765.             UART_PUTC_EXACT(COMMAND_END);
  767. #ifdef OSD_DBG_TXD
  768.             psprintf(RegionValStr[REGION3], "SEND 8051 TREBLE: %d", nTreble);
  769.             PrintOsdMsg(STR_OS_SPACE, REGION3, 1, 1);
  770. #endif
  771.         }
  772.         psprintf(RegionValStr[REGION1], "TREBLE: %d", nTreble);
  773.         break;
  775.     case VOL_MODE_BASS:
  776.         if (bVolChanged)
  777.         {
  778.             if ((1 == nUpOrDown) && (nBass < VOL_MAX))
  779.                 nBass++;
  780.             else if ((0 == nUpOrDown) && (nBass > VOL_MIN))
  781.                 nBass--;
  782.             else
  783.                 break;
  785.             // send volume change command to 8051
  786.             UART_PUTC_EXACT(COMMAND_START);
  787.             UART_PUTC_EXACT(BASS_EFFECT);
  788.             UART_PUTC_EXACT(nBass);
  789.             UART_PUTC_EXACT(COMMAND_END);
  791. #ifdef OSD_DBG_TXD
  792.             psprintf(RegionValStr[REGION3], "SEND 8051 BASS: %d", nBass);
  793.             PrintOsdMsg(STR_OS_SPACE, REGION3, 1, 1);
  794. #endif
  795.         }
  796.         psprintf(RegionValStr[REGION1], "BASS: %d", nBass);
  797.         break;
  799.     default:
  800.         return;
  801.     }
  802.     PrintOsdMsg(STR_OS_SPACE, REGION1, 3, 1);
  803. }
  804. #else   //FOR NEW UART COMMAND
  805. void IRSwitchMode()
  806. {
  807.     //BYTE bModeChanged = 0;
  809. /* if (action_click)
  810.     {
  811. bModeChanged = 1;
  812. if (MODE_DVD == nCurrentDVDMode)
  813. nCurrentDVDMode = MODE_AV1;
  814. else
  815. nCurrentDVDMode++;
  816.     }
  817. */
  818.     switch (nCurrentDVDMode)
  819.     {
  820.     case MODE_AV1:
  821.         psprintf(RegionValStr[REGION1], "AV1 MODE");
  822.         // send mode command to 8051
  823.         //if (bModeChanged)
  824.         {
  825.             UART_PUTC_EXACT(COMMAND_START);
  826.             UART_PUTC_EXACT(AV1_MODE);
  827.             UART_PUTC_EXACT(AV1_MODE_D);
  828.             UART_PUTC_EXACT(COMMAND_END);
  829. //            aryDbgBuf[0] = COMMAND_START;
  830. //            aryDbgBuf[1] = AV_MODE;
  831. //            aryDbgBuf[2] = AV1_MODE;
  832. //            aryDbgBuf[3] = COMMAND_END;
  833. //            PutString(aryDbgBuf, 4);
  835. #ifdef OSD_DBG_TXD
  836.             psprintf(RegionValStr[REGION3], "SEND 8051 AV1_MODE");
  837.             PrintOsdMsg(STR_OS_SPACE, REGION3, 1, 1);
  838. #endif
  839.         }
  840.         break;
  842.     case MODE_AV2:
  843.         psprintf(RegionValStr[REGION1], "AV2 MODE");
  844.         // send mode command to 8051
  845.         //if (bModeChanged)
  846.         {
  847.             UART_PUTC_EXACT(COMMAND_START);
  848.             UART_PUTC_EXACT(AV2_MODE);
  849.             UART_PUTC_EXACT(AV2_MODE_D);
  850.             UART_PUTC_EXACT(COMMAND_END);
  852. #ifdef OSD_DBG_TXD
  853.             psprintf(RegionValStr[REGION3], "SEND 8051 AV2_MODE");
  854.             PrintOsdMsg(STR_OS_SPACE, REGION3, 1, 1);
  855. #endif
  856.         }
  857.         break;
  859.     case MODE_TUNER:
  860.         psprintf(RegionValStr[REGION1], "TUNER MODE");
  861.         // send mode command to 8051
  862. // if (bModeChanged)
  863.         {
  864.             UART_PUTC_EXACT(COMMAND_START);
  865.             UART_PUTC_EXACT(TUNER_MODE);
  866.             UART_PUTC_EXACT(TUNER_MODE_D);
  867.             UART_PUTC_EXACT(COMMAND_END);
  869. #ifdef OSD_DBG_TXD
  870.             psprintf(RegionValStr[REGION3], "SEND 8051 TUNER_MODE");
  871.             PrintOsdMsg(STR_OS_SPACE, REGION3, 1, 1);
  872. #endif
  873.         }
  874.         break;
  876.     case MODE_DVD:
  877.         psprintf(RegionValStr[REGION1], "DVD MODE");
  878.         // send mode command to 8051
  879.         //if (bModeChanged)
  880.         {
  881.             UART_PUTC_EXACT(COMMAND_START);
  882.             UART_PUTC_EXACT(DVD_MODE);
  883.             UART_PUTC_EXACT(DVD_MODE_D);
  884.             UART_PUTC_EXACT(COMMAND_END);
  886. #ifdef OSD_DBG_TXD
  887.             psprintf(RegionValStr[REGION3], "SEND 8051 DVD_MODE");
  888.             PrintOsdMsg(STR_OS_SPACE, REGION3, 1, 1);
  889. #endif
  890.         }
  891.         break;
  893.     default:
  894.         return;
  895.     }
  896.     PrintOsdMsg(STR_OS_SPACE, REGION1, 2, 1);
  897. }
  899. void IRSwitchVolMode()
  900. {
  901.     //BYTE bModeChanged = 0;
  903.     /*if (action_click)
  904.     {
  905. bModeChanged = 1;
  906. if (VOL_MODE_BASS == nCurrentVolMode)
  907. nCurrentVolMode = VOL_MODE_MAIN;
  908. else
  909. nCurrentVolMode++;
  910.     }
  911.     */
  912.     switch (nCurrentVolMode)
  913.     {
  914.     case VOL_MODE_MAIN:
  915.         psprintf(RegionValStr[REGION1], "MAIN VOL: %dDB", nMainVol);
  916.         break;
  918.     case VOL_MODE_FRONT:
  919.         psprintf(RegionValStr[REGION1], "FRONT VOL: %dDB", nFrontVol);
  920.         break;
  922.     case VOL_MODE_CENTER:
  923.         psprintf(RegionValStr[REGION1], "CENTER VOL: %dDB", nCenterVol);
  924.         break;
  926.     case VOL_MODE_REAR:
  927.         psprintf(RegionValStr[REGION1], "REAR VOL: %dDB", nRearVol);
  928.         break;
  929.     case VOL_MODE_SUBWOOFER:
  930.         psprintf(RegionValStr[REGION1],"SW VOL: %dDB",nSubwooferVol);
  931.         break ;
  932.     case VOL_MODE_MAIN_BALANCE_L:
  933.         psprintf(RegionValStr[REGION1], "BALANCE FL VOL: %dDB", nMainBalance_L);
  934.         break;
  936.     case VOL_MODE_MAIN_BALANCE_R:
  937.         psprintf(RegionValStr[REGION1], "BALANCE FR VOL: %dDB", nMainBalance_R);
  938.         break;
  939.     case VOL_MODE_SUR_BALANCE_L:
  940.         psprintf(RegionValStr[REGION1], "BALANCE SL VOL: %dDB", nSurBalance_L);
  941.         break;
  943.     case VOL_MODE_SUR_BALANCE_R:
  944.         psprintf(RegionValStr[REGION1], "BALANCE SR VOL: %dDB", nSurBalance_R);
  945.         break;
  947.     case VOL_MODE_QS_EFFECT:
  948.         psprintf(RegionValStr[REGION1], "QSOUND: %d", nQSEffect);
  949.         break;
  951.     case VOL_MODE_TREBLE:
  952.         psprintf(RegionValStr[REGION1], "TREBLE VOL: %dDB", 2*nTreble);
  953.         break;
  955.     case VOL_MODE_BASS:
  956.         psprintf(RegionValStr[REGION1], "BASS VOL: %dDB", 2*nBass);
  957.         break;
  959.     default:
  960.         return;
  961.     }
  962.     PrintOsdMsg(STR_OS_SPACE, REGION1, 2, 1);
  963.     do_updata_vfd_vol();
  964. }
  966. void IRAdjustVol(int nUpOrDown) // 1:up, 0:down
  967. {
  968.     BYTE bVolChanged = 0;
  970.     if (action_click||timeout_vfd)
  971.         bVolChanged = 1;
  972.     switch (nCurrentVolMode)
  973.     {
  974.     case VOL_MODE_MAIN:
  975.         if (bVolChanged)
  976.         {
  977.             if ((1 == nUpOrDown) && (nMainVol < VOL_MAX))
  978.                 nMainVol++;
  979.             else if ((0 == nUpOrDown) && (nMainVol > VOL_MIN))
  980.                 nMainVol--;
  981.             else
  982.                 break;
  984.             // send volume change command to 8051
  985.             UART_PUTC_EXACT(COMMAND_START);
  986.             UART_PUTC_EXACT(TOTAL_VOL);
  987.             UART_PUTC_EXACT(nMainVol);
  988.             UART_PUTC_EXACT(COMMAND_END);
  990. #ifdef OSD_DBG_TXD
  991.             psprintf(RegionValStr[REGION3], "SEND 8051 MAIN VOL: %d", nMainVol);
  992.             PrintOsdMsg(STR_OS_SPACE, REGION3, 1, 1);
  993. #endif
  994.         }
  995.         psprintf(RegionValStr[REGION1], "MAIN VOL: %dDB", nMainVol);
  996.         break;
  998.     case VOL_MODE_FRONT:
  999.         if (bVolChanged)
  1000.         {
  1001.             if ((1 == nUpOrDown) && (nFrontVol < VOL_ADJUST_MAN))
  1002.                 nFrontVol++;
  1003.             else if ((0 == nUpOrDown) && (nFrontVol > VOL_ADJUST_MIN))
  1004.                 nFrontVol--;
  1005.             else
  1006.                 break;
  1008.             // send volume change command to 8051
  1009.             UART_PUTC_EXACT(COMMAND_START);
  1010.             UART_PUTC_EXACT(FRONT_VOL);
  1011.             switch(nFrontVol)
  1012. {
  1013. case -6 :
  1014. UART_PUTC_EXACT(0x86);
  1015. break ;
  1016. case -5 :
  1017. UART_PUTC_EXACT(0x85);
  1018. break ;
  1019. case -4 :
  1020. UART_PUTC_EXACT(0x84);
  1021. break ;
  1022. case -3 :
  1023. UART_PUTC_EXACT(0x83);
  1024. break ;
  1025. case -2 :
  1026. UART_PUTC_EXACT(0x82);
  1027. break ;
  1028. case -1 :
  1029. UART_PUTC_EXACT(0x81);
  1030. break ;
  1031. default :
  1032. UART_PUTC_EXACT((BYTE)(nFrontVol));
  1033. break ; 
  1035. }
  1036.             //UART_PUTC_EXACT(nFrontVol);
  1037.             UART_PUTC_EXACT(COMMAND_END);
  1039. #ifdef OSD_DBG_TXD
  1040.             psprintf(RegionValStr[REGION3], "SEND 8051 FRONT VOL: %d", nFrontVol);
  1041.             PrintOsdMsg(STR_OS_SPACE, REGION3, 1, 1);
  1042. #endif
  1043.         }
  1044.         psprintf(RegionValStr[REGION1], "FRONT VOL: %dDB", nFrontVol);
  1045.         break;
  1047.     case VOL_MODE_CENTER:
  1048.         if (bVolChanged)
  1049.         {
  1050.             if ((1 == nUpOrDown) && (nCenterVol < VOL_ADJUST_MAN))
  1051.                 nCenterVol++;
  1052.             else if ((0 == nUpOrDown) && (nCenterVol > VOL_ADJUST_MIN))
  1053.                 nCenterVol--;
  1054.             else
  1055.                 break;
  1057.             // send volume change command to 8051
  1058.             UART_PUTC_EXACT(COMMAND_START);
  1059.             UART_PUTC_EXACT(CENT_VOL);
  1060.             switch(nCenterVol)
  1061. {
  1062. case -6 :
  1063. UART_PUTC_EXACT(0x86);
  1064. break ;
  1065. case -5 :
  1066. UART_PUTC_EXACT(0x85);
  1067. break ;
  1068. case -4 :
  1069. UART_PUTC_EXACT(0x84);
  1070. break ;
  1071. case -3 :
  1072. UART_PUTC_EXACT(0x83);
  1073. break ;
  1074. case -2 :
  1075. UART_PUTC_EXACT(0x82);
  1076. break ;
  1077. case -1 :
  1078. UART_PUTC_EXACT(0x81);
  1079. break ;
  1080. default :
  1081. UART_PUTC_EXACT((BYTE)(nCenterVol));
  1082. break ; 
  1084. }
  1085.             UART_PUTC_EXACT(COMMAND_END);
  1087. #ifdef OSD_DBG_TXD
  1088.             psprintf(RegionValStr[REGION3], "SEND 8051 CENTER VOL: %d", nCenterVol);
  1089.             PrintOsdMsg(STR_OS_SPACE, REGION3, 1, 1);
  1090. #endif
  1091.         }
  1092.         psprintf(RegionValStr[REGION1], "CENTER VOL: %dDB", nCenterVol);
  1093.         break;
  1095.     case VOL_MODE_REAR:
  1096.         if (bVolChanged)
  1097.         {
  1098.             if ((1 == nUpOrDown) && (nRearVol < VOL_ADJUST_MAN))
  1099.                 nRearVol++;
  1100.             else if ((0 == nUpOrDown) && (nRearVol > VOL_ADJUST_MIN))
  1101.                 nRearVol--;
  1102.             else
  1103.                 break;
  1105.             // send volume change command to 8051
  1106.             UART_PUTC_EXACT(COMMAND_START);
  1107.             UART_PUTC_EXACT(REAR_VOL);
  1108.             switch(nRearVol)
  1109. {
  1110. case -6 :
  1111. UART_PUTC_EXACT(0x86);
  1112. break ;
  1113. case -5 :
  1114. UART_PUTC_EXACT(0x85);
  1115. break ;
  1116. case -4 :
  1117. UART_PUTC_EXACT(0x84);
  1118. break ;
  1119. case -3 :
  1120. UART_PUTC_EXACT(0x83);
  1121. break ;
  1122. case -2 :
  1123. UART_PUTC_EXACT(0x82);
  1124. break ;
  1125. case -1 :
  1126. UART_PUTC_EXACT(0x81);
  1127. break ;
  1128. default :
  1129. UART_PUTC_EXACT((BYTE)(nRearVol));
  1130. break ; 
  1132. }
  1133.             UART_PUTC_EXACT(COMMAND_END);
  1135. #ifdef OSD_DBG_TXD
  1136.             psprintf(RegionValStr[REGION3], "SEND 8051 REAR VOL: %d", nRearVol);
  1137.             PrintOsdMsg(STR_OS_SPACE, REGION3, 1, 1);
  1138. #endif
  1139.         }
  1140.         psprintf(RegionValStr[REGION1], "REAR VOL: %dDB", nRearVol);
  1141.         break;
  1143. case VOL_MODE_SUBWOOFER:
  1144.         if (bVolChanged)
  1145.         {
  1146.             if ((1 == nUpOrDown) && (nSubwooferVol < VOL_ADJUST_MAN))
  1147.                 nSubwooferVol++;
  1148.             else if ((0 == nUpOrDown) && (nSubwooferVol > VOL_ADJUST_MIN))
  1149.                 nSubwooferVol--;
  1150.             else
  1151.                 break;
  1153.             // send volume change command to 8051
  1154.             UART_PUTC_EXACT(COMMAND_START);
  1155.             UART_PUTC_EXACT(SUBWOOFER_VOL);
  1156.             switch(nSubwooferVol)
  1157. {
  1158. case -6 :
  1159. UART_PUTC_EXACT(0x86);
  1160. break ;
  1161. case -5 :
  1162. UART_PUTC_EXACT(0x85);
  1163. break ;
  1164. case -4 :
  1165. UART_PUTC_EXACT(0x84);
  1166. break ;
  1167. case -3 :
  1168. UART_PUTC_EXACT(0x83);
  1169. break ;
  1170. case -2 :
  1171. UART_PUTC_EXACT(0x82);
  1172. break ;
  1173. case -1 :
  1174. UART_PUTC_EXACT(0x81);
  1175. break ;
  1176. default :
  1177. UART_PUTC_EXACT((BYTE)(nSubwooferVol));
  1178. break ; 
  1180. }
  1181.             UART_PUTC_EXACT(COMMAND_END);
  1183. #ifdef OSD_DBG_TXD
  1184.             psprintf(RegionValStr[REGION3], "SEND 8051 SW VOL: %d", nSubwooferVol);
  1185.             PrintOsdMsg(STR_OS_SPACE, REGION3, 1, 1);
  1186. #endif
  1187.         }
  1188.         psprintf(RegionValStr[REGION1], "SW VOL: %dDB", nSubwooferVol);
  1189.         break;
  1190.     case VOL_MODE_MAIN_BALANCE_L:
  1191.         if (bVolChanged)
  1192.         {
  1193.             if ((1 == nUpOrDown) && (nMainBalance_L < BALANCE_MAX))
  1194.                 nMainBalance_L++;
  1195.             else if ((0 == nUpOrDown) && (nMainBalance_L > BALANCE_MIN))
  1196.                 nMainBalance_L--;
  1197.             else
  1198.                 break;
  1200.             // send volume change command to 8051
  1201.             UART_PUTC_EXACT(COMMAND_START);
  1202.             UART_PUTC_EXACT(FRONT_BALANCE_L);
  1203.             switch (nMainBalance_L)
  1204.             {
  1205.             case -1:
  1206.                 UART_PUTC_EXACT(0x81);
  1207.                 break;
  1209.             case -2:
  1210.                 UART_PUTC_EXACT(0x82);
  1211.                 break;
  1213.             case -3:
  1214.                 UART_PUTC_EXACT(0x83);
  1215.                 break;
  1217.             default:
  1218.                 UART_PUTC_EXACT((BYTE)nMainBalance_L);
  1219.                 break;
  1220.             }
  1221.             UART_PUTC_EXACT(COMMAND_END);
  1223. #ifdef OSD_DBG_TXD
  1224.             psprintf(RegionValStr[REGION3], "SEND 8051 FRONT BAL L: %d", nMainBalance_L);
  1225.             PrintOsdMsg(STR_OS_SPACE, REGION3, 1, 1);
  1226. #endif
  1227.         }
  1228.         psprintf(RegionValStr[REGION1], "BALANCE FL VOL: %dDB", nMainBalance_L);
  1229.         break;
  1231.     case VOL_MODE_MAIN_BALANCE_R:
  1232.         if (bVolChanged)
  1233.         {
  1234.             if ((1 == nUpOrDown) && (nMainBalance_R < BALANCE_MAX))
  1235.                 nMainBalance_R++;
  1236.             else if ((0 == nUpOrDown) && (nMainBalance_R > BALANCE_MIN))
  1237.                 nMainBalance_R--;
  1238.             else
  1239.                 break;
  1241.             // send volume change command to 8051
  1242.             UART_PUTC_EXACT(COMMAND_START);
  1243.             UART_PUTC_EXACT(FRONT_BALANCE_R);
  1244.             switch (nMainBalance_R)
  1245.             {
  1246.             case -1:
  1247.                 UART_PUTC_EXACT(0x81);
  1248.                 break;
  1250.             case -2:
  1251.                 UART_PUTC_EXACT(0x82);
  1252.                 break;
  1254.             case -3:
  1255.                 UART_PUTC_EXACT(0x83);
  1256.                 break;
  1258.             default:
  1259.                 UART_PUTC_EXACT((BYTE)nMainBalance_R);
  1260.                 break;
  1261.             }
  1262.             UART_PUTC_EXACT(COMMAND_END);
  1264. #ifdef OSD_DBG_TXD
  1265.             psprintf(RegionValStr[REGION3], "SEND 8051 FRONT BAL R: %d", nMainBalance_R);
  1266.             PrintOsdMsg(STR_OS_SPACE, REGION3, 1, 1);
  1267. #endif
  1268.         }
  1269.         psprintf(RegionValStr[REGION1], "BALANCE FR VOL: %dDB", nMainBalance_R);
  1270.         break;
  1271.         
  1272.     case VOL_MODE_SUR_BALANCE_L:
  1273.         if (bVolChanged)
  1274.         {
  1275.             if ((1 == nUpOrDown) && (nSurBalance_L < BALANCE_MAX))
  1276.                 nSurBalance_L++;
  1277.             else if ((0 == nUpOrDown) && (nSurBalance_L > BALANCE_MIN))
  1278.                 nSurBalance_L--;
  1279.             else
  1280.                 break;
  1282.             // send volume change command to 8051
  1283.             UART_PUTC_EXACT(COMMAND_START);
  1284.             UART_PUTC_EXACT(REAR_BALANCE_L);
  1285.             switch (nSurBalance_L)
  1286.             {
  1287.             case -1:
  1288.                 UART_PUTC_EXACT(0x81);
  1289.                 break;
  1291.             case -2:
  1292.                 UART_PUTC_EXACT(0x82);
  1293.                 break;
  1295.             case -3:
  1296.                 UART_PUTC_EXACT(0x83);
  1297.                 break;
  1299.             default:
  1300.                 UART_PUTC_EXACT((BYTE)nSurBalance_L);
  1301.                 break;
  1302.             }
  1303.             UART_PUTC_EXACT(COMMAND_END);
  1305. #ifdef OSD_DBG_TXD
  1306.             psprintf(RegionValStr[REGION3], "SEND 8051 SUR BAL L: %d", nSurBalance_L);
  1307.             PrintOsdMsg(STR_OS_SPACE, REGION3, 1, 1);
  1308. #endif
  1309.         }
  1310.         psprintf(RegionValStr[REGION1], "BALANCE SL VOL: %dDB", nSurBalance_L);
  1311.         break;
  1313.     case VOL_MODE_SUR_BALANCE_R:
  1314.         if (bVolChanged)
  1315.         {
  1316.             if ((1 == nUpOrDown) && (nSurBalance_R < BALANCE_MAX))
  1317.                 nSurBalance_R++;
  1318.             else if ((0 == nUpOrDown) && (nSurBalance_R > BALANCE_MIN))
  1319.                 nSurBalance_R--;
  1320.             else
  1321.                 break;
  1323.             // send volume change command to 8051
  1324.             UART_PUTC_EXACT(COMMAND_START);
  1325.             UART_PUTC_EXACT(REAR_BALANCE_R);
  1326.             switch (nSurBalance_R)
  1327.             {
  1328.             case -1:
  1329.                 UART_PUTC_EXACT(0x81);
  1330.                 break;
  1332.             case -2:
  1333.                 UART_PUTC_EXACT(0x82);
  1334.                 break;
  1336.             case -3:
  1337.                 UART_PUTC_EXACT(0x83);
  1338.                 break;
  1340.             default:
  1341.                 UART_PUTC_EXACT((BYTE)nSurBalance_R);
  1342.                 break;
  1343.             }
  1344.             UART_PUTC_EXACT(COMMAND_END);
  1346. #ifdef OSD_DBG_TXD
  1347.             psprintf(RegionValStr[REGION3], "SEND 8051 SUR BAL R: %d", nSurBalance_R);
  1348.             PrintOsdMsg(STR_OS_SPACE, REGION3, 1, 1);
  1349. #endif
  1350.         }
  1351.         psprintf(RegionValStr[REGION1], "BALANCE SR VOL: %dDB", nSurBalance_R);
  1352.         break;
  1354.     case VOL_MODE_QS_EFFECT:
  1355.         if (bVolChanged)
  1356.         {
  1357.             if ((1 == nUpOrDown) && (nQSEffect < QS_MAX))
  1358.                 nQSEffect++;
  1359.             //else if ((0 == nUpOrDown) && (nQSEffect > QS_MIN))
  1360. //  nQSEffect--;
  1361.             else
  1362.                 nQSEffect=QS_MIN;
  1363. //break;
  1365.             // send volume change command to 8051
  1366.             UART_PUTC_EXACT(COMMAND_START);
  1367.             UART_PUTC_EXACT(QS_EFFECT);
  1368.             UART_PUTC_EXACT(nQSEffect);
  1369.             UART_PUTC_EXACT(COMMAND_END);
  1371. #ifdef OSD_DBG_TXD
  1372.             psprintf(RegionValStr[REGION3], "SEND 8051 QS: %d", nQSEffect);
  1373.             PrintOsdMsg(STR_OS_SPACE, REGION3, 1, 1);
  1374. #endif
  1375.         }
  1376.         psprintf(RegionValStr[REGION1], "QSOUND: %d", nQSEffect);
  1377.         break;
  1379.     case VOL_MODE_TREBLE:
  1380.         if (bVolChanged)
  1381.         {
  1382.             if ((1 == nUpOrDown) && (nTreble < VOL_ADJUST_MAN-1))
  1383.                 nTreble++;
  1384.             else if ((0 == nUpOrDown) && (nTreble > VOL_ADJUST_MIN+1))
  1385.                 nTreble--;
  1386.             else
  1387.                 break;
  1389.             // send volume change command to 8051
  1390.             UART_PUTC_EXACT(COMMAND_START);
  1391.             UART_PUTC_EXACT(TREBLE_EFFECT);
  1392.             switch (nTreble)
  1393.             {
  1394.             case -1:
  1395.                 UART_PUTC_EXACT(0x81);
  1396.                 break;
  1398.             case -2:
  1399.                 UART_PUTC_EXACT(0x82);
  1400.                 break;
  1402.             case -3:
  1403.                 UART_PUTC_EXACT(0x83);
  1404.                 break;
  1405.             case -4:
  1406.                 UART_PUTC_EXACT(0x84);
  1407.                 break;
  1408.             case -5:
  1409.                 UART_PUTC_EXACT(0x85);
  1410.                 break;
  1411.             default:
  1412.                 UART_PUTC_EXACT((BYTE)nTreble);
  1413.                 break;
  1414.             }
  1415.             UART_PUTC_EXACT(COMMAND_END);
  1417. #ifdef OSD_DBG_TXD
  1418.             psprintf(RegionValStr[REGION3], "SEND 8051 TREBLE: %d", nTreble);
  1419.             PrintOsdMsg(STR_OS_SPACE, REGION3, 1, 1);
  1420. #endif
  1421.         }
  1422.         psprintf(RegionValStr[REGION1], "TREBLE VOL: %dDB", 2*nTreble);
  1423.         break;
  1425.     case VOL_MODE_BASS:
  1426.         if (bVolChanged)
  1427.         {
  1428.             if ((1 == nUpOrDown) && (nBass < VOL_ADJUST_MAN-1))
  1429.                 nBass++;
  1430.             else if ((0 == nUpOrDown) && (nBass > VOL_ADJUST_MIN+1))
  1431.                 nBass--;
  1432.             else
  1433.                 break;
  1435.             // send volume change command to 8051
  1436.             UART_PUTC_EXACT(COMMAND_START);
  1437.             UART_PUTC_EXACT(BASS_EFFECT);
  1438.             switch (nBass)
  1439.             {
  1440.             case -1:
  1441.                 UART_PUTC_EXACT(0x81);
  1442.                 break;
  1444.             case -2:
  1445.                 UART_PUTC_EXACT(0x82);
  1446.                 break;
  1448.             case -3:
  1449.                 UART_PUTC_EXACT(0x83);
  1450.                 break;
  1451.             case -4:
  1452.                 UART_PUTC_EXACT(0x84);
  1453.                 break ;
  1454.             case -5:
  1455.                 UART_PUTC_EXACT(0x85);
  1456.             default:
  1457.                 UART_PUTC_EXACT((BYTE)nBass);
  1458.                 break;
  1459.             }
  1460.             UART_PUTC_EXACT(COMMAND_END);
  1462. #ifdef OSD_DBG_TXD
  1463.             psprintf(RegionValStr[REGION3], "SEND 8051 BASS: %d", nBass);
  1464.             PrintOsdMsg(STR_OS_SPACE, REGION3, 1, 1);
  1465. #endif
  1466.         }
  1467.         psprintf(RegionValStr[REGION1], "BASS VOL: %dDB", 2*nBass);
  1468.         break;
  1470.     default:
  1471.         return;
  1472.     }
  1473.     PrintOsdMsg(STR_OS_SPACE, REGION1, 2, 1);
  1474.     do_updata_vfd_vol();
  1475. }
  1476. void Set_Default_Vol(void)
  1477. {
  1478. nCurrentDVDMode=MODE_DVD;
  1479. nCurrentVolMode=VOL_MODE_MAIN;
  1480. nMainVol=MAINVOL;
  1481. nFrontVol=FRONTVOL;
  1482. nCenterVol=CENTERVOL;
  1483. nRearVol=REARVOL;
  1484. nSubwooferVol=SUBWOOFERVOL;
  1485. nMainBalance_L=MAINBALANCE_L;
  1486. nMainBalance_R=MAINBALANCE_R;
  1487. nSurBalance_L=SURBALANCE_L;
  1488. nSurBalance_R=SURBALANCE_R;
  1489. nQSEffect=QSEFFECT;
  1490. nTreble=TREBLEVOL;
  1491. nBass=BASSVOL;
  1492. UART_PUTC_EXACT(COMMAND_START);
  1493. UART_PUTC_EXACT(VOL_DEFAULT);
  1494. UART_PUTC_EXACT(VOL_DEFAULT_D);
  1495. UART_PUTC_EXACT(COMMAND_END);
  1496. psprintf(RegionValStr[REGION1], "SETUP DEFAULT VOL");
  1497. PrintOsdMsg(STR_OS_SPACE, REGION1, 2, 1);
  1498. do_updata_vfd_vol();
  1499. }
  1500. #endif //NEW UART COMMAND FOR FUSS
  1501. #endif