1 监控任务设计

1.1 概述

监控任务用于监控CPU利用率、管脚状态，然后在串口中报告状态。示例较简单，也可以做得更为复杂些。系统结构图如下：

监控任务设计：
虽然监控任务基本上也是周期性去检查各个状态；但是系统中没有使用软定时器去周期检查。因为除周期性检查状态外，还需要做一些其它工作，在定时函数中完成并不方便。如果再考虑以后想在监控任务中做一些其它耗时操作，如果这些也放在定时器中去做，则会影响到系统中其它定时器。

监控任务的主要工作是等待邮箱中的消息。一旦等不到超时，则认为需要检查状态。不过，这种方式有个缺点：比如5s监控，在4.9秒后收到邮箱消息时，则会重新等待延时。

命令链表：
我们将所有的命令用一个复杂的联合体来保存，当然你也可以分开写成多个结构体。所有命令块的分配与释放通过存储块来管理。

具体监控任务通过命令链表来配置。该链表中的插入和删除操作完全由监控任务自己来负责，而不是允许命令解释器任务直接操作，这样就避免了两个任务同时读写监控列表问题的情况出现，这样就不必添加任务资源保护处理。此外，通过邮箱来发送请求，命令解释器任务可以在发送请求后立即做自己的工作。监控任务可以在有空闲时再对该命令进行处理。整体效率更高。

1.2 代码实现

cli.c：

