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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > uCOS > 查看源码
os_view.c
资源名称：STM32-uCOS-II_UAV.rar　[点击查看]
上传用户：yj_qqy
上传日期：2017-01-28
资源大小：2911k
文件大小：42k
源码类别：

uCOS

开发平台：

C/C++

os_view.c：源码内容
  1. /*
  2. *********************************************************************************************************
  3. *                                           uC/OS-View
  4. *
  5. *                             (c) Copyright 2005, Micrium, Weston, FL
  6. *                                       All Rights Reserved
  7. *
  8. *
  9. * Filename   : OS_VIEW.C
  10. * Version    : V1.33
  11. * Programmer : JJL
  12. *********************************************************************************************************
  13. */
  15. #define  OS_VIEW_GLOBALS
  16. #include <includes.h>
  18. #if OS_VIEW_MODULE == DEF_ENABLED
  20. /*
  21. *********************************************************************************************************
  22. *                                               CONSTANTS
  23. *********************************************************************************************************
  24. */
  26. #ifndef  OS_VIEW_SUPPORT_MEM
  27. #define  OS_VIEW_SUPPORT_MEM               0                /* Current version doesn't support memory Rd/Wr    */
  28. #endif
  29.                                                             /* Inbound  packets (from PC)                      */
  30. #define  OS_VIEW_PROTOCOL_RX_SD0        0xED                /* Start delimiters                                */
  31. #define  OS_VIEW_PROTOCOL_RX_SD1        0x8C
  32. #define  OS_VIEW_PROTOCOL_RX_ED         0x8D                /* End   delimiter                                 */
  34.                                                             /* Outbound packets (to PC)                        */
  35. #define  OS_VIEW_PROTOCOL_TX_SD0        0x8C                /* Start delimiters                                */
  36. #define  OS_VIEW_PROTOCOL_TX_SD1        0xED
  37. #define  OS_VIEW_PROTOCOL_TX_ED         0x8D                /* End   delimiter                                 */
  40. #define  OS_VIEW_RX_STATE_SD0              0                /* waiting for start first  start delimiter (SD0)  */
  41. #define  OS_VIEW_RX_STATE_SD1              1                /* waiting for start second start delimiter (SD1)  */
  42. #define  OS_VIEW_RX_STATE_LEN              2                /* waiting for len byte                            */
  43. #define  OS_VIEW_RX_STATE_DATA             3                /* waiting for data                                */
  44. #define  OS_VIEW_RX_STATE_CHKSUM           4                /* waiting for checksum                            */
  45. #define  OS_VIEW_RX_STATE_ED               5                /* waiting for end delimiter                       */
  47. #define  OS_VIEW_TX_STATE_SD0              0                /* Transmit state machine states                   */
  48. #define  OS_VIEW_TX_STATE_SD1              1
  49. #define  OS_VIEW_TX_STATE_DATA_LEN         2
  50. #define  OS_VIEW_TX_STATE_DATA             3
  51. #define  OS_VIEW_TX_STATE_CHKSUM           4
  52. #define  OS_VIEW_TX_STATE_ED               5
  53. #define  OS_VIEW_TX_STATE_STR_LEN          6
  54. #define  OS_VIEW_TX_STATE_STR_TYPE         7
  55. #define  OS_VIEW_TX_STATE_STR_DATA         8
  57. #define  OS_VIEW_CMD_STEP_TICK_ON          0                /* Commands for tick stepping                      */
  58. #define  OS_VIEW_CMD_STEP_TICK_OFF         1
  59. #define  OS_VIEW_CMD_STEP_TICK_NEXT        2
  61. #define  OS_VIEW_CPU_NAME_SIZE            30
  63. /*$PAGE*/
  64. /*
  65. *********************************************************************************************************
  66. *                                           LOCAL VARIABLES
  67. *********************************************************************************************************
  68. */
  70. #if OS_VIEW_PARSE_TASK > 0
  71. static  OS_STK     OSView_TaskStk[OS_VIEW_TASK_STK_SIZE];
  73. #if OS_SEM_EN > 0
  74. static  OS_EVENT  *OSView_Sem;
  75. #endif
  77. #endif
  80. /*
  81. *********************************************************************************************************
  82. *                                      LOCAL FUNCTION PROTOTYPES
  83. *********************************************************************************************************
  84. */
  86. #if OS_VIEW_PARSE_TASK > 0
  87. static  void    OSView_InitOS(void);
  88. static  void    OSView_Task(void *p_arg);
  89. #endif
  91. static  INT8U   OSView_CmdParsePkt(void);
  92. static  void    OSView_CmdSendToApp(void);
  93. static  void    OSView_CmdGetSysInfo(void);
  94. static  void    OSView_CmdGetTaskList(void);
  95. static  void    OSView_CmdGetTaskInfo(void);
  96. static  void    OSView_CmdGetTaskInfo_InvalidTask(void);
  97. static  INT8U   OSView_CmdGetTaskInfo_TCBStat(OS_TCB *ptcb);
  98. static  void    OSView_CmdMemRdINT8U(void);
  99. static  void    OSView_CmdMemRdINT16U(void);
  100. static  void    OSView_CmdMemRdINT32U(void);
  101. static  void    OSView_CmdMemWrINT8U(void);
  102. static  void    OSView_CmdMemWrINT16U(void);
  103. static  void    OSView_CmdMemWrINT32U(void);
  104. static  void    OSView_CmdTickStep(void);
  105. static  void    OSView_CmdTrace(void);
  107. static  void    OSView_RxPkt(void);
  108. static  void    OSView_RxStoINT8U(INT8U rx_data);
  109. static  void    OSView_RxBufClr(void);
  110. static  INT8U   OSView_RxGetINT8U(void);
  111. static  INT16U  OSView_RxGetINT16U(void);
  112. static  INT32U  OSView_RxGetINT32U(void);
  114. static  void    OSView_TxStart(void);
  115. static  void    OSView_TxStoINT8U(INT8U tx_data);
  116. static  void    OSView_TxStoINT16U(INT16U tx_data);
  117. static  void    OSView_TxStoINT32U(INT32U tx_data);
  118. static  void    OSView_TxStoPtr(void *ptr);
  119. static  void    OSView_TxStoStr(INT8U *s);
  121. /*$PAGE*/
  122. /*
  123. *********************************************************************************************************
  124. *                                       INITIALIZE uC/OS-View
  125. *********************************************************************************************************
  126. */
  128. void  OSView_Init (INT32U baud_rate)
  129. {
  130. #if OS_TICK_STEP_EN > 0
  131.     OSTickStepState     = OS_TICK_STEP_DIS;                 /* Disable the tick stepping mode                  */
  132. #endif
  134.     OSView_CyclesCtr    = 0;
  136.     OSView_RxState      = OS_VIEW_RX_STATE_SD0;             /* Setup Rx and Tx state machines                  */
  137.     OSView_TxState      = OS_VIEW_TX_STATE_SD0;
  139.     OSView_TxLen        = 0;
  140.     OSView_TxStrLen     = 0;
  141.     OSView_TxActiveFlag = OS_FALSE;
  143.     OSView_TerminalRxSetCallback((void (*)(INT8U))0);       /* Force terminal callback function to 'nothing'   */
  145.     OSView_TmrCntsPrev  = 0;
  147. #if OS_VIEW_PARSE_TASK > 0
  148.     OSView_InitOS();
  149. #endif
  151.     OSView_InitTarget(baud_rate);                           /* Initialize target specific code                 */
  152. }
  154. /*$PAGE*/
  155. /*
  156. *********************************************************************************************************
  157. *                             INITIALIZE THE uC/OS-View TASK AND OS OBJECTS
  158. *********************************************************************************************************
  159. */
  161. #if OS_VIEW_PARSE_TASK > 0
  162. static  void  OSView_InitOS (void)
  163. {
  164. #if OS_TASK_NAME_EN > 0 || OS_EVENT_NAME_SIZE > 7
  165.     INT8U  err;
  166. #endif
  169. #if OS_SEM_EN > 0
  170.     OSView_Sem = OSSemCreate(0);
  171. #if OS_EVENT_NAME_EN > 0
  172.     OSEventNameSet(OSView_Sem, (INT8U *)"uC/OS-View Signal", &err);
  173. #endif
  174. #endif
  176. #if OS_TASK_CREATE_EXT_EN > 0
  177.     #if OS_STK_GROWTH == 1
  178.     (void)OSTaskCreateExt(OSView_Task,
  179.                           (void *)0,                                  /* No arguments passed to OSView_Task() */
  180.                           &OSView_TaskStk[OS_VIEW_TASK_STK_SIZE - 1], /* Set Top-Of-Stack                     */
  181.                           OS_VIEW_TASK_PRIO,                          /* Lowest priority level                */
  182.                           OS_VIEW_TASK_ID,
  183.                           &OSView_TaskStk[0],                         /* Set Bottom-Of-Stack                  */
  184.                           OS_VIEW_TASK_STK_SIZE,
  185.                           (void *)0,                                  /* No TCB extension                     */
  186.                           OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR); /* Enable stack checking + clear stack  */
  187.     #else
  188.     (void)OSTaskCreateExt(OSView_Task,
  189.                           (void *)0,                                  /* No arguments passed to OSView_Task() */
  190.                           &OSView_TaskStk[0],                         /* Set Top-Of-Stack                     */
  191.                           OS_VIEW_TASK_PRIO,                          /* Lowest priority level                */
  192.                           OS_VIEW_TASK_ID,
  193.                           &OSView_TaskStk[OS_VIEW_TASK_STK_SIZE - 1], /* Set Bottom-Of-Stack                  */
  194.                           OS_VIEW_TASK_STK_SIZE,
  195.                           (void *)0,                                  /* No TCB extension                     */
  196.                           OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR); /* Enable stack checking + clear stack  */
  197.     #endif
  198. #else
  199.     #if OS_STK_GROWTH == 1
  200.     (void)OSTaskCreate(OSView_Task,
  201.                        (void *)0,
  202.                        &OSView_TaskStk[OS_VIEW_TASK_STK_SIZE - 1],
  203.                        OS_VIEW_TASK_PRIO);
  204.     #else
  205.     (void)OSTaskCreate(OSView_Task,
  206.                        (void *)0,
  207.                        &OSView_TaskStk[0],
  208.                        OS_VIEW_TASK_PRIO);
  209.     #endif
  210. #endif
  212. #if OS_TASK_NAME_EN > 10
  213.     OSTaskNameSet(OS_VIEW_TASK_PRIO, (INT8U *)"uC/OS-View", &err);
  214. #endif
  215. }
  216. #endif
  218. /*$PAGE*/
  219. /*
  220. *********************************************************************************************************
  221. *                                           uC/OS-View TASK
  222. *********************************************************************************************************
  223. */
  225. #if OS_VIEW_PARSE_TASK > 0
  226. static  void  OSView_Task (void *p_arg)
  227. {
  228.     INT16U     len;
  229.     INT8U      err;
  230. #if OS_SEM_EN == 0 && OS_MBOX_EN > 0
  231.     void      *msg;
  232. #endif
  233. #if OS_CRITICAL_METHOD == 3                       /* Allocate storage for CPU status register          */
  234.     OS_CPU_SR  cpu_sr = 0;
  235. #endif
  238.     (void)p_arg;
  239.     while (1) {
  240. #if OS_SEM_EN > 0
  241.         (void)OSSemPend(OSView_Sem, 0, &err);     /* Wait for a packet to be received                  */
  242. #else
  243. #if OS_MBOX_EN > 0
  244.         (void)OSMboxPend(OSView_Mbox, 0, &err);   /* Wait for a packet to be received                  */
  245. #endif
  246. #endif
  247.         len = OSView_CmdParsePkt();               /* Parse packet and formulate a response             */
  248.         if (len > 0) {                            /* If we have a response                             */
  249.             OS_ENTER_CRITICAL();                  /* Setup transmission of the response                */
  250.             OSView_TxLen = len;
  251.             OS_EXIT_CRITICAL();
  252.             OSView_TxStart();
  253.         }
  254.     }
  255. }
  256. #endif
  258. /*$PAGE*/
  259. /*
  260. *********************************************************************************************************
  261. *                                     uC/OS-View TASK CREATE HOOK
  262. *
  263. * Description: This function MUST be called by uC/OS-II's Task Create Hook function: OSTaskCreateHook().
  264. *********************************************************************************************************
  265. */
  267. void  OSView_TaskCreateHook (OS_TCB *ptcb)
  268. {
  269.     ptcb->OSTCBCyclesStart = OSView_TimeGetCycles();        /* Get the current start time for this task.       */
  270.     ptcb->OSTCBCyclesTot   = 0;                             /* Update the task's total execution time          */
  271. }
  273. /*$PAGE*/
  274. /*
  275. *********************************************************************************************************
  276. *                                     uC/OS-View TASK SWITCH HOOK
  277. *
  278. * Description: This function MUST be called by uC/OS-II's Task Switch Hook function: OSTaskSwHook().
  279. *********************************************************************************************************
  280. */
  282. void  OSView_TaskSwHook (void)
  283. {
  284.     INT32U  cycles;
  287.     cycles                         = OSView_TimeGetCycles();    /* This task is done                           */
  288.     OSTCBCur->OSTCBCyclesTot      += cycles - OSTCBCur->OSTCBCyclesStart;
  289.     OSTCBHighRdy->OSTCBCyclesStart = cycles;                    /* Save absolute #cycles at task activation    */
  290. }
  292. /*
  293. *********************************************************************************************************
  294. *                                       Update 32-bits cycles counter
  295. *
  296. * Description: This function must be called by uC/OS-II's OSTimeTickHook() and is used to maintain a
  297. *              32-bit counter of clock or other cycles.
  298. *
  299. * Returns    : None
  300. *
  301. * Note(s)    : Changes the global variable OSView_CyclesCtr
  302. *********************************************************************************************************
  303. */
  305. void  OSView_TickHook (void)
  306. {
  307.     (void)OSView_TimeGetCycles();
  308. }
  310. /*$PAGE*/
  311. /*
  312. *********************************************************************************************************
  313. *                                           Get time [cycles]
  314. *
  315. * Description: This routine is required for task execution time measurement.  This function needs to
  316. *              return time as accurately as possible and in a 32-bit variable.
  317. *
  318. * Returns    : A 32-bit representation of time.
  319. *********************************************************************************************************
  320. */
  322. INT32U  OSView_TimeGetCycles (void)
  323. {
  324.     INT32U     cycles;
  325. #if OS_VIEW_TMR_32_BITS > 0
  326.     INT32U     cnts32;
  327.     INT32U     cnts32_delta;
  328. #else
  329.     INT16U     cnts16;
  330.     INT16U     cnts16_delta;
  331. #endif
  332. #if OS_CRITICAL_METHOD == 3                                    /* Allocate storage for CPU status register         */
  333.     OS_CPU_SR  cpu_sr = 0;
  334. #endif
  338.     OS_ENTER_CRITICAL();
  339. #if OS_VIEW_TMR_32_BITS > 0
  340.     cnts32              = OSView_TmrRd();                      /* Read current counts of the free running counter  */
  341.     cnts32_delta        = cnts32 - OSView_TmrCntsPrev;
  342.     OSView_TmrCntsPrev  = cnts32;                              /* Save current counts for next time                */
  343.     OSView_CyclesCtr   += cnts32_delta;
  344. #else
  345.     cnts16              = (INT16U)OSView_TmrRd();              /* Read current counts of the free running counter  */
  346.     cnts16_delta        = cnts16 - OSView_TmrCntsPrev;
  347.     OSView_TmrCntsPrev  = cnts16;                              /* Save current counts for next time                */
  348.     OSView_CyclesCtr   += (INT32U)cnts16_delta;
  349. #endif
  350.     cycles              = OSView_CyclesCtr;
  351.     OS_EXIT_CRITICAL();
  352.     return (cycles);
  353. }
  355. /*$PAGE*/
  356. /*
  357. *********************************************************************************************************
  358. *                                       uC/OS-View COMMAND HANDLER
  359. *                                            (Parse Packet)
  360. *********************************************************************************************************
  361. */
  363. static  INT8U  OSView_CmdParsePkt (void)
  364. {
  365.     INT8U cmd0;
  368.     cmd0 = OSView_RxGetINT8U();                             /* First byte contains command                     */
  369.     if (cmd0 == 'C') {
  370.         OSView_CmdSendToApp();
  371.         OSView_TxBufCnt = 0;
  372.         return (0);
  373.     }
  374.     if (OSView_TxBufCnt > 0) {                              /* Do cmds only if Tx of the last one is done      */
  375.         return (0);
  376.     }
  377.     switch (cmd0) {
  378.         case 's':
  379.              OSView_TxStoINT8U(cmd0);
  380.              OSView_CmdGetSysInfo();
  381.              break;
  383.         case 't':
  384.              OSView_TxStoINT8U(cmd0);
  385.              OSView_CmdGetTaskInfo();
  386.              break;
  388.         case 'l':
  389.              OSView_TxStoINT8U(cmd0);
  390.              OSView_CmdGetTaskList();
  391.              break;
  393.         case 'S':
  394.              OSView_TxStoINT8U(cmd0);
  395.              OSView_CmdTickStep();
  396.              break;
  398.         case 'T':
  399.              OSView_TxStoINT8U(cmd0);
  400.              OSView_CmdTrace();
  401.              break;
  403.         case 'b':
  404.              OSView_TxStoINT8U(cmd0);
  405.              OSView_CmdMemRdINT8U();
  406.              break;
  408.         case 'w':
  409.              OSView_TxStoINT8U(cmd0);
  410.              OSView_CmdMemRdINT16U();
  411.              break;
  413.         case 0:
  414.              OSView_TxStoINT8U(cmd0);
  415.              OSView_CmdMemRdINT32U();
  416.              break;
  418.         case '1':
  419.              OSView_TxStoINT8U(cmd0);
  420.              OSView_CmdMemWrINT8U();
  421.              break;
  423.         case '2':
  424.              OSView_TxStoINT8U(cmd0);
  425.              OSView_CmdMemWrINT16U();
  426.              break;
  428.         case '4':
  429.              OSView_TxStoINT8U(cmd0);
  430.              OSView_CmdMemWrINT32U();
  431.              break;
  433.         default:
  434.              break;
  435.     }
  436.     return (OSView_TxBufCnt);
  437. }
  439. /*$PAGE*/
  440. /*
  441. *********************************************************************************************************
  442. *                                       uC/OS-View COMMAND HANDLER
  443. *                                         (Send to Application)
  444. *
  445. * Description: This routine transfers a character to the application.
  446. *********************************************************************************************************
  447. */
  449. static  void  OSView_CmdSendToApp (void)
  450. {
  451.     INT8U  rx_data;
  454.     rx_data = OSView_RxGetINT8U();                               /* Read data typed at terminal                */
  455.     if ((void *)OSView_TerminalRxCallbackFnct != (void *)0) {    /* See if callback is defined                 */
  456.         (*OSView_TerminalRxCallbackFnct)(rx_data);               /* Pass character received to application     */
  457.     }
  458. }
  461. /*
  462. *********************************************************************************************************
  463. *                                       uC/OS-View COMMAND HANDLER
  464. *                                        (Get System Information)
  465. *********************************************************************************************************
  466. */
  468. static  void  OSView_CmdGetSysInfo (void)
  469. {
  470.     INT8U   s[OS_VIEW_CPU_NAME_SIZE+1];
  471.     INT8U   i;
  472.     INT32U  stk_base;
  473.     INT32U  stk_size;
  474.     INT32U  time;
  477.     time = OSTimeGet();                                     /* Send current value of tick counter              */
  478.     OSView_TxStoINT32U(time);
  479.     OSView_TxStoPtr(OSTCBCur);                              /* Current task's OS_TCB                           */
  480.     OSView_TxStoINT16U(OS_VERSION);                         /* Send uC/OS-II's version number                  */
  481.     OSView_TxStoINT8U(1);                                   /* Indicate profiling information will be sent     */
  483.     for (i = 0; i < OS_VIEW_CPU_NAME_SIZE; i++) {           /* Clear buffer to help with debug.                */
  484.         s[i] = 0x00;
  485.     }
  486.     OSView_GetCPUName(s);                                   /* Get Processor Name in string 's'                */
  487.     OSView_TxStoStr(s);
  489.     stk_base = OSView_GetIntStkBase();                      /* Interrupt stack base from port specific file    */
  490.     OSView_TxStoINT32U(stk_base);
  492.     stk_size = OSView_GetIntStkSize();                      /* Interrupt stack size from port specific file    */
  493.     OSView_TxStoINT32U(stk_size);
  494. }
  496. /*$PAGE*/
  497. /*
  498. *********************************************************************************************************
  499. *                                       uC/OS-View COMMAND HANDLER
  500. *                                            (Get Task List)
  501. *********************************************************************************************************
  502. */
  504. static  void  OSView_CmdGetTaskList (void)
  505. {
  506.     INT8U   prio;
  507.     OS_TCB *ptcb;
  510.     OSView_TxStoINT8U('t');                                 /* Identifier for data type                        */
  511.     for (prio = 0; prio <= OS_LOWEST_PRIO; prio++) {
  512.         ptcb = OSTCBPrioTbl[prio];
  513.         if (ptcb != (OS_TCB *)0 && ptcb != (OS_TCB *)1) {   /* Does task exist? (Not a Mutex reserved task)    */
  514.             OSView_TxStoINT32U((INT32U)ptcb);               /* Yes, send the task's TCB address                */
  515.         }
  516.     }
  517. }
  519. /*
  520. *********************************************************************************************************
  521. *                                       uC/OS-View COMMAND HANDLER
  522. *                                         (Get Task Information)
  523. *********************************************************************************************************
  524. */
  526. static  void  OSView_CmdGetTaskInfo (void)
  527. {
  528.     OS_TCB  *ptcb;
  529.     INT32U   cycles;
  530.     INT8U    stat;
  533.     ptcb   = (OS_TCB *)OSView_RxGetINT32U();                         /* Get the desired task's TCB address     */
  534.     cycles = OSView_TimeGetCycles();                                 /* Get timestamp                          */
  535.     OSView_TxStoINT32U(cycles);
  536.     if (ptcb != (OS_TCB *)0 && ptcb != (OS_TCB *)1) {                /* Make sure we have a valid TCB pointer  */
  537.         if (ptcb == OSTCBCur) {
  538.             ptcb->OSTCBCyclesTot  += cycles - ptcb->OSTCBCyclesStart;
  539.             ptcb->OSTCBCyclesStart = cycles;
  540.         }
  541.         OSView_TxStoStr(ptcb->OSTCBTaskName);   /* Task name                              */
  542.         OSView_TxStoINT8U(ptcb->OSTCBPrio);                          /* Prio                                   */
  543.         stat = OSView_CmdGetTaskInfo_TCBStat(ptcb);                  /* Task status                            */
  544.         OSView_TxStoINT8U(stat);
  545.         OSView_TxStoINT32U((INT32U)ptcb->OSTCBEventPtr);             /* Pointer to event task is waiting for.  */
  546.         OSView_TxStoINT32U((INT32U)ptcb->OSTCBDly);                  /* Timeout (i.e. ticks of delayed task)   */
  547.         OSView_TxStoINT32U(ptcb->OSTCBCyclesTot);                    /* ExecTime                               */
  548.         OSView_TxStoINT32U(ptcb->OSTCBCtxSwCtr);                     /* NumActivations                         */
  550.         OSView_TxStoINT32U((INT32U)ptcb->OSTCBStkBase);              /* Stack base address                     */
  551.         OSView_TxStoINT32U(ptcb->OSTCBStkSize * sizeof(OS_STK));     /* Stack size (in #bytes)                 */
  552.         OSView_TxStoINT32U(ptcb->OSTCBStkUsed);                      /* Number of bytes used                   */
  553.         OSView_TxStoINT32U((INT32U)ptcb->OSTCBStkPtr);               /* Current stack pointer address          */
  554.     } else {
  555.         OSView_CmdGetTaskInfo_InvalidTask();
  556.     }
  557.     OSView_TxStoINT16U((INT16U)OSTimeGet());
  558. }
  560. /*$PAGE*/
  561. /*
  562. *********************************************************************************************************
  563. *                                       uC/OS-View COMMAND HANDLER
  564. *                                             (Invalid Task)
  565. *********************************************************************************************************
  566. */
  568. static  void  OSView_CmdGetTaskInfo_InvalidTask (void)
  569. {
  570.     OSView_TxStoStr((INT8U *)"INVALID TASK!");         /* Task name                                       */
  571.     OSView_TxStoINT8U(0);                                   /* Prio                                            */
  572.     OSView_TxStoINT8U(0);                                   /* Stat                                            */
  573.     OSView_TxStoINT32U(0);                                  /* Data                                            */
  574.     OSView_TxStoINT32U(0);                                  /* Timeout                                         */
  575.     OSView_TxStoINT32U(0);                                  /* StackBase                                       */
  576.     OSView_TxStoINT32U(0);                                  /* StackSize                                       */
  577.     OSView_TxStoINT32U(0);                                  /* #Bytes used on stack                            */
  578.     OSView_TxStoINT32U(0);                                  /* Current SP address                              */
  579.     OSView_TxStoINT32U(0);                                  /* ExecTime                                        */
  580.     OSView_TxStoINT32U(0);                                  /* NumActivations                                  */
  581. }
  583. /*
  584. *********************************************************************************************************
  585. *                                       uC/OS-View COMMAND HANDLER
  586. *                                         (Get ptcb->OSTCBStat)
  587. *********************************************************************************************************
  588. */
  590. static  INT8U  OSView_CmdGetTaskInfo_TCBStat (OS_TCB *ptcb)
  591. {
  592.     INT8U stat;
  595.     if (ptcb->OSTCBStat != OS_STAT_RDY) {
  596.         stat = ptcb->OSTCBStat;
  597.     } else {
  598.         if (ptcb->OSTCBDly > 0) {                           /* Task status                                     */
  599.             stat = 0xF0;
  600.         } else {
  601.             stat = ptcb->OSTCBStat;
  602.         }
  603.     }
  604.     return (stat);
  605. }
  607. /*$PAGE*/
  608. /*
  609. *********************************************************************************************************
  610. *                                       uC/OS-View COMMAND HANDLER
  611. *                                              (Memory)
  612. *********************************************************************************************************
  613. */
  615. static  void  OSView_CmdMemRdINT8U (void)
  616. {
  617.     INT32U addr;
  618.     INT8U  nbytes;
  621.     addr   = OSView_RxGetINT32U();
  622.     nbytes = OSView_RxGetINT8U();
  623.     while (nbytes--) {
  624.         OSView_TxStoINT8U(*(INT8U *)addr);
  625.         addr++;
  626.     }
  627. }
  630. static  void  OSView_CmdMemRdINT16U (void)
  631. {
  632.     INT32U addr;
  633.     INT8U  nbytes;
  636.     addr   = OSView_RxGetINT32U();
  637.     nbytes = OSView_RxGetINT8U();
  638.     while (nbytes--) {
  639.         OSView_TxStoINT16U(*(INT16U *)addr);
  640.         addr += 2;
  641.     }
  642. }
  645. static  void  OSView_CmdMemRdINT32U (void)
  646. {
  647.     INT32U addr;
  648.     INT8U  nbytes;
  651.     addr   = OSView_RxGetINT32U();
  652.     nbytes = OSView_RxGetINT8U();
  653.     while (nbytes--) {
  654.         OSView_TxStoINT32U(*(INT32U *)addr);
  655.         addr += 4;
  656.     }
  657. }
  659. /*$PAGE*/
  660. /*
  661. *********************************************************************************************************
  662. *                                       uC/OS-View COMMAND HANDLER
  663. *                                           (Write Functions)
  664. *********************************************************************************************************
  665. */
  667. static  void  OSView_CmdMemWrINT8U (void)
  668. {
  669.     INT8U *p;
  672.     p    = (INT8U *)OSView_RxGetINT32U();
  673.     (*p) = OSView_RxGetINT8U();
  674. }
  677. static  void  OSView_CmdMemWrINT16U (void)
  678. {
  679.     INT16U *p;
  682.     p    = (INT16U *)OSView_RxGetINT32U();
  683.     (*p) = OSView_RxGetINT16U();
  684. }
  687. static  void  OSView_CmdMemWrINT32U (void)
  688. {
  689.     INT32U *p;
  692.     p    = (INT32U *)OSView_RxGetINT32U();
  693.     (*p) = OSView_RxGetINT32U();
  694. }
  696. /*$PAGE*/
  697. /*
  698. *********************************************************************************************************
  699. *                                       uC/OS-View COMMAND HANDLER
  700. *                                          (Tick Step command)
  701. *********************************************************************************************************
  702. */
  704. static  void  OSView_CmdTickStep (void)
  705. {
  706. #if OS_TICK_STEP_EN > 0
  707.     INT8U sub_cmd;
  710.     sub_cmd = OSView_RxGetINT8U();
  711.     switch (sub_cmd) {
  712.         case 0:                                             /* Enable stepping                                 */
  713.              OSTickStepState = OS_TICK_STEP_WAIT;
  714.              break;
  716.         case 1:                                             /* Disable stepping, let tick ISR handle the ticks */
  717.              OSTickStepState = OS_TICK_STEP_DIS;
  718.              break;
  720.         case 2:                                             /* Simulate the occurrence of one tick             */
  721.              OSTickStepState = OS_TICK_STEP_ONCE;
  722.              break;
  723.     }
  724. #endif
  725. }
  727. /*
  728. *********************************************************************************************************
  729. *                                       uC/OS-View COMMAND HANDLER
  730. *                                             (Trace command)
  731. *
  732. * Note(s): Command not currently supported.
  733. *********************************************************************************************************
  734. */
  736. static  void  OSView_CmdTrace (void)
  737. {
  738. }
  740. /*$PAGE*/
  741. /*
  742. *********************************************************************************************************
  743. *                                              Rx Handler
  744. *
  745. * Description: This routine is called from the Rx interrupt service handler.
  746. *********************************************************************************************************
  747. */
  749. void  OSView_RxHandler (INT8U rx_data)
  750. {
  751.     OSView_RxCtr++;
  752.     switch (OSView_RxState) {
  753.         case OS_VIEW_RX_STATE_SD0:                          /* waiting for start first  start delimiter (SD0)  */
  754.              if (rx_data == OS_VIEW_PROTOCOL_RX_SD0) {
  755.                  OSView_RxState = OS_VIEW_RX_STATE_SD1;
  756.                  OSView_RxBufClr();
  757.              }
  758.              break;
  760.         case OS_VIEW_RX_STATE_SD1:                          /* waiting for start second start delimiter (SD1)  */
  761.              if (rx_data == OS_VIEW_PROTOCOL_RX_SD1) {
  762.                  OSView_RxState = OS_VIEW_RX_STATE_LEN;
  763.              } else {
  764.                  OSView_RxState = OS_VIEW_RX_STATE_SD0;
  765.              }
  766.              break;
  768.         case OS_VIEW_RX_STATE_LEN:                          /* waiting for 'len' byte                          */
  769.              if ((rx_data == 0x00) | (rx_data > OS_VIEW_RX_BUF_SIZE)) {
  770.                  OSView_RxState  = OS_VIEW_RX_STATE_SD0;    /* Can not handle this size ...                    */
  771.              } else {
  772.                  OSView_RxChkSum    = rx_data;
  773.                  OSView_RxRemainLen = rx_data;
  774.                  OSView_RxState     = OS_VIEW_RX_STATE_DATA;
  775.              }
  776.              break;
  778.         case OS_VIEW_RX_STATE_DATA:                         /* waiting for data                                */
  779.              OSView_RxStoINT8U(rx_data);
  780.              OSView_RxChkSum += rx_data;
  781.              if (--OSView_RxRemainLen == 0) {
  782.                  OSView_RxState = OS_VIEW_RX_STATE_CHKSUM;
  783.              }
  784.              break;
  786.         case OS_VIEW_RX_STATE_CHKSUM:                       /* waiting for checksum                            */
  787.              OSView_RxChkSum += rx_data;
  788.              if ((OSView_RxChkSum & 0xFF) == 0x00) {
  789.                  OSView_RxState = OS_VIEW_RX_STATE_ED;
  790.              } else {
  791.                  OSView_RxState = OS_VIEW_RX_STATE_SD0;
  792.              }
  793.              break;
  795.         case OS_VIEW_RX_STATE_ED:
  796.              if (rx_data == OS_VIEW_PROTOCOL_RX_ED) {       /* End delimiter ?                                 */
  797.                  OSView_RxPktCtr++;
  798.                  OSView_RxPkt();                            /* Parse received packet                           */
  799.              }
  800.              OSView_RxState = OS_VIEW_RX_STATE_SD0;
  801.              break;
  803.         default:
  804.              OSView_RxState = OS_VIEW_RX_STATE_SD0;
  805.              break;
  806.     }
  807. }
  809. /*$PAGE*/
  810. /*
  811. *********************************************************************************************************
  812. *                                        PARSE RECEIVED PACKET
  813. *
  814. * Description: This function is called when a packet has been received and needs to be processed.
  815. *********************************************************************************************************
  816. */
  818. static  void  OSView_RxPkt (void)
  819. {
  820. #if OS_VIEW_PARSE_TASK > 0
  821. #if OS_SEM_EN > 0
  822.     OSSemPost(OSView_Sem);                         /* We have a whole packet, signal task to parse it! */
  823. #else
  824. #if OS_MBOX_EN > 0
  825.     OSMboxPost(OSView_Mbox, (void *)1);
  826. #endif
  827. #endif
  829. #else
  830.     INT16U   len;
  833.     len = OSView_CmdParsePkt();                    /* We have a whole packet, parse it!                */
  834.     if (len > 0) {
  835.         OSView_TxLen = len;
  836.         OSView_TxStart();
  837.     }
  838. #endif
  839. }
  841. /*$PAGE*/
  842. /*
  843. *********************************************************************************************************
  844. *                                        STORE DATA IN Rx BUFFER
  845. *
  846. * Description: This routine is called whenever a valid byte has been received.
  847. *********************************************************************************************************
  848. */
  850. static  void  OSView_RxStoINT8U (INT8U rx_data)
  851. {
  852.     if (OSView_RxBufCnt < OS_VIEW_RX_BUF_SIZE) {
  853.         OSView_RxBuf[OSView_RxBufCnt++] = rx_data;
  854.     }
  855. }
  858. /*
  859. *********************************************************************************************************
  860. *                                           CLEAR Rx BUFFER
  861. *********************************************************************************************************
  862. */
  864. static  void  OSView_RxBufClr (void)
  865. {
  866.     OSView_RxBufCnt = 0;
  867.     OSView_RxRdIx   = 0;
  868. }
  870. /*
  871. *********************************************************************************************************
  872. *                                     GET 8, 16 or 32-bit DATA
  873. *********************************************************************************************************
  874. */
  876. static  INT8U  OSView_RxGetINT8U (void)
  877. {
  878.     return (OSView_RxBuf[OSView_RxRdIx++]);
  879. }
  882. static  INT16U  OSView_RxGetINT16U (void)
  883. {
  884.     INT16U  lowbyte;
  885.     INT16U  highbyte;
  888.     highbyte = OSView_RxGetINT8U();
  889.     lowbyte  = OSView_RxGetINT8U();
  890.     return ((highbyte << 8) | lowbyte);
  891. }
  894. static  INT32U  OSView_RxGetINT32U (void)
  895. {
  896.     INT32U  highword;
  897.     INT32U  lowword;
  900.     highword = OSView_RxGetINT16U();
  901.     lowword  = OSView_RxGetINT16U();
  902.     return ((highword << 16) | lowword);
  903. }
  905. /*$PAGE*/
  906. /*
  907. *********************************************************************************************************
  908. *                                  START TRANSMISSION OF REPLY PACKET
  909. *********************************************************************************************************
  910. */
  912. void  OSView_TerminalRxSetCallback (void (*call_back)(INT8U rx_data))
  913. {
  914.     OSView_TerminalRxCallbackFnct = call_back;
  915. }
  917. /*$PAGE*/
  918. /*
  919. *********************************************************************************************************
  920. *                                 SEND AN ASCII STRING TO TERMINAL WINDOW
  921. *
  922. * Description: This function allows an application to send strings to the TERMINAL window in the viewer.
  923. *
  924. * Arguments  : s     is a pointer to the string to send.
  925. *
  926. *              dly   allows the calling task to delay itself for 'dly' ticks until the current string
  927. *                    is sent.  If 'dly' is set to 0, then the string will not be sent if a string is
  928. *                    currently in the process of being sent.  In other words, if there is a string currently
  929. *                    being sent and you sent 'dly' to 0, OSView_TxStr() will return to the caller and the
  930. *                    string will not be sent.
  931. *
  932. * Note(s)    : 1) This function MUST be called from a TASK and NOT an ISR.
  933. *********************************************************************************************************
  934. */
  936. void  OSView_TxStr (INT8U *s, INT16U dly)
  937. {
  938.     INT16U  len;
  941.     len = (INT16U)OS_StrLen(s);                           /* Make sure string fits in buffer           */
  942.     if (len >= OS_VIEW_TX_STR_SIZE) {                     /* Force end of string if string too long    */
  943.         len    = OS_VIEW_TX_STR_SIZE - 1;
  944.         s[len] = '';
  945.     }
  946.     if (OSView_TxStrLen > 0) {                            /* Are currently busy sending a string?      */
  947.         if (dly > 0) {                                    /* Yes, does caller want to wait?            */
  948.             while (OSView_TxStrLen > 0) {                 /* Yes, let other tasks run                  */
  949.                 OSView_TxStrDlyCtr++;
  950.                 OSTimeDly(dly);
  951.             }
  952.             OSView_TxStrLen = len;                        /* Update the string length                  */
  953.             strcpy((char *)&OSView_TxStrBuf[0], (char *)s);           /* Copy string to send to buffer             */
  954.             if (OSView_TxStrLen > 0) {
  955.                 OSView_TxStart();
  956.             }
  957.         }
  958.     } else {
  959.         OSView_TxStrLen = len;                            /* Update the string length                  */
  960.         strcpy((char *)&OSView_TxStrBuf[0], (char *)s);               /* Copy string to send to buffer             */
  961.         if (OSView_TxStrLen > 0) {
  962.             OSView_TxStart();
  963.         }
  964.     }
  965. }
  967. /*$PAGE*/
  968. /*
  969. *********************************************************************************************************
  970. *                                  START TRANSMISSION OF REPLY PACKET
  971. *********************************************************************************************************
  972. */
  974. static  void  OSView_TxStart (void)
  975. {
  976. #if OS_CRITICAL_METHOD == 3
  977.     OS_CPU_SR  cpu_sr = 0;
  978. #endif
  981.     OS_ENTER_CRITICAL();
  982.     if (OSView_TxActiveFlag == OS_FALSE) {
  983.         OSView_TxHandler();
  984.         OSView_TxIntEn();
  985.     }
  986.     OS_EXIT_CRITICAL();
  987. }
  989. /*
  990. *********************************************************************************************************
  991. *                                               Tx Handler
  992. *
  993. * Description: This routine is called from the transmitter buffer empty interrupt service handler.
  994. *              It will send out the next byte in the buffer.
  995. *
  996. * Returns:     none
  997. *********************************************************************************************************
  998. */
  1000. void  OSView_TxHandler (void)
  1001. {
  1002.     INT8U  tx_data;
  1005.     switch (OSView_TxState) {
  1006.         case OS_VIEW_TX_STATE_SD0:
  1007.              if (OSView_TxLen > 0 || OSView_TxStrLen > 0) { /* Packet in buffer or string waiting to be send ? */
  1008.                  OSView_Tx1(OS_VIEW_PROTOCOL_TX_SD0);
  1009.                  OSView_TxCtr++;
  1010.                  OSView_TxActiveFlag = OS_TRUE;
  1011.                  OSView_TxState      = OS_VIEW_TX_STATE_SD1;
  1012.                  OSView_TxIx         = 0;
  1013.              } else {                                       /* If there is nothing to do end transmission      */
  1014.                  OSView_TxActiveFlag = OS_FALSE;
  1015.                  OSView_TxIntDis();                         /* No more data to send, disable Tx interrupts     */
  1016.                  break;
  1017.              }
  1018.              break;
  1020.         case OS_VIEW_TX_STATE_SD1:
  1021.              OSView_Tx1(OS_VIEW_PROTOCOL_TX_SD1);
  1022.              OSView_TxCtr++;
  1023.              if (OSView_TxLen > 0) {
  1024.                  OSView_TxState = OS_VIEW_TX_STATE_DATA_LEN;
  1025.              } else {
  1026.                  OSView_TxState = OS_VIEW_TX_STATE_STR_LEN;
  1027.              }
  1028.              break;
  1030.         case OS_VIEW_TX_STATE_DATA_LEN:                       /* Include the packet length in the packet         */
  1031.              OSView_Tx1(OSView_TxLen);
  1032.              OSView_TxCtr++;
  1033.              OSView_TxState  = OS_VIEW_TX_STATE_DATA;
  1034.              OSView_TxChkSum = OSView_TxLen;
  1035.              break;
  1037.         case OS_VIEW_TX_STATE_DATA:
  1038.              tx_data = OSView_TxBuf[OSView_TxIx];
  1039.              OSView_Tx1(tx_data);
  1040.              OSView_TxCtr++;
  1041.              OSView_TxChkSum += tx_data;
  1042.              OSView_TxIx++;
  1043.              if (OSView_TxIx >= OSView_TxLen) {               /* See if we are done sending the packet           */
  1044.                  OSView_TxState  = OS_VIEW_TX_STATE_CHKSUM;
  1045.                  OSView_TxLen    = 0;
  1046.              }
  1047.              break;
  1049.         case OS_VIEW_TX_STATE_STR_LEN:                        /* String sending                                  */
  1050.              OSView_Tx1(OSView_TxStrLen + 1);
  1051.              OSView_TxCtr++;
  1052.              OSView_TxState  = OS_VIEW_TX_STATE_STR_TYPE;
  1053.              OSView_TxChkSum = OSView_TxStrLen + 1;
  1054.              break;
  1056.         case OS_VIEW_TX_STATE_STR_TYPE:
  1057.              OSView_Tx1('C');
  1058.              OSView_TxCtr++;
  1059.              OSView_TxState   = OS_VIEW_TX_STATE_STR_DATA;
  1060.              OSView_TxChkSum += 'C';
  1061.              break;
  1063.         case OS_VIEW_TX_STATE_STR_DATA:
  1064.              tx_data = OSView_TxStrBuf[OSView_TxIx];
  1065.              OSView_Tx1(tx_data);
  1066.              OSView_TxCtr++;
  1067.              OSView_TxChkSum += tx_data;
  1068.              if (++OSView_TxIx >= OSView_TxStrLen) {
  1069.                  OSView_TxState  = OS_VIEW_TX_STATE_CHKSUM;
  1070.                  OSView_TxStrLen = 0;
  1071.              }
  1072.              break;
  1074.         case OS_VIEW_TX_STATE_CHKSUM:                         /* Epilog ... checksum & end delimiter             */
  1075.              OSView_Tx1(OSView_TxChkSum);
  1076.              OSView_TxCtr++;
  1077.              OSView_TxState = OS_VIEW_TX_STATE_ED;
  1078.              break;
  1080.         case OS_VIEW_TX_STATE_ED:
  1081.              OSView_Tx1(OS_VIEW_PROTOCOL_TX_ED);
  1082.              OSView_TxCtr++;
  1083.              OSView_TxState  = OS_VIEW_TX_STATE_SD0;
  1084.              OSView_TxBufCnt = 0;                             /* Clear the Tx buffer                             */
  1085.              OSView_TxPktCtr++;
  1086.              break;
  1088.         default:
  1089.              OSView_TxState      = OS_VIEW_TX_STATE_SD0;
  1090.              OSView_TxActiveFlag = OS_FALSE;
  1091.              OSView_TxIntDis();                               /* No more data to send, disable Tx interrupts     */
  1092.              break;
  1093.     }
  1094. }
  1096. /*$PAGE*/
  1097. /*
  1098. *********************************************************************************************************
  1099. *                                     STORE 8, 16 or 32-bit DATA
  1100. *********************************************************************************************************
  1101. */
  1103. static  void  OSView_TxStoINT8U (INT8U tx_data)
  1104. {
  1105.     if (OSView_TxBufCnt < OS_VIEW_TX_BUF_SIZE) {
  1106.         OSView_TxBuf[OSView_TxBufCnt++] = tx_data;
  1107.     }
  1108. }
  1111. static  void  OSView_TxStoINT16U (INT16U tx_data)
  1112. {
  1113.     OSView_TxStoINT8U(tx_data >> 8);
  1114.     OSView_TxStoINT8U(tx_data & 0x00FF);
  1115. }
  1118. static  void  OSView_TxStoINT32U (INT32U tx_data)
  1119. {
  1120.     OSView_TxStoINT16U(tx_data >> 16);
  1121.     OSView_TxStoINT16U(tx_data & 0x0000FFFFL);
  1122. }
  1125. static  void  OSView_TxStoPtr (void *ptr)
  1126. {
  1127.     INT32U  tx_data;
  1130.     tx_data = (INT32U)ptr;
  1131.     OSView_TxStoINT16U(tx_data >> 16);
  1132.     OSView_TxStoINT16U(tx_data & 0x0000FFFFL);
  1133. }
  1136. static  void  OSView_TxStoStr (INT8U *s)
  1137. {
  1138.     INT8U   len;
  1139.     INT8U   i;
  1140.     INT8U  *ps;
  1143.     len = 0;
  1144.     ps  = s;
  1145.     if (ps != (INT8U *)0) {                                 /* Calculate length of string                      */
  1146.         while (*ps) {
  1147.             ps++;
  1148.             len++;
  1149.         }
  1150.     }
  1151.     OSView_TxStoINT8U(len);                                 /* Store string, length first                      */
  1152.     ps = s;
  1153.     for (i = 0; i < len; i++) {
  1154.         OSView_TxStoINT8U((INT8U)*ps);
  1155.         ps++;
  1156.     }
  1157. }
  1159. #endif