vxworks使用说明书.txt

VxWorks使用说明书

卸载一个加载的模块 
Shell命令unld 
删除任务 
Shell命令td 
复位目标机 
Shell命令reboot 
用该命令的好处：目标服务器自动与目标代理重新链接，Shell自动重启 
查看任务 
在Browser对象信息窗口输入待查看的任务名或ID 
查看信号量 
在Browser对象信息窗口输入待查看的信号量名或ID 
查看消息队列 
在Browser对象信息窗口输入待查看的消息队列命或ID 
内存分区 
在Browser对象信息窗口输入待查看的内存分区ID 
看门狗 
在Browser对象信息窗口输入待查看的看门狗ID 
类（class） 
在Browser对象信息窗口输入待查看的类的ID 
查看内存使用（模块使用内存的情况） 
Browser的内存使用窗口 
查看任务列表（系统里的所有任务） 
Browser的任务列表窗口 
查看CPU占用率 
Browser的Spy窗口 
查看堆栈使用情况 
Browser的堆栈检查窗口 

注： 
* Shell可以通过菜单命令Debug | Shell启动 
* Shell的原语可以通过在Shell中输入help列出 
* Browser可以通过菜单命令Debug | Browser启动 
* Debugger命令窗口的命令可以通过在命令窗口输入help列出 

8、任务调试模式下的多任务调试 

在任务调试模式下，在一个集成环境中，在一个任务中调试，在另一个任务中设置断点，设置的断点不起作用。这是因为一个调试器只
能处理一个TCB（任务控制块），每个任务都有一个TCB，因此一个调试器只能调试一个任务，要调试几个任务就要启动几个调试器。一
个集成环境只能启动一个调试器，所以要调试几个任务就要启动几个集成环境。另外，需要在被调试的任务的待调试的第一条语句前加
入taskSuspend(0)语句，挂起该任务，否则任务就可能会在调试前被执行。 

下面是多任务调试的测试用例的源代码 
/* VxWorks includes */ 
#include        "vxWorks.h" 
#include        "taskLib.h" 
#include        "stdio.h" 
#include        "msgQLib.h" 

int g_lTaskATid; 
int g_lTaskBTid; 
MSG_Q_ID g_MsgQ1id; 
MSG_Q_ID g_MsgQ2id; 

void MultiTaskTestTaskA(void)  
{ 
    char cMsgToTaskB[100]; 
    char cMsgFromTaskB[100]; 

    sprintf(cMsgToTaskB,"To TaskB \n"); 

    printf(" Hello from MultiTaskTestTaskA \n"); 

    /*start point of debugging for  MultiTaskTestTaskA*/ 
    taskSuspend(0); 
     
    for(;;) 
    {     
        printf(" Hello from MultiTaskTestTaskA \n"); 

        /*Send message to MultiTaskTestTaskB*/ 
             
       msgQSend(g_MsgQ1id,cMsgToTaskB,sizeof(cMsgToTaskB),WAIT_FOREVER,MSG_PRI_NORMAL);  

        /*Receive message from MultiTaskTestTaskB*/ 
        msgQReceive(g_MsgQ2id,cMsgFromTaskB,100,WAIT_FOREVER); 
        printf("%s",cMsgFromTaskB); 
    } 
     
} 

void MultiTaskTestTaskB(void)   
{ 
    char cMsgToTaskA[100]; 
    char cMsgFromTaskA[100]; 

    sprintf(cMsgToTaskA,"To TaskA \n"); 

    printf(" Hello from MultiTaskTestTaskB \n"); 

    /*start point of debugging for  MultiTaskTestTaskA*/ 
    taskSuspend(0); 

    for(;;) 
    { 
        printf(" Hello from MultiTaskTestTaskB \n"); 
         
        /*Send message to MultiTaskTestTaskA*/ 
        msgQSend(g_MsgQ2id,cMsgToTaskA,sizeof(cMsgToTaskA),WAIT_FOREVER,                  MSG_PRI_NORMAL);  

        /*Receive message from MultiTaskTestTaskA*/ 
        msgQReceive(g_MsgQ1id,cMsgFromTaskA,100,WAIT_FOREVER); 
        printf("%s",cMsgFromTaskA); 
    } 
} 


