μC/OS-II实验：实验四消息队列

现在的位置: 首页 > 综合 > 正文

μC/OS-II实验：实验四消息队列

2013年08月11日 ⁄ 综合 ⁄ 共 7874字 ⁄ 字号小中大 ⁄ 评论关闭

实验描述：

在本实验中，设计了 6 个普通应用任务：TA0（优先级为 20）、TA1（优先级为 21）、TA2（优先级为 22）、TA3（优先级为 23）、TA4（优先级为 25）、TA5（优先级为 26），以及一个控制任务 TaskCon（优先级为 19）。

uC/OS-II 中，等待消息的任务总是按照优先级的高低来决定获得消息的顺序的等待消息的任务总是按照优先级的高低来决定获得消息的顺序的。

具体的设计思路为：

创建队列的功能：创建一个等待属性为 FIFO 的消息队列 1；创建一个等待属性为LIFO 的消息队列 2。
考察以 FIFO 方式释放消息的消息队列：由任务 TA0、TA1、TA2 等待队列 1 中的消息。TA0、TA1、TA2 使用相同的任务代码（Taskq1 函数）。
考察以 LIFO 方式释放消息的消息队列：由任务 TA3、TA4、TA5 等待队列 2 中的消息。TA3、TA4、TA5 使用相同的任务代码（Taskq2 函数）。
考察清空消息队列、查询消息队列的功能查询消息队列的功能： TaskCon 任务向队列 2 中连续发送 6 条消息，然后查询消息数；清空该队列后再查询。

考察删除消息队列的安全性：在任务 TA3、TA4、TA5 等待队列 2 中的消息的过程中，让 TaskCon 删除队列 2；当队列 2 被删除后，检查任务 TA3、TA4、TA5 调用接收消息的函数是否返回错误码。

涉及的μC/OS-II系统函数：

。。。

实验代码：

 app.c

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

void TaskQueue1(void* pdata)
{
    INT8U err;
    INT8U id;
    void* msg;
    id = *(int*)pdata;

    while(1)
    {
        OSTimeDlyHMSM(0,0,1,0);
        msg = OSQPend(q1,0,&err);
        switch(err)
        {
            case OS_NO_ERR:
                /* If it is normally, just print the string.*/
                printf("Task_%d got %s \r\n", id, (char*)msg);
                OSTimeDlyHMSM(0,0,1,0);
                break;
            default:
                /* If the queue is empty or has been deleted, print another string.*/
                printf("Queue1 %d is empty! \r\n",id);
                OSTimeDlyHMSM(0,0,1,0);
                break;
        }
    }
}

void TaskQueue2(void* pdata)
{
    INT8U err;
    INT8U id;
    void* msg;
    id = *(int*)pdata;
    while(1)
    {
        OSTimeDlyHMSM(0,0,1,0);
        msg = OSQPend(q2,0,&err);
        switch(err)
        {
            case OS_NO_ERR:
                /* If it is normally, just print the string.*/
                printf("Task_%d got %s \r\n", id+N_TASKS, (char*)msg);
                OSTimeDlyHMSM(0,0,1,0);
                break;
            default:
                /* If the queue is empty or has been deleted, print another string.*/
                printf("Queue1 %d is empty! \r\n",id+N_TASKS);
                OSTimeDlyHMSM(0,0,1,0);
                break;
        }
    }
}