/*** @brief 命令解释器设计* @details* @author 01课堂 李述铜 http://01ketang.cc* @date 2017-06-01* @version 1.0* @copyright 版权所有，禁止用于商业用途*/
#include <string.h>
#include <stdlib.h>
#include "tinyOS.h"
#include "cli.h"
#include "uart.h"
#include "extio.h"
#include "WaveGen.h"
#include "monitor.h"#define TERMINAL_BS     0x08
#define TERMINAL_SPACE  ' '
#define TERMINAL_CR     '\r'
#define TERMINAL_LF     '\n'
#define TERMINAL_TAB    '\t'// 空白字符
static const char spaceCh[] = {TERMINAL_SPACE, TERMINAL_CR, TERMINAL_LF, TERMINAL_TAB, '\0'};
static const char * unknownPinMsg = "Unknown Pin\r\n";
static const char * unknownCmdMsg = "Unknown Command!\r\n";
static const char * noEnoughParamMsg = "No Enough Param!\r\n";// 任务相关
static tTaskStack cliTaskEnv[CLI_TASK_ENV_SIZE];     // 任务1的堆栈空间
static tTask cliTask;// 命令行提示缓冲区
static char promoteBuffer[CLI_CMD_PROMATE_SIZE];/*** 显示消息*/
static void showMsg (const char * msg) {UartWrite(msg, strlen(msg));
}/*** 输出显示字符* @param ch*/
static void showCh (const char ch) {UartWrite(&ch, 1);
}/*** 显示提示符*/
static void showPromote (void) {UartWrite(promoteBuffer, strlen(promoteBuffer));
}/*** 更改提示符*/
static void setPromote (const char * newPromote) {strncpy(promoteBuffer, newPromote, sizeof(promoteBuffer));promoteBuffer[sizeof(promoteBuffer) - 1] = '\0';
}/*** 提示符修改命令*/
static void promoteCmd (void) {char * promote = strtok(NULL, spaceCh);if (promote == NULL) {showMsg(noEnoughParamMsg);return;}setPromote(promote);
}/*** 将引脚名转换为内部序号* @param pinCh* @return*/
static ExtIOPin convertPinNum (char * pinCh) {ExtIOPin pinNum;if (pinCh == NULL) {return ExtIOPinEnd;}pinNum = (ExtIOPin)(*pinCh - '0');if (pinNum >= ExtIOPinEnd) {return ExtIOPinEnd;}return pinNum;
}/*** 外部IO命令解析*/
static void extioCmd () {char * type = strtok(NULL, spaceCh);if (type == NULL) {showMsg(noEnoughParamMsg);return;}if (strstr(type, "get")) {      // 命令extio get pinExtIOPin pin;ExtIOState state;pin = convertPinNum(strtok(NULL, spaceCh));if (pin == ExtIOPinEnd) {showMsg(unknownPinMsg);return;}state = ExtIOGetState(pin);showMsg((state == ExtIOHigh) ? "1\r\n" : "0\r\n");} else if (strstr(type, "set")) {   // 命令extio set pin valueExtIOPin pin;char * value;pin = convertPinNum(strtok(NULL, spaceCh));if (pin == ExtIOPinEnd) {showMsg(unknownPinMsg);return;}value = strtok(NULL, spaceCh);if (value == NULL) {showMsg(noEnoughParamMsg);return;}ExtIOSetState(pin, *value == '0' ? ExtIOLow : ExtIOHigh);} else if (strstr(type, "dir")) {   // 命令extio dir pin in/outExtIOPin pin;char *outType;pin = convertPinNum(strtok(NULL, spaceCh));if (pin == ExtIOPinEnd) {showMsg(unknownPinMsg);return;}outType = strtok(NULL, spaceCh);if (outType == NULL) {showMsg(noEnoughParamMsg);return;}ExtIOSetDir(pin, strstr(outType, "in") ? 1 : 0);} else {showMsg(noEnoughParamMsg);}
}/*** 波形输出命令解析*/
static void waveCmd () {char *type = strtok(NULL, spaceCh);if (type == NULL) {showMsg(noEnoughParamMsg);return;}if (strstr(type, "square")) {      // 命令wave squareWaveSelectType(WaveSquare);} else if (strstr(type, "start")) {WaveStartOutput();} else if (strstr(type, "stop")) {WaveStopOutput();} else {showMsg(noEnoughParamMsg);}
}static void monitorPinCmd (void) {MonitorCmd * cmd;uint8_t pin;uint8_t isOn = 0;char * pinCh = strtok(NULL, spaceCh);       // 解析引脚 pinnumif (pinCh == NULL) {showMsg(noEnoughParamMsg);return;} else {char *on_off;pin = atoi(pinCh);on_off = strtok(NULL, spaceCh);         // 解析开关on/offif (on_off == NULL) {showMsg(noEnoughParamMsg);return;} else if (strstr(on_off, "on")) {isOn = 1;}cmd = MonitorAllocCmd();cmd->isAdd = isOn;cmd->target = MonitorExtIOPin;cmd->options.pin.pinNum = pin;MonitorSendCmd(cmd);}
}static void monitorCPUCmd (void) {uint8_t isOn = 0;char * on_off = strtok(NULL, spaceCh);  // monitor cpu on/offif (on_off == NULL) {showMsg(noEnoughParamMsg);return;} else if (strstr(on_off, "on")) {MonitorCmd * cmd = MonitorAllocCmd();char * percent = strtok(NULL, spaceCh); // monitor cpu on percentisOn = 1;if (percent != NULL) {float cpuPercent = (float)atof(percent);cmd->options.cpu.warning = 1;cmd->options.cpu.warnPercent = cpuPercent;} else {cmd->options.cpu.warning = 0;}cmd->isAdd = isOn;cmd->target = MonitorCPUUsage;MonitorSendCmd(cmd);}
}/*** 波形输出命令解析*/
static void monitorCmd (void) {char *type = strtok(NULL, spaceCh);if (type == NULL) {showMsg(noEnoughParamMsg);return;}if (strstr(type, "on")) {               // monitor onMonitorOn();} else if (strstr(type, "off")) {       // monitor offMonitorOff();} else if (strstr(type, "pin")) {       // monitor pin num on/offif (MonitorIsOn()) {monitorPinCmd();} else {showMsg("Turn on Monitor first!\r\n");}} else if (strstr(type, "cpu")) {      // monitor cpu on/offif (MonitorIsOn()) {monitorCPUCmd();} else {showMsg("Turn on Monitor first!\r\n");}}
}/*** 未知命令处理*/
static void unknowCmd (void) {showMsg(unknownCmdMsg);
}/*** 读取一行数据，如果命令超过则截断*/
static void readLine (char * buffer, uint32_t maxLen) {uint32_t index = 0;while (index < maxLen) {char ch;UartRead(&ch, 1);switch (ch) {case TERMINAL_BS:   // 退格键if (index > 0) {buffer[index--] = '\0';showCh(TERMINAL_BS);showCh(TERMINAL_SPACE);showCh(TERMINAL_BS);}break;case TERMINAL_CR:showCh(TERMINAL_LF);default:showCh(ch);buffer[index++] = ch;if ((ch == '\n') || (ch == '\r') || (index >= maxLen)) {buffer[index] = '\0';return;}break;}}
}/*** 解析命令*/
static void processCmd (char * cmdLine) {char * cmdStart;// 获取开头cmdStart = strtok(cmdLine, spaceCh);if (cmdStart == NULL) {return;}// 识别命令if (strstr(cmdStart, "extio")) {extioCmd();} else if (strstr(cmdStart, "wave")) {waveCmd();} else if (strstr(cmdStart, "promote")) {promoteCmd();} else if (strstr(cmdStart, "monitor")) {monitorCmd();} else {unknowCmd();}
}/*** 解释器任务* @param param*/
void cliTaskEntry (void * param) {static char cmdBuffer[CLI_CMD_BUFFER_SIZE];for (;;) {showPromote();readLine(cmdBuffer, sizeof(cmdBuffer));processCmd(cmdBuffer);}
}/*** 命令解释器设计*/
void CLIInit (void) {strcpy(promoteBuffer, ">>");tTaskInit(&cliTask, cliTaskEntry, (void *) 0x0, CLI_TASK_PRIO, cliTaskEnv, sizeof(cliTaskEnv));
}

monitor.h：

/*** @brief 监控任务设计* @details* @author 01课堂 李述铜 http://01ketang.cc* @date 2017-06-01* @version 1.0* @copyright 版权所有，禁止用于商业用途*/#ifndef MONITOR_H
#define MONITOR_H#include "tinyOS.h"#define MONITOR_TASK_PRIO           0
#define MONITOR_TASK_ENV_SIZE       512
#define MONITOR_MAX_CMD             10
#define REPORT_BUFFER_SIZE          128
#define MONITOR_DEFAULT_TIMEOUT     1000// 监控对像
typedef enum {MonitorCPUUsage,MonitorExtIOPin,
}MonitorTarget;// 监控命令
typedef struct _MonitorCmd {tNode linkNode;uint8_t isAdd;MonitorTarget target;union MonitorOption{struct {uint8_t pinNum;     // 管脚序号}pin;struct {uint8_t warning;float warnPercent;}cpu;}options;
}MonitorCmd;void MonitorInit (void);
void MonitorOn (void);
void MonitorOff (void);
uint8_t MonitorIsOn (void);MonitorCmd * MonitorAllocCmd (void);
void MonitorFreeCmd (MonitorCmd * cmd);
void MonitorSendCmd (MonitorCmd * cmd);
void MonitorSetPeriod (uint32_t ms);#endif //PROJECT_MONITOR_H

monitor.c：

/*** @brief 监控任务设计* @details* @author 01课堂 李述铜 http://01ketang.cc* @date 2017-06-01* @version 1.0* @copyright 版权所有，禁止用于商业用途*/
#include <string.h>
#include <stdio.h>
#include "monitor.h"
#include "uart.h"
#include "extio.h"static uint8_t monitorIsOn;__align(8) static tTaskStack monitorTaskEnv[MONITOR_TASK_ENV_SIZE];
static tTask monitorTask;static tMbox cmdMbox;
static void * msgBuffer[MONITOR_MAX_CMD];static tMemBlock cmdMemBlock;
static MonitorCmd cmdMem[MONITOR_MAX_CMD];static tList monitorCmdList;static uint32_t monitorPeriod;          // 监控周期
static char reportBuffer[REPORT_BUFFER_SIZE];/*** 分配命令块* @return*/
MonitorCmd * MonitorAllocCmd (void) {MonitorCmd * cmd = 0;tMemBlockWait(&cmdMemBlock, (void **)&cmd, 0);memset(cmd, 0, sizeof(MonitorCmd));tNodeInit(&cmd->linkNode);return cmd;
}/*** 释放命令块* @param cmd*/
void MonitorFreeCmd (MonitorCmd * cmd) {tMemBlockNotify(&cmdMemBlock, cmd);
}/*** 添加监控命令* @param cmd*/
void MonitorSendCmd (MonitorCmd * cmd) {tMboxNotify(&cmdMbox, cmd, tMBOXSendNormal);
}/*** 设置监控周期* @param ms*/
void MonitorSetPeriod (uint32_t ms) {monitorPeriod = ms;
}/*** 找到配置相同的命令* @param cmd* @return*/
static MonitorCmd * findCmd (MonitorCmd * cmd) {tNode * currNode;for (currNode = tListFirst(&monitorCmdList); currNode != (tNode *)0; currNode = tListNext(&monitorCmdList, currNode)) {MonitorCmd * currentCmd = (MonitorCmd *)tNodeParent(currNode, MonitorCmd, linkNode);if (currentCmd->target == cmd->target) {switch (currentCmd->target) {case MonitorCPUUsage:return currentCmd;case MonitorExtIOPin:if (currentCmd->options.pin.pinNum == cmd->options.pin.pinNum) {return currentCmd;}break;default:break;}}}return 0;
}/*** 添加命令*/
static void procReceivedCmd (MonitorCmd * cmd) {MonitorCmd * existCmd = findCmd(cmd);if (cmd->isAdd) {if (existCmd) {tListRemove(&monitorCmdList, &existCmd->linkNode);MonitorFreeCmd(existCmd);}tListAddLast(&monitorCmdList, &cmd->linkNode);} else {if (existCmd) {tListRemove(&monitorCmdList, &existCmd->linkNode);MonitorFreeCmd(existCmd);}MonitorFreeCmd(cmd);}
}static void showReportMsg (const char * msg) {UartWrite(msg, strlen(msg));
}static void reportCPUUsage (MonitorCmd * cmd) {float cpuUsage = tCpuUsageGet();sprintf(reportBuffer, "CPU usage:%lf\r\n", cpuUsage);showReportMsg(reportBuffer);if (cmd->options.cpu.warning) {if (cmd->options.cpu.warnPercent <= cpuUsage) {showReportMsg("Warning: CPU usage too high\r\n");}}
}static void reportExtIOPin (MonitorCmd * cmd) {ExtIOState state;ExtIOPin pin = (ExtIOPin)cmd->options.pin.pinNum;if (pin >= ExtIOPinEnd) {return;}state = ExtIOGetState(pin);sprintf(reportBuffer, "ExtIO Pin %d:%d\r\n", pin, (state == ExtIOHigh) ? 1 : 0);showReportMsg(reportBuffer);
}/*** 报告错误* @param cmd*/
static void reportTarget (void) {tNode * currNode;for (currNode = tListFirst(&monitorCmdList); currNode != NULL; currNode = tListNext(&monitorCmdList, currNode)) {MonitorCmd * currentCmd = (MonitorCmd *)tNodeParent(currNode, MonitorCmd, linkNode);switch (currentCmd->target) {case MonitorCPUUsage:reportCPUUsage(currentCmd);break;case MonitorExtIOPin:reportExtIOPin(currentCmd);break;}}
}/*** 监控任务* @param param*/
void monitorTaskEntry (void * param) {for (;;) {uint32_t err;MonitorCmd * cmd;err = tMboxWait(&cmdMbox, (void **)&cmd, monitorPeriod / TINYOS_SYSTICK_MS);if (err == tErrorNoError) {procReceivedCmd(cmd);} else {reportTarget();}}
}/*** 监控初始化*/
void MonitorInit (void) {monitorIsOn = 0;          // 未开启
}void MonitorOn (void) {if (monitorIsOn) {return;}monitorIsOn = 1;monitorPeriod = MONITOR_DEFAULT_TIMEOUT;tListInit(&monitorCmdList);tMboxInit(&cmdMbox, msgBuffer, MONITOR_MAX_CMD);tMemBlockInit(&cmdMemBlock, cmdMem, sizeof(MonitorCmd), MONITOR_MAX_CMD);tTaskInit(&monitorTask, monitorTaskEntry, (void *) 0x0, MONITOR_TASK_PRIO, monitorTaskEnv, sizeof(monitorTaskEnv));
}void MonitorOff (void) {if (monitorIsOn == 0) {return;}tTaskForceDelete(&monitorTask);monitorIsOn = 0;
}uint8_t MonitorIsOn (void) {return monitorIsOn;
}

---

参考资料：

1. 手把手教你学用嵌入式操作系统