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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > DVD > 查看源码
dmd.c
资源名称：ST_5105DTV.rar　[点击查看]
上传用户：fy98168
上传日期：2015-06-26
资源大小：13771k
文件大小：14k
源码类别：

DVD

开发平台：

C/C++

dmd.c：源码内容
  1. #include <string.h>
  2. #include "errors.h"
  3. #include "i2c.h"
  4. #include "osp.h"
  5. #include "timer.h"
  6. #include "dmd.h"
  7. #include "db.h"
  8. #include "sipsi.h"
  10. #include "tcmu30311.h"
  11. #include "Nvod.h"
  12. #include "Epg.h"
  14. #define DMD_INITIAL_TIMEOUT  (3000)   /* 3s acquisition time out   */
  15. #define DMD_RECOVER_TIMEOUT  (9000)  
  17. /****************************************************************************
  18. ** Local function prototypes
  19. ****************************************************************************/
  20. static  void    DMDAcquisitionTask(void);
  21. static  UINT32  DMDHandleConnectedState(UINT32 *);
  22. static  UINT32  DMDHandleDroppedState(UINT32 *);
  23. static  UINT32  DMDHandleWaitingState(UINT32 *);
  24. static  void    DMDHandleTimeout(void);
  26. typedef struct
  27. {
  28. KB_DMDType type; /* e.g. satellite (QPSK), terrestrial (COFDM) */
  29. UINT16 address; /* I2C bus address */
  30. UINT16 present; /* TRUE / FALSE */
  31. INT32 (*detect)(UINT16 addr);
  32. void (*initialize)(KB_DMDTunerParameters *pParam);
  33. INT32 (*connect)(void);
  34. void (*drop)(void);
  35. void (*process_int)(void);
  36. INT32 (*check_lock)(void);
  37. UINT32 (*read_signal_strength)(void);
  38. INT32  (*read_ber)(UINT32 *ber);
  39. INT32  (*read_snr)(UINT32 *snr);
  40. } T_NIM_Type;
  42. static T_NIM_Type supportedNIMs[] =
  43. {
  44. /* cable : STV 0297 NIMs */
  45. {
  46. DMD_TYPE_QAM,
  47. IIC_ADDR_NIM_30311,
  48. FALSE,
  49. SAMDetect,
  50. SAMInit,
  51. SAMStartConnect,
  52. SAMStopConnect,
  53. NULL,
  54. SAMCheckLock,
  55. NULL,
  56. NULL,
  57. NULL
  58. },
  60. {
  61. DMD_TYPE_NONE, 0x00, FALSE, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL
  62. }
  63. };
  66. static T_NIM_Type       *NIM;
  67. static UINT32 DMDQueueID;       /* Message queue for Acquisition task */
  68. static UINT32 AcquisitionTimer;
  71. static INT32 gLockFlag = 0;
  72. /***************************************************************************
  73. ** These are the Acquisition Task message ID assignments 
  74. ***************************************************************************/
  75. #define CONNECT_REQUEST_MSG_ID  (1) /* connect request message id     */
  76. #define DROP_REQUEST_MSG_ID     (2) /* drop request message id        */
  77. #define TIMEOUT_MSG_ID          (3) /* time out connecting message id */
  78. #define NIM_INT_MSG_ID          (4) /* NIM interrupt message id       */
  79. #define INT_LOCK_MSG_ID         (5) /* lock interrupt message id      */
  80. #define INT_LOST_LOCK_MSG_ID    (6) /* lost lock interrupt message id */
  83. /************************************************************************
  84. ** Acquisition task state definitions
  85. *************************************************************************/
  86. #define DEMOD_ERROR     (0) /* Demod error */
  87. #define DEMOD_DROPPED   (1) /* Signal is dropped. Idle state    */
  88. #define DEMOD_WAITING   (2) /* Acquisition process has started. */
  89. #define DEMOD_CONNECTED (3) /* Signal successfully acquired     */
  91. /*
  92. ** All publicly available functions that have their location
  93. ** modified have their initial location as a dummy function
  94. */
  95. static void dummyFunction(KB_DMDCallbackEvents a){ (void)(a);}
  96. static KB_DMD_CallbackFunc DMDCallbackFunction = dummyFunction;
  98. extern KB_DMDTunerParameters *KB_NVOD_GetTsParaFromTsSequence(UINT32  TsSequence);
  99. extern STB_State KB_GetCurState(void);
  102. INT32 KB_DMDInit(void)
  103. {
  104. UINT32          taskid;
  105. T_NIM_Type      *availableNIM = &(supportedNIMs[0]);
  106. INT32           nim_types = DMD_TYPE_NONE;
  108. /* Find any supported NIMs */
  109. while(availableNIM->type != DMD_TYPE_NONE)
  110.     {
  111. /* Mark available if the NIM is found */
  112. nim_types = availableNIM->detect( availableNIM->address );
  114. if(nim_types != DMD_TYPE_NONE)
  115.         {
  116. availableNIM->present = TRUE;
  117. break;
  118.         }
  119. availableNIM++;
  120.     }
  122. /* Provide a dummy handler for the application's callback */
  123. DMDCallbackFunction = dummyFunction;
  125. if(nim_types != DMD_TYPE_NONE )
  126.     {
  127. /*
  128. ** Create the message queue and the 
  129. ** task used to control the NIM
  130. */
  131. KB_OSPQueInit("DMDQ", 16, &DMDQueueID);
  133. KB_OSPTaskInit("DMDT", 0x2000, (void(*)(void *))DMDAcquisitionTask, 
  134.                          DMD_PRIORITY, NULL, &taskid);
  135. /*
  136. ** Initialize the first demod found
  137. */
  138. availableNIM->initialize(&CurrentSignal);
  139. NIM = availableNIM;
  140.     }
  142. return nim_types;
  143. }
  145. static void DMDAcquisitionTask(void)
  146. {
  147. UINT32 message[4];  
  148. INT32  rc;
  150. UINT32 state   = DEMOD_DROPPED;
  152. AcquisitionTimer = KB_TimerCreate(KB_TIMER_ONCE,
  153.     (KB_TIMER_FUNC_POINTER)DMDHandleTimeout, NULL);
  155. while(1)
  156.     {
  157. rc = KB_OSPMsgGet(DMDQueueID, KB_Wait, 0, (KB_OSPMsgNode*)message);
  158. if(rc != Ret_OK)                                     
  159.         {
  160. continue;
  161.         }                         
  163. switch (state)
  164.         {
  165.         case DEMOD_WAITING:
  166. state = DMDHandleWaitingState(message);
  167. break;
  169.         //其他模块仅发信号连接消息过来, message的第一个参数设置为1(CONNECT_REQUEST_MSG_ID)
  170.         //信号断开的直接调用KB_DMDDropSignal--->NIM->drop();
  171.         case DEMOD_DROPPED:
  172. state = DMDHandleDroppedState(message);
  173. break;
  175.         case DEMOD_CONNECTED:
  176. state = DMDHandleConnectedState(message);
  177. break;
  179.         case DEMOD_ERROR:
  180. break;
  182.         default:
  183. break;
  184.         }
  185. if (state == DEMOD_CONNECTED)
  186. {
  187. gLockFlag = TRUE;
  188. }
  189. else
  190. {
  191. gLockFlag = FALSE;
  192.         }
  193.     }
  194. }
  196. static UINT32 DMDHandleConnectedState(UINT32 *message)
  197. {
  198. UINT32 newState = DEMOD_CONNECTED;
  200. switch (message[0])
  201.     {
  202.     case DROP_REQUEST_MSG_ID:
  203. newState = DEMOD_DROPPED;
  204. if( NIM != NULL ) NIM->drop();
  205. DMDCallbackFunction(DMD_CALLBACK_SIGNAL_DROPPED);
  206. break;
  208.     case INT_LOST_LOCK_MSG_ID:
  209. newState = DEMOD_WAITING;
  210. DMDCallbackFunction(DMD_CALLBACK_SIGNAL_LOST);
  211. /* Reset the acquisition timer */
  212. KB_TimerDisable(AcquisitionTimer);
  213. KB_TimerEnable(AcquisitionTimer, DMD_RECOVER_TIMEOUT);
  214. break;
  216. case CONNECT_REQUEST_MSG_ID:
  217.        newState = DEMOD_WAITING;
  218. KB_TimerDisable(AcquisitionTimer);
  219. KB_TimerEnable(AcquisitionTimer, DMD_INITIAL_TIMEOUT);
  220. if( (NIM != NULL) && (TRUE == NIM->connect()) )
  221. {
  222. newState = DEMOD_CONNECTED;
  223. DMDCallbackFunction(DMD_CALLBACK_SIGNAL_CONNECTED);
  224. }
  225. else
  226. {
  227. newState = DEMOD_DROPPED;
  228. DMDCallbackFunction(DMD_CALLBACK_SIGNAL_LOST);
  229. }
  230.        break;
  232. case TIMEOUT_MSG_ID:
  233. KB_TimerDisable(AcquisitionTimer);
  234. if( (NIM != NULL) && (NIM->check_lock != NULL)
  235.      && (TRUE == NIM->check_lock()) )
  236. {
  237.     }
  238. else
  239. {
  240. newState = DEMOD_DROPPED;
  241. if( NIM != NULL) NIM->drop();
  242. DMDCallbackFunction(DMD_CALLBACK_SIGNAL_LOST);
  244. {
  245. UINT32 msg[4];
  246. msg[0] = CONNECT_REQUEST_MSG_ID;
  247. KB_OSPMsgSend(DMDQueueID, (KB_OSPMsgNode*)msg);
  248. }
  249. }
  250. KB_TimerEnable(AcquisitionTimer, DMD_INITIAL_TIMEOUT);
  251. break;
  253.     default:
  254. break;
  255.     }
  257. return(newState);
  258. }
  260. static UINT32 DMDHandleDroppedState(UINT32 *message)
  261. {
  262. UINT32 newState = DEMOD_DROPPED;
  264. switch (message[0])
  265.     {
  266. case INT_LOCK_MSG_ID:
  267. newState = DEMOD_CONNECTED;
  268. DMDCallbackFunction(DMD_CALLBACK_SIGNAL_CONNECTED);
  269. break;
  271.     case CONNECT_REQUEST_MSG_ID:
  272. newState = DEMOD_WAITING;
  273. KB_TimerDisable(AcquisitionTimer);
  274. KB_TimerEnable(AcquisitionTimer, DMD_INITIAL_TIMEOUT);
  275. if( (NIM != NULL) && (TRUE == NIM->connect()) )
  276. {
  277. newState = DEMOD_CONNECTED;
  278. DMDCallbackFunction(DMD_CALLBACK_SIGNAL_CONNECTED);
  279. }
  280. else
  281. {
  282. newState = DEMOD_DROPPED;
  283. DMDCallbackFunction(DMD_CALLBACK_SIGNAL_LOST);
  284. }
  285. break;
  287.     case DROP_REQUEST_MSG_ID:
  288. newState = DEMOD_DROPPED;
  289. DMDCallbackFunction(DMD_CALLBACK_SIGNAL_DROPPED);
  290. break;
  292. case TIMEOUT_MSG_ID:
  293. KB_TimerDisable(AcquisitionTimer);
  294. if( (NIM != NULL) && (NIM->check_lock != NULL)
  295.      && (TRUE == NIM->check_lock()) )
  296. {
  297.      newState = DEMOD_CONNECTED;
  298. DMDCallbackFunction(DMD_CALLBACK_SIGNAL_CONNECTED);
  299.     }
  300. else
  301. {
  302. UINT32 msg[4];
  303. msg[0] = CONNECT_REQUEST_MSG_ID;
  304. KB_OSPMsgSend(DMDQueueID, (KB_OSPMsgNode*)msg);
  305. }
  306. KB_TimerEnable(AcquisitionTimer, DMD_INITIAL_TIMEOUT);
  307. break;
  309.     default:
  310. break;
  311.     }
  313. return(newState);
  314. }
  316. static UINT32 DMDHandleWaitingState(UINT32 *message)
  317. {
  318. UINT32 newState = DEMOD_WAITING;
  320. switch (message[0])
  321.     {
  322.     case INT_LOCK_MSG_ID:
  323. newState = DEMOD_CONNECTED;
  324. KB_TimerDisable(AcquisitionTimer);
  325. DMDCallbackFunction(DMD_CALLBACK_SIGNAL_CONNECTED);
  326. break;          
  328.     case TIMEOUT_MSG_ID:
  329. KB_TimerDisable(AcquisitionTimer);
  330. if( (NIM != NULL) && (NIM->check_lock != NULL)
  331.      && (TRUE == NIM->check_lock()) )
  332. {
  333.      newState = DEMOD_CONNECTED;
  334. DMDCallbackFunction(DMD_CALLBACK_SIGNAL_CONNECTED);
  335.     }
  336. else
  337. {
  338. newState = DEMOD_DROPPED;
  339. if( NIM != NULL) NIM->drop();
  340. DMDCallbackFunction(DMD_CALLBACK_SIGNAL_LOST);
  342. }
  343. KB_TimerEnable(AcquisitionTimer, DMD_INITIAL_TIMEOUT);
  344. break;
  346.     case DROP_REQUEST_MSG_ID:
  347. KB_TimerDisable(AcquisitionTimer);
  348. newState = DEMOD_DROPPED;
  349. if( NIM != NULL) NIM->drop();
  350. DMDCallbackFunction(DMD_CALLBACK_SIGNAL_DROPPED);
  351. break;
  353.     case CONNECT_REQUEST_MSG_ID:
  354. newState = DEMOD_WAITING;
  355. KB_TimerDisable(AcquisitionTimer);
  356. KB_TimerEnable(AcquisitionTimer, DMD_INITIAL_TIMEOUT);
  357. if( (NIM != NULL) && (TRUE == NIM->connect()) )
  358. {
  359. newState = DEMOD_CONNECTED;
  360. DMDCallbackFunction(DMD_CALLBACK_SIGNAL_CONNECTED);
  361. }
  362. else
  363. {
  364. newState = DEMOD_DROPPED;
  365. DMDCallbackFunction(DMD_CALLBACK_SIGNAL_LOST);
  366. }
  367. break;
  369.     default:
  370. break;
  371.     }
  373. return(newState);
  374. }
  376. static void DMDHandleTimeout(void)
  377. {
  378. UINT32 message[4];
  380. message[0] = TIMEOUT_MSG_ID;
  381. KB_OSPMsgSend(DMDQueueID, (KB_OSPMsgNode*)message);
  382. }
  385. INT32 KB_DMDConnectSignal(KB_DMDTunerParameters *dmdParam)
  386. {
  387.     UINT32 CurrentTsTsSequence;
  388.     UINT16 TsID;
  389.     unsigned short Fre;
  390.     unsigned short Symbl;
  391.     unsigned char  Qam;
  392. UINT32 message[4];
  393.     KB_DMDTunerParameters    ts;
  395.    if( (NIM == NULL) || (dmdParam == NULL) || (dmdParam->type != NIM->type) )
  396.     {
  397.      return RETFIAL1;
  398.     }
  400.     DBGPrint("[j_dmd.c] %d %d %dn", dmdParam->frequency, dmdParam->details.qam.symbolRatekSs,
  401.                dmdParam->details.qam.modulation);
  402. if( (0 == memcmp(&CurrentSignal, dmdParam, sizeof(KB_DMDTunerParameters))) && (NIM->check_lock() == TRUE) )
  403. {
  404.         if (State_NVOD == KB_GetCurState())
  405.         {
  406.             if (0 == dmdParam->frequency)
  407.             {
  408.                 printf("nKB_DMDConnectSignal::serious error. fre = 0!");
  409.                 CurrentTsTsSequence = KB_NVOD_GetCurrentTsNum();
  410.                 if ((UINT32)(-1) != CurrentTsTsSequence 
  411.                     && NULL != KB_NVOD_GetTsParaFromTsSequence(CurrentTsTsSequence))
  412.                 {
  413.                     KB_DMDConnectSignal(KB_NVOD_GetTsParaFromTsSequence(CurrentTsTsSequence));
  414.                     return RETOK;
  415.                 }
  416.             }
  417.             
  418.             if (KB_DB_DTV_SUCCESS != KB_NVODInit2())
  419.             {
  420.                 printf("nKB_DMDConnectSignal::KB_NVODInit2 failed!n");
  421.             }
  422.             else
  423.             {
  424.                 printf("nKB_DMDConnectSignal::KB_NVODInit2 ok!n");
  425.             }
  426.         }
  427. DMDCallbackFunction(DMD_CALLBACK_SIGNAL_CONNECTED);
  428. return RETOK;
  429. }
  431. CurrentSignal = *dmdParam;
  432.       
  433.     if (State_NVOD == KB_GetCurState())
  434.     {
  435.         if (0 == dmdParam->frequency)
  436.         {
  437.             printf("nKB_DMDConnectSignal::serious error. fre = 0!");
  438.             CurrentTsTsSequence = KB_NVOD_GetCurrentTsNum();
  439.             if ((UINT32)(-1) != CurrentTsTsSequence 
  440.                 && NULL != KB_NVOD_GetTsParaFromTsSequence(CurrentTsTsSequence))
  441.             {
  442.                 KB_DMDConnectSignal(KB_NVOD_GetTsParaFromTsSequence(CurrentTsTsSequence));
  443.                 return RETOK;
  444.             }
  445.         }
  446.         
  447.         if (KB_DB_DTV_SUCCESS != KB_NVODInit2())
  448.         {
  449.             printf("nKB_DMDConnectSignal::KB_NVODInit2 failed!n");
  450.         }
  451.         else
  452.         {
  453.             printf("nKB_DMDConnectSignal::KB_NVODInit2 ok!n");
  454.         }
  455.     }
  456.     if (State_EPG == KB_GetCurState())
  457.     {
  458.         if (0 == dmdParam->frequency)
  459.         {
  460.             printf("nKB_DMDConnectSignal::serious error. fre = 0!");
  461.             CurrentTsTsSequence = KB_EPG_GetCurrentTsNum();
  462.             
  463.             if ((UINT32)(-1) != CurrentTsTsSequence)
  464.             {
  465.                 TsID = (UINT16)KB_EPG_GetTsIdFromTsNum(CurrentTsTsSequence);
  466.                 
  467.                 if ((UINT32)(-1) != TsID 
  468.                     && RET_OK == KB_DBGetChnlInfoByTsID(TsID, &Fre, &Symbl, &Qam))
  469.                 {
  470.                     KB_DMDDropSignal();
  472.                     ts.type      = DMD_TYPE_QAM;
  473.                     ts.inversion = INVERSION_AUTO;
  474.                     ts.frequency = (UINT32)Fre * 100;
  475.                     ts.details.qam.symbolRatekSs = Symbl;
  476.                     ts.details.qam.modulation    = Qam;
  477.                     KB_DMDConnectSignal(&ts);
  478.                     printf("nKB_DMDConnectSignal::ts(%d) rechange to %d!n",
  479.                            dmdParam->frequency, ts.frequency);
  480.                 }
  481.             }
  482.             return RETOK;
  483.         }
  484.         else
  485.         {
  486.             if (RET_OK == KB_DBGetTsIDByFre(&TsID,CurrentSignal.frequency))
  487.             {
  488.                 CurrentTsTsSequence = KB_EPG_GetCurrentTsNum();
  489.                 if ((UINT32)(-1) != CurrentTsTsSequence 
  490.                      && TsID != KB_EPG_GetTsIdFromTsNum(CurrentTsTsSequence))
  491.                 {
  492.                     printf("nKB_DMDConnectSignal::CurrentTs change!n");
  493.                     KB_SIStopEitSCH(KB_SI_STOP_ALL);
  494.                     KB_EPG_SetCurrentTsNum(TsID);
  495.                 }
  496.             }
  497.         }
  498.     }
  499.       
  500.     message[0] = CONNECT_REQUEST_MSG_ID;
  501. KB_OSPMsgSend(DMDQueueID, (KB_OSPMsgNode*)message);
  503. return RETOK;
  504. }
  507. INT32 KB_DMDDropSignal(void)
  508. {
  509. if( NIM != NULL ) 
  510. {
  511. NIM->drop();
  512. }
  513. DMDCallbackFunction(DMD_CALLBACK_SIGNAL_DROPPED);
  514. return RETOK;
  515. }
  517. INT32 KB_DMDQuerySignalStatus(void)
  518. {
  519. return gLockFlag;
  520. }
  522. INT32 KB_DMDGetSignalParameters(KB_DMDTunerParameters *ptParameters)
  523. {
  524.     if (ptParameters == NULL)
  525.     {
  526.         return RETFAIL3;
  527.     }
  528.     
  529.     *ptParameters = CurrentSignal;
  531.     return RETOK;
  532. }
  534. void KB_DMDCallBack(KB_DMD_CallbackFunc callback)
  535. {
  536. DMDCallbackFunction = callback; /* Register function in function table */
  537. }
  540. /* EOF --------------------------------------------------------------------- */