void TaskCon(void* pdata)
{
    INT8U  i,j;
    INT8U  err;
    INT8S  note=1;                                                      /* for flush the queue                  */
    INT8S  del=3;                                                       /* for delete the queue                 */
    OS_EVENT *q;
    OS_Q_DATA qdata;
    static char *queue1msg[MSG_SIZE]={                                  /* queue1's message                      */
                        "message0",
                        "message1",
                        "message2",
                        "message3",
                        "message4",
                        "message5"
                        };
    static char *queue2msg[MSG_SIZE]={                                  /* queue2's message                      */
                        "messageA",
                        "messageB",
                        "messageC",
                        "messageD",
                        "messageE",
                        "messageF"
                        };

    while(1)
    {
        printf("...........................ADD MESSAGE TO QUEUE_1..............................\r\n");
        for( i = 0 ; i < MSG_SIZE ; i++ )
        {
            err = OSQPostFront(q1,(void*)queue1msg[i]);                 /* post message to q1 LIFO                     */
            switch(err)
            {
                case OS_NO_ERR:
                    printf("Queue1 %d add %s\r\n",i,queue1msg[i]);
                    OSTimeDlyHMSM(0, 0, 0, 500);
                    break;
                case OS_Q_FULL:
                    printf("Queue1 is full, CANNOT add.\r\n");
                    OSTimeDlyHMSM(0, 0, 0, 500);
                    break;
                default :
                    break;
            }
        }
        if(del>=0)
        {
            printf("...........................ADD MESSAGE TO QUEUE_2..............................\r\n");
        }

        for( j = 0 ; j < MSG_SIZE ; j++ )
        {
            err = OSQPost(q2,(void*)queue2msg[j]);                  /* post message to q2 FIFO                     */
            switch(err)
            {
                case OS_NO_ERR:
                    printf("Queue2 %d add %s\r\n",j,queue2msg[j]);
                    OSTimeDlyHMSM(0, 0, 0, 500);
                    break;
                case OS_Q_FULL:
                    printf("Queue2 is full, CANNOT add. \r\n");
                    OSTimeDlyHMSM(0, 0, 0, 500);
                    break;
                default :
                    break;
            }
        }

        if(del>=0)
        {
            if(note==1)
            {
                OSQFlush(q2);
                printf("...........................ADD MESSAGE TO QUEUE_2..............................\r\n");
                printf("..............................CLEAR UP QUEUE_2.................................\r\n");
                note=0;
            }
            else
            {
                note=1;
            }
        }

        err=OSQQuery(q1,&qdata);                                        /* get the information about q1                 */
        if(err==OS_NO_ERR)
        {
            printf("\r\n");
            printf("Queue1'information:\r\n");
            printf("NextMsg:\t%s\r\nNumMsg:\t%d\r\nQSize:\t%d\r\n",(char *)qdata.OSMsg,qdata.OSNMsgs,qdata.OSQSize);
            printf("\r\n");
        }                                                           /* print the information about q1               */
        OSTimeDlyHMSM(0, 0, 0, 500);                                /* Wait 500 minisecond                          */
        if(del==0)
        {
            q=OSQDel(q2,OS_DEL_ALWAYS,&err);                        /* delete the  q2                               */
            if(q==(OS_EVENT *)0)
            {
                printf("DELETE Queue2 OK!\r\n");
            }
        }
        else
        {
            del--;
            printf( "DELETE Queue2 FAILED!\r\n");
        }
    }
}

 app.h

1
2
3
4
5
6

GLOBAL INT8U TaskData[N_TASKS];
#define MSG_SIZE 6
GLOBAL void* msg1[MSG_SIZE];
GLOBAL void* msg2[MSG_SIZE];
GLOBAL OS_EVENT *q1;
GLOBAL OS_EVENT *q2;

 app_cfg.h

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#define QUEUE1_STK_SIZE     64
#define QUEUE2_STK_SIZE     64
#define COM_STK_SIZE        64

#define QUEUE_TASK_Prio 20
#define COM_TASK_Prio 19

#define N_TASKS 3
GLOBAL OS_STK   TASK_QUEUE1_STK[N_TASKS][QUEUE1_STK_SIZE];
GLOBAL OS_STK   TASK_QUEUE2_STK[N_TASKS][QUEUE2_STK_SIZE];
GLOBAL OS_STK   TASK_COM_STK[COM_STK_SIZE];

void TaskQueue1(void* pdata);
void TaskQueue2(void* pdata);
void TaskCon(void* pdata);

 main.c:TaskStart

1
2
3
4
5
6
7
8
9
10

/* 实验四  消息队列 */
for(i = 0; i < N_TASKS; i++)
{
    TaskData[i] = i;
    OSTaskCreate(TaskQueue1, (void *)&TaskData[i], (OS_STK *)&TASK_QUEUE1_STK[i][QUEUE1_STK_SIZE - 1], QUEUE_TASK_Prio + i);
    OSTaskCreate(TaskQueue2, (void *)&TaskData[i], (OS_STK *)&TASK_QUEUE2_STK[i][QUEUE2_STK_SIZE - 1], QUEUE_TASK_Prio + i + N_TASKS);
}
OSTaskCreate(TaskCon, (void *)0, (OS_STK *)&TASK_COM_STK[COM_STK_SIZE - 1], COM_TASK_Prio);

 main.c

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

int main(void)
{
BSP_Init();

    OSInit();
    q1 = OSQCreate(msg1,6);
    q2 = OSQCreate(msg2,6);

    OSTaskCreate( TaskStart,
                    (void *)0,  //parameter
                    (OS_STK *)&TASK_START_STK[START_STK_SIZE-1],
                    START_TASK_Prio );
    OSStart();

    return 0;
}

实验结果：

TaskCon任务不停的“喂”消息，TaskQueue1和TaskQueue2“吃”消息。并且前者每隔note次就flush一下q2，在del次数之后产出了q2消息队列。

注意：在调用OSQQuery时，需要定义一个OS_Q_DATA qdata;不能OS_Q_DATA *qdata;然后err=OSQQuery(q1,&qdata);要是按照后者调用方式：err=OSQQuery(q1,qdata);就会触发void HardFault_Handler(void)中断。

原因就是没有申请空间。

【上篇】基于java的图片文件格式转换和线性缩放
【下篇】Java RMI 入门

作者: tinkle

该日志由 tinkle 于11年前发表在综合分类下，最后更新于 2013年08月11日.
转载请注明: μC/OS-II实验：实验四消息队列 | 学步园 +复制链接

抱歉!评论已关闭.

学步园