mbed-rtos操作系统概述

线程控制的主要目的是允许用户建立多个线程并发执行，从而简化各类应用的开发，这样的需求是很常见的，如我们需要程序一方面处理串口数据，另一方便处理LED计数的变化，我们先看一个不用线程的实现：

DigitalOut led1(LED1);

DigitalOut led2(LED2);

DigitalOut led3(LED3);

DigitalOut led4(LED4);

Serial pc(USBTX,USBRX);

uint8_t ledvalue=0;

Ticker tick;

void setLed(uint8_t  val)

{

    led1=val % 2;

    led2=(val /2 ) % 2;

    led3=(val /4 ) % 2;

    led4=(val /5 ) % 2;

}

void printstr()

{

    pc.printf("Hello World,Now value is %d . \n",ledvalue);

    wait(1);

}

int main()

{

    tick.attach(&printstr,2);

    while (1)

    {

                        setLed(++ledvalue);

                        wait(0.1);

    }

}

但上载此程序后发现，因为在串口输出中需要1秒的等待，所以在这1秒内LED停止了计数过程，另外，如果你把tick的间隔时间设成小于1秒的后，LED计算根本就没有机会执行，显然，这样的处理很难满足实际的需求，下面我们给一个使用线程控制的实现（注释部分为传入函数参数的方式）：

#include "rtos.h"

DigitalOut led1(LED1);

DigitalOut led2(LED2);

DigitalOut led3(LED3);

DigitalOut led4(LED4);

Serial pc(USBTX,USBRX);

uint8_t ledvalue=0;

Ticker tick;

void setLed(uint8_t  val)

{

    led1=val % 2;

    led2=(val /2 ) % 2;

    led3=(val /4 ) % 2;

    led4=(val /5 ) % 2;

}

void printstr(void const *args)

{

    while (true) {

                        pc.printf("Hello World,Now value is %d.\n",ledvalue);

                        // pc.printf("Hello World,Now value is %d.\n",*(uint8_t *)args);

                        Thread::wait(1000);

    }

}

int main()

{

    Thread thread(printstr);

  Thread thread(printstr,&ledvalue);

    while (1)

    {

                        setLed(++ledvalue);

                        Thread::wait(100);

    }

}

此时你就会发现串口输出和LED计算不再相互影响，就像两个程序独立执行一样，下面是串口输出的片断：

Hello World,Now value is 174.

Hello World,Now value is 184.

Hello World,Now value is 195.

Hello World,Now value is 205.

Hello World,Now value is 215.

从此输出可以看出，两者交替执行的时间间隔总体差不多但还是有一定区别的，但不管怎样，我们已经看出操作系统的价值，它可以简化我们复杂应用的开发。mbed-rtos在使用时必须导入rtos库和相应mcu架构的底层实现，xbed LPC1768使用的是cortex-m3的价格，所以我们需要导入mbed-rtos库和TARGET_M3两个库。mbed-rtos提供了Thread对象来完成线程控制，它提供的主要方法有：

为了更好地理解以上方法的用法,我们先来看下面的例子:

#include "rtos.h"

Serial pc(USBTX,USBRX);

long count[2];

void printstr1(void const *args)

{

    while (true) {

                        pc.printf("Hello World,My Thread Name is %s,Thread ID is %d.\n",args,Thread::gettid());

                        count[0]++;

                        Thread::yield();

    }

}

void printstr2(void const *args)

{

    while (true) {

                        pc.printf("Hello World,My Thread Name is %s,Thread ID is %d.\n",args,Thread::gettid());

                        count[1]++;

                        Thread::yield();

    }

}

int main()

{

    Thread thread1(printstr1,(void *)"1",osPriorityNormal);

    Thread thread2(printstr2,(void *)"2",osPriorityNormal);

    while (1)

    {

                        pc.printf("Thread1 count is %ld,Thread2 count is %ld. \n",count[0],count[1]);

                        Thread::wait(1000);

    }

}

以上代码创建了两个优先级一样的子线程和一个在main中运行的主线程，运行后你会发现两个子线程运行占用的时间片是一样的，也即是打印的次数一样多，这也符合调度的机制，让大家获得平等的运行机会，但我们会发现串口的输出全乱了，这是因为mbed的串口输出使用了缓冲区机制，由于没有线程同步，导致不同线程的缓冲区相互覆盖从而造成错误输出，这可以使用后续章节的mutex即互斥锁机制完成。

为了刚好地理解优先级，我们可以把一个子线程的优先级设成osPriorityHigh，重新上载后你就会发现只有该线程获得了运行机会，这是因为该线程在使用yield释放出运行权后，系统调度程序找到的最高优先级就绪线程还是它，当然，这是一种很极端的情况，如果我们使用Thread::wait方法就不会一样了，因为它等待的时间内并不需要运行权，所以别的低优先级的线程就有了运行的机会，但一定要注意的是，任何一个子线程必须有释放运行权的机制，否则别的线程就不再有运行的机会，下面是测试代码：

#include "rtos.h"

Serial pc(USBTX,USBRX);

uint8_t theadindex[2];

long count[2];

void printstr(void const *args)

{

    while (true) {

                        count[*(uint8_t *)args-1]++;

                        Thread::wait(500);

    }

}

int main()

{

    theadindex[0]=1;

    theadindex[1]=2;

    Thread thread1(printstr,(void *)theadindex,osPriorityNormal);

    Thread thread2(printstr,(void *)(theadindex+1),osPriorityHigh);

    while (1)

    {

                        pc.printf("Thread1 count is %ld,Thread2 count is %ld. \n",count[0],count[1]);

                        Thread::wait(1000);

    }

}

另外，mbed-rtos为了方便用户定时执行特定函数，它还另外提供了RtosTimer类，它提供的主要方法如下：

         下面是一个简单的应用示例，从效果上来说是和Ticker及Timeout的运行结果一致的：

#include "rtos.h"

Timer mytimer;

DigitalOut led1(LED1);

DigitalOut led2(LED2);

void blinkled1(void const *v)

{

    led1=!led1;

}

void blinkled2(void const *v)

{

    led2=!led2;

}

Serial pc(USBTX,USBRX);

int main (void) {

    RtosTimer led1_timer(blinkled1,osTimerPeriodic);

    RtosTimer led2_timer(blinkled2,osTimerOnce);

    led1_timer.start(1000);

    led2_timer.start(1000);

    mytimer.start();

    while (true) {

                                            Thread::wait(1000);

                                            pc.printf("Time passed %fs.\n",mytimer.read());

    }

}