task.cpp

练习并掌握多任务实时操作系统下Task 调度、Task 间主要通信手段（信号量、消息队列等）、RISC 处理器 I/O 端口控制等内容

#include <vxworks.h>
#include <tasklib.h>
#include <syslib.h>
#include <tylib.h>
#include <fiolib.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <msgQLib.h>
#include <logLib.h>

#define  MAX_MSGS    (10)
#define  MAX_MSG_LEN (100)
#define  STACK_SIZE  2000
#define  DELAY_TICKS 50

struct msgType
{
    int type;     // type
    int src;      // who sends this message
    int led;      // for led command, which led to be light
    char msg[64]; // for show command or error message
};

MSG_Q_ID msgQ_A, msgQ_C, msgQ_D;
SEM_ID synSem;
int stdIN, stdOUT;
int tid_A, tid_B, tid_C, tid_D;

int bye();
int task_A();
int task_B();
int task_C();
int task_D();

int main()
{
    // this is needless...
    // stdIN = ioGlobalStdGet(0);
    // stdOUT = ioGlobalStdGet(1);
    // stdIN = ioTaskStdGet(0, 0);
    // stdOUT = ioTaskStdGet(0, 1);

    // ioctl(stdOUT, FIOFLUSH, 0);
    // ioctl(stdOUT, FIOSETOPTIONS, OPT_RAW);

    // just go to the real main.....
    tid_A = taskSpawn("A", 200, 0, STACK_SIZE, (FUNCPTR)task_A,0,0,0,0,0,0,0,0,0,0);

    return 0;
}

int bye()
{
    taskDelete(tid_A);
    taskDelete(tid_B);
    taskDelete(tid_C);
    taskDelete(tid_D);

    semDelete(synSem);

    msgQDelete(msgQ_A);
    msgQDelete(msgQ_C);
    msgQDelete(msgQ_D);

    // ioctl(stdOUT, FIOSETOPTIONS, OPT_TERMINAL);
}

int task_A()
{
    struct msgType msgBuf[1];

    msgQ_A = msgQCreate(MAX_MSGS, MAX_MSG_LEN, MSG_Q_PRIORITY);
    msgQ_C = msgQCreate(MAX_MSGS, MAX_MSG_LEN, MSG_Q_PRIORITY);
    msgQ_D = msgQCreate(MAX_MSGS, MAX_MSG_LEN, MSG_Q_PRIORITY);

    synSem = semCCreate(SEM_Q_FIFO, 3);
    tid_B = taskSpawn("B", 200, 0, STACK_SIZE, (FUNCPTR)task_B,0,0,0,0,0,0,0,0,0,0);
    tid_C = taskSpawn("C", 200, 0, STACK_SIZE, (FUNCPTR)task_C,0,0,0,0,0,0,0,0,0,0);
    tid_D = taskSpawn("D", 200, 0, STACK_SIZE, (FUNCPTR)task_D,0,0,0,0,0,0,0,0,0,0);
    semFlush(synSem);

    while (1)
    {
        msgQReceive(msgQ_A, (char *)msgBuf, MAX_MSG_LEN, WAIT_FOREVER);
        logMsg("Task%d:%s...\n", msgBuf->src, (int)msgBuf->msg, 0, 0, 0, 0);
    }

    return 0;
}

/*
 * 0   exit
 * 1   show [string]
 * 2   ledon [number]
 * 3   ledoff [number]
 * -1  error: unknown command
 * -2  error: parament lost
 */
int read_cmd(char *cmdline, struct msgType *msg)
{
    char *cmd, *para = 0;
    int i, ret;

    cmd = cmdline;
    for (i=0; cmdline[i]; i++)
    {
        if (cmdline[i]==' ') /* i ignored tab */
        {
            cmd[i++] = 0;
            para = cmdline + i;
        }
    }

    if (!strcmp(cmd, "exit"))
        ret = 0;
    else if (!strcmp(cmd, "show"))
    {
        if (para)
        {
            ret = 1;
            strcpy(msg->msg, para);
        }
        else
        {
            ret = -2;
            strcpy(msg->msg, "parament lost");
        }
    }
    else if (!strcmp(cmd, "ledon"))
    {
        if (para)
        {
            ret = 2;
            sscanf(para, "%d", &(msg->led));
        }
        else
        {
            ret = -2;
            strcpy(msg->msg, "parament lost");
        }
    }
    else if (!strcmp(cmd, "ledoff"))
    {
        if (para)
        {
            ret = 3;
            sscanf(para, "%d", &(msg->led));
        }
        else
        {
            ret = -2;
            strcpy(msg->msg, "parament lost");
        }
    }
    else
    {
        // unknown command
        ret = -1;
        strcpy(msg->msg, "unknown command");
    }
    msg->type = ret;

    return ret;
}

int task_B()
{
    char buf[64];
    int cmd;
    struct msgType msgBuf[1];

    semTake(synSem, WAIT_FOREVER);
    while (1)
    {
        gets(buf);

        msgBuf->msg[0] = 0;
        msgBuf->src = 2;

        cmd = read_cmd(buf, msgBuf);
        switch (cmd)
        {
            case 0:  /* exit */
                printf("bye-bye.\n");
                taskSpawn("bye", 200, 0, STACK_SIZE, (FUNCPTR)bye,0,0,0,0,0,0,0,0,0,0);
                break;
            case 1:  /* show */
                msgQSend(msgQ_D, (char *)msgBuf, sizeof(msgBuf), WAIT_FOREVER, MSG_PRI_NORMAL);
                break;
            case 2:  /* ledon */
            case 3:  /* ledoff */
                msgQSend(msgQ_C, (char *)msgBuf, sizeof(msgBuf), WAIT_FOREVER, MSG_PRI_NORMAL);
                break;
            case -1: /* error */
                msgQSend(msgQ_A, (char *)msgBuf, sizeof(msgBuf), WAIT_FOREVER, MSG_PRI_NORMAL);
                break;
            case -2: /* error */
                msgQSend(msgQ_A, (char *)msgBuf, sizeof(msgBuf), WAIT_FOREVER, MSG_PRI_NORMAL);
            default:
                /* never come here, unless hardware is broken */
                break;
        }
    }

    return 0;
}

int task_C()
{
    struct msgType msgBuf[1];
    semTake(synSem, WAIT_FOREVER);

    while (1)
    {
        msgQReceive(msgQ_C, (char *)msgBuf, MAX_MSG_LEN, WAIT_FOREVER);
        if (msgBuf->led>=0 && msgBuf->led<4)
        {
            // led light light
        }
        else
        {
            msgBuf->type = -1;
            msgBuf->src = 3;
            strcpy(msgBuf->msg, "bad led id");
            msgQSend(msgQ_A, (char *)msgBuf, sizeof(msgBuf), WAIT_FOREVER, MSG_PRI_NORMAL);
        }
    }

    return 0;
}

int task_D()
{
    struct msgType msgBuf;
    semTake(synSem, WAIT_FOREVER);

    while (1)
    {
        msgQReceive(msgQ_D, (char *)&msgBuf, MAX_MSG_LEN, WAIT_FOREVER);
        printf("msg-D> %s\n", msgBuf.msg);
    }

    return 0;
}