/*This function spawns MultiTaskTestTaskA and MultiTaskTestTaskB , creates g_MsgQ1id and g_MsgQ2id , is entry for 
debugging.*/ 
void  MultiTaskTestInit(void) 
{ 
    printf(" Hello from MultiTaskTestInit \n"); 

    g_MsgQ1id=msgQCreate(20,100,MSG_Q_FIFO); 
    if(g_MsgQ1id==NULL) 
    { 
        printf(" ERROR: create g_MsgQ1 error \n"); 
    } 

    g_MsgQ2id=msgQCreate(20,100,MSG_Q_FIFO); 
    if(g_MsgQ1id==NULL) 
    { 
        printf(" ERROR: create g_MsgQ2 error \n"); 
    } 
  
     
    printf(" Spawning a new task called MultiTaskTestTaskA \n\n"); 
    g_lTaskATid = taskSpawn("MultiTaskTestTaskA", 100,0,10000,                                                                                          (FUNCPTR)MultiTaskTestTaskA, 0,0,0,0,0,0,0,0,0,0); 
    if(g_lTaskATid == ERROR) 
    {  
        printf(" ERROR: task did not spawn \n"); 
        exit(1); 
    } 

    printf(" Spawning a new task called MultiTaskTestTaskB  
\n"); 
    g_lTaskBTid = taskSpawn("MultiTaskTestTaskB", 100,0,10000,                                                                                           (FUNCPTR)MultiTaskTestTaskB, 0,0,0,0,0,0,0,0,0,0);                                                              
   if(g_lTaskBTid == ERROR) 
    {  
        printf(" ERROR: task did not spawn \n"); 
        exit(1); 
    } 
  
  exit(0); 
} 

多任务调试步骤： 
* 用-g选项编译源代码产生目标文件 
* 下载产生的目标文件 
* 在MultiTaskTestInit函数的开始设置断点 
* 把MultiTaskTestInit设置为调试任务的人口函数 
* 单步执行产生MultiTaskTestTaskA任务的语句后可以在串口（超级终端）上看到字符串Hello from MultiTaskTestTaskA，用Browser
查看任务，可以看到任务MultiTaskTestTaskA出于挂起态（suspended），表明程序执行了taskSuspend(0)语句。 
* 运行另一个Tornado集成环境 
* Attach任务MultiTaskTestTaskA， 
* 在语句msgQReceive(g_MsgQ2id,cMsgFromTaskB,100,WAIT_FOREVER)的下一条语句处设置断点 
* 运行任务MultiTaskTestTaskA。可以看到没有执行到断点处，用Browser查看任务状态，MultiTaskTestTaskA出于阻塞态（pended），
因为它在等待消息。 
* 单步执行MultiTaskTestInit到产生MultiTaskTestTaskB任务的下一条语句，可以看到MultiTaskTestTaskB任务处于挂起态 
* 再运行另一个Tornado集成环境 
* Attach任务MultiTaskTestTaskB， 
* 在语句msgQReceive(g_MsgQ1id,cMsgFromTaskA,100,WAIT_FOREVER)下一条语句处设置断点 
* 运行任务MultiTaskTestTaskB。可以看到执行到断点处停下。这是因为MultiTaskTestTaskA任务已经发送一条消息到MultiTaskTestTaskB
的接收队列中。 
* 此时，可以看到MultiTaskTestTaskA任务也运行到断点处，因为为MultiTaskTestTaskB任务已经发送一条消息到MultiTaskTestTaskA的
接收队列中。  

9、系统调试模式下程序的调试 
Tornado集成环境提供两种调试模式：任务调试模式和系统调试模式。在任务调试模式下，在一个集成环境下一个时间内只能调试一个任务。
调试只影响当前被调试的任务，其它任务正常运行。在系统调试模式下，可以同时调试多个任务、中断服务程序（ISR），调试影响整个
系统。 
Tornado1.0集成环境下，在系统模式下进行程序调试，主机与目标机之间必须使用串口通信。Tornado2.0集成环境提供了通过网口进行系
统模式调试的功能。 
系统缺省使用网口通信，如果需要使用串口通信，需要修改文件C: \ Tornado \ target \ config  
} all \ configAll.h的一些宏定义，修改为： 
#define WDB_COMM_TYPE        WDB_COMM_SERIAL   /*使用串口通信*/ 
#define WDB_TTY_CHANNEL    0                                         /*使用第一个串口*/ 
#define WDB_TTY_BAUD          38400                                 /*波特率：38400bps*/ 

重新编译链接vxWorks。 
在启动目标服务器时，要选择串口通信，并进行相应配置。 

9.1 系统调试模式下多任务的调试： 
调试使用的源代码与任务调试模式中使用的代码相同。但是，需要去掉为了能够在任务调试模式下进行多任务调试的MultiTaskTestTaskA
和MultiTaskTestTaskB中的语句taskSuspend(0);。 

多任务调试步骤： 
* 用-g选项编译源代码产生目标文件。 
* 下载产生的目标文件。 
* 在MultiTaskTestInit函数的开始设置断点。 
* 在Debugger命令窗口输入命令attach system进入系统调试模式。 
* 在Shell窗口输入命令sp MultiTaskTestInit产生一个以MultiTaskTestInit为入口函数的任务，因为整个系统都停下了，新产生的任务
还没有执行，这可以通过在Debugger命令窗口输入命令info threads显示当前系统中的任务列表看出来。 
* 执行菜单命令Debug | Continue继续运行程序。 
* 系统在设置的断点处停下。 
* 在函数MultiTaskTestTaskA中的语句msgQReceive(g_MsgQ2id,cMsgFromTaskB, 100,WAIT_FOREVER)的下一条语句处设置断点。 
* 在函数MultiTaskTestTaskB中的语句msgQReceive(g_MsgQ1id,cMsgFromTaskA, 100,WAIT_FOREVER)的下一条语句处设置断点。 
* 执行菜单命令Debug | Continue继续运行程序。 
* 程序在任务MultiTaskTestTaskB中的断点处停下（为什么不是在任务MultiTaskTestTaskA中停下？请考虑）。 
* 执行菜单命令Debug | Continue继续运行程序。 
* 程序在任务MultiTaskTestTaskA中的断点处停下。 
* 执行菜单命令Debug | Continue继续运行程序。 
* 程序又一次在任务MultiTaskTestTaskA中的断点处停下（为什么停两次？请考虑）。 
* 执行菜单命令Debug | Continue继续运行程序。 
* 程序在任务MultiTaskTestTaskB中的断点处停下。 

9.2 中断服务程序的调试 
中断服务程序只能在系统调试模式下调试，不能在任务调试模式下调试。因为中断服务程序是作为系统的一部分运行，不是以任务方式运
行，因此不需要为它产生任务。 

中断服务程序调试步骤： 
* 用-g选项编译源代码产生目标文件。 
* 下载产生的目标文件。 
* 在MultiTaskTestInit函数的开始设置断点。 
* 在Debugger命令窗口输入命令attach system进入系统调试模式。 
* 执行菜单命令Debug | Continue继续运行程序。 
* 如果产生相应的中断，程序就会在中断服务程序的断点处停下。进行需要的调试。 

------------------------全文完------------------------------  



应用示例分析(demo例子程序windDemo.c) 
   通过对一具体实例的分析，对任务的创建、任务间通信、内存分配、消息管理等VxWorks系统应用更进一步的了解。 

/* windDemo - repeatedly test various kernel function */ 

/* 
modification history 
-------------------- 
02c,23aug93,jcf  fixed synchronization. 
02b,01aug93,dvs  fixed loop count printing. 
02a,18mar93,dvs  took out timer/benchmark information. 
                 ansified code. 
general cleanup of code to use as MicroWorks demo. 
01a,12nov90,shl  written. 
*/ 

/* 
DESCRIPTION 
This program repeatedly exercises different kernel facilities of  
the Wind kernel. 

The functions involved include the use of semaphores as sychronization 
and mutual exclusion primitives, the use of taskSuspend()/taskResume() for task control, the use of message queues for 
communication and the  
use of watchdogs for task timeouts. 

To exercise these kernel facilities two tasks are used, a high priority task and a low priority task. The high priority 
task executes functions with which the resources are not available. As the high priority task blocks, the low priority 
task takes over and makes available the resources that the high priority task is waiting for. This may sound simple at 
first but the underlying execution of this test program involves context switching, rescheduling of tasks, and shuffling 
of the ready queue, pend queue, and the timer queue. 

These functions are chosen because they are the most commonly used 
functions in sychronization, mutual exclusion, task control, inter-task communication and timer facilities. These are 
the basic building blocks of the operating system itself and also used in applications.  Repeatedly execution of this 
"death loop" is a good indication of how the system will perform in real-life as these functions are utiltized heavily
 in every application. 

The following is the thread of execution of this test program. 


     Higher Priority     Lower Priority 
  Task1     Task2