标题: 玩儿大了~给arduino上操作系统了~！ [打印本页]
作者: 51黑dd    时间: 2016-4-9 20:08
标题: 玩儿大了~给arduino上操作系统了~！
恩。。好久没发帖了，不过这几天也没闲着
前几天我在求助区发了个关于定时器的问题，结果没有让我满意的答案
于是自己百度+谷歌，终于找到了一个非常强大的库--ProtoThreads！
一个非常强大的多任务库，非常适合arduino这种资源非常有限的单片机
别急，先上一段简单的代码look look
  1.     #include <pt.h>
  2.      
  3.     static int counter1,counter2,state1=0,state2=0;
  4.      
  5.     static int protothread1(struct pt *pt)
  6.     {  
  7.       PT_BEGIN(pt);  
  8.       while(1)
  9.       {  
  10.         PT_WAIT_UNTIL(pt, counter1==1);
  11.         digitalWrite(12,state1);
  12.         state1=!state1;
  13.         counter1=0;   
  14.       }
  15.       PT_END(pt);
  16.     }
  17.      
  18.      
  19.     static int protothread2(struct pt *pt)
  20.     {
  21.       PT_BEGIN(pt);
  22.       while(1) {   
  23.         PT_WAIT_UNTIL(pt, counter2==5);
  24.         counter2=0;
  25.         digitalWrite(13,state2);
  26.         state2=!state2;
  27.       }
  28.       PT_END(pt);
  29.     }
  30.      
  31.      
  32.     static struct pt pt1, pt2;
  33.     void setup()
  34.     {
  35.      
  36.       pinMode(12,OUTPUT);
  37.       pinMode(13,OUTPUT);
  38.       PT_INIT(&pt1);
  39.       PT_INIT(&pt2);
  40.     }
  41.      
  42.     void loop ()
  43.     {
  44.         protothread1(&pt1);
  45.         protothread2(&pt2);
  46.         delay(1000);
  47.         counter1++;
  48.         counter2++;
  49.       }
复制代码

此段代码演示了如何使用PT库来实现12、13脚led分别隔1秒、5秒闪烁，已经在arduino09上测试通过
sorry，无注释。。别急，这只是个演示
这篇文章会不断更新，分别讲述PT库的原理和应用
让大家能开发出更复杂的程序

好介绍开始了~
Protothread是专为资源有限的系统设计的一种耗费资源特别少并且不使用堆栈的线程模型，其特点是：  
◆ 以纯C语言实现，无硬件依赖性；  
◆ 极少的资源需求，每个Protothread仅需要2个额外的字节；  
◆ 可以用于有操作系统或无操作系统的场合；  
◆ 支持阻塞操作且没有栈的切换。
使用Protothread实现多任务的最主要的好处在于它的轻量级。每个Protothread不需要拥有自已的堆栈，所有的Protothread 共享同一个堆栈空间，这一点对于RAM资源有限的系统尤为有利。相对于操作系统下的多任务而言，每个任务都有自已的堆栈空间，这将消耗大量的RAM资源，而每个Protothread仅使用一个整型值保存当前状态。  
咱们来结合一个最简单的例子来理解ProtoThreads的原理吧，就拿上面的闪烁灯代码来说
  1.     #include <pt.h>//ProtoThreads必须包含的头文件

  3.     static int counter1,counter2,state1=0,state2=0; //counter为定时计数器，state为每个灯的状态

  5.     static int protothread1(struct pt *pt) //线程1，控制灯1
  6.     {  
  7.       PT_BEGIN(pt);  //线程开始
  8.       while(1) //每个线程都不会死
  9.       {  
  10.         PT_WAIT_UNTIL(pt, counter1==1); //如果时间满了1秒，则继续执行，否则记录运行点，退出线程1
  11.         digitalWrite(12,state1);
  12.         state1=!state1;//灯状态反转
  13.         counter1=0; //计数器置零
  14.       }
  15.       PT_END(pt); //线程结束
  16.     }


  19.     static int protothread2(struct pt *pt) //线程2，控制灯2
  20.     {
  21.       PT_BEGIN(pt); //线程开始
  22.       while(1) {    //每个线程都不会死
  23.         PT_WAIT_UNTIL(pt, counter2==5); //如果时间满了5秒，则继续执行，否则记录运行点，退出线程2
  24.         counter2=0;  //计数清零
  25.         digitalWrite(13,state2);
  26.         state2=!state2; //灯状态反转
  27.       }
  28.       PT_END(pt);  //线程结束
  29.     }


  32.     static struct pt pt1, pt2;
  33.     void setup()
  34.     {

  36.       pinMode(12,OUTPUT);
  37.       pinMode(13,OUTPUT);
  38.       PT_INIT(&pt1);  //线程1初始化
  39.       PT_INIT(&pt2);  //线程2初始化
  40.     }

  42.     void loop () //这就是进行线程调度的地方
  43.     {
  44.         protothread1(&pt1);  //执行线程1
  45.         protothread2(&pt2);  //执行线程2
  46.         delay(1000);  //时间片，每片1秒，可根据具体应用设置大小
  47.         counter1++;
  48.         counter2++;
  49.       }
复制代码

看上面的代码，你会发现很多大写的函数，其实那些都是些宏定义（宏定义用大写是约定俗成的..)，如果把这些宏都展开你就能更好的理解他的原理了：
  1.     #include <pt.h>//ProtoThreads必须包含的头文件

  3.     static int counter1,counter2,state1=0,state2=0; //counter为定时计数器，state为每个灯的状态

  5.     static int protothread1(struct pt *pt) //线程1，控制灯1
  6.     {  
  7.       { char PT_YIELD_FLAG = 1;
  8.                     switch((pt)->lc) {//用switch来选择运行点
  9.                      case 0: //此乃初始运行点，线程正常退出或刚开始都从这开始运行
  10.                                     while(1) //每个线程都不会死
  11.                                     {
  12.                                             do {      
  13.                                                             (pt)->lc=12;//记录运行点
  14.                                                             case 12:
  15.                                                                     if(!(counter1==1))
  16.                                                                     {
  17.                                                                             return PT_WAITING;        //return 0
  18.                                                                     }                                               
  19.                                             } while(0)
  20.                                             digitalWrite(12,state1);
  21.                                             state1=!state1;//灯状态反转
  22.                                             counter1=0; //计数器置零
  23.                                     }
  24.                     }
  25.       PT_YIELD_FLAG = 0;
  26.       pt->lc=0;
  27.       return PT_ENDED; // return 1
  28.       }
  29.     }


  32.     static int protothread2(struct pt *pt) //线程2，控制灯2
  33.     {
  34.       { char PT_YIELD_FLAG = 1;
  35.                     switch((pt)->lc) {//用switch来选择运行点
  36.                      case 0:     //线程开始
  37.                                     while(1) //每个线程都不会死
  38.                                     {
  39.                                             do {      
  40.                                                             (pt)->lc=39;
  41.                                                             case 39://记录运行点
  42.                                                                     if(!(counter2==5))
  43.                                                                     {
  44.                                                                             return PT_WAITING;        //return 0
  45.                                                                     }                                               
  46.                                             } while(0)
  47.                                             counter2=0;  //计数清零
  48.                                             digitalWrite(13,state2);
  49.                                             state2=!state2; //灯状态反转
  50.                                     }
  51.                     }
  52.                     PT_YIELD_FLAG = 0;
  53.                     pt->lc=0;
  54.                     return PT_ENDED; // return 1
  55.             }
  56.     }


  59.     static struct pt pt1, pt2;
  60.     void setup()
  61.     {

  63.       pinMode(12,OUTPUT);
  64.       pinMode(13,OUTPUT);
  65.       pt1->lc=0;  //线程1初始化
  66.       pt2->lc=0;  //线程2初始化
  67.     }

  69.     void loop () //这就是进行线程调度的地方
  70.     {
  71.         protothread1(&pt1);  //执行线程1
  72.         protothread2(&pt2);  //执行线程2
  73.         delay(1000);  //时间片，每片1秒，可根据具体应用设置大小
  74.         counter1++;
  75.         counter2++;
  76.       }
复制代码

好了，终于扩展完了。。
  分析一下上面的代码，就知道其实ProtoThreads是利用switch case 来选择运行点的，每个线程中的堵塞，其实就是判断条件是否成立，不成立则return，所以说每个线程都很有雷锋精神，舍己为人，呵呵。有一点要注意那就是每个线程只能够在我们指定的地方堵塞，至于堵塞点，那就要看具体应用了。
  由于线程是反复被调用的，因此，写程序的时候不能像写一般的函数一样使用局部变量，因为每次重新调用都会把变量初始化了，如果要保持变量，可以把它定义为static的
  在pt.h中定义了很多功能：
PT_INIT(pt)   初始化任务变量，只在初始化函数中执行一次就行
PT_BEGIN(pt)   启动任务处理，放在函数开始处
PT_END(pt)   结束任务，放在函数的最后
PT_WAIT_UNTIL(pt, condition) 等待某个条件（条件可以为时钟或其它变量，IO等）成立，否则直接退出本函数，下一次进入本     函数就直接跳到这个地方判断
PT_WAIT_WHILE(pt, condition)  和上面一个一样，只是条件取反了
PT_WAIT_THREAD(pt, thread) 等待一个子任务执行完成
PT_SPAWN(pt, child, thread) 新建一个子任务，并等待其执行完退出
PT_RESTART(pt)   重新启动某个任务执行
PT_EXIT(pt)   任务后面的部分不执行，直接退出重新执行
PT_YIELD(pt)   锁死任务
PT_YIELD_UNTIL(pt, cond) 锁死任务并在等待条件成立，恢复执行
在pt中一共定义四种线程状态，在任务函数退出到上一级函数时返回其状态
PT_WAITING  等待
PT_EXITED  退出
PT_ENDED  结束
PT_YIELDED  锁死

比如PT_WAIT_UNTIL(pt, condition) ，通过改变condition可以运用的非常灵活，如结合定时器的库，把condition改为定时器溢出，那就是个时间触发系统了，再把condition改为其他条件，就是事件触发系统了
暂时写这么多吧
***2014.3.16  这里有一另一篇关于protothread的文章，写的挺好，感谢网友vincent_jie 的推荐：
http://www.kankanews.com/ICkengine/archives/107079.shtml



Devuino代表在 Arduino基础上的开发平台，Muti代表多线程


ProtoThread相比其他RTOS有什么突出的优点呢？貌似它已经停止更新了。

优点挺多的
1、超轻量级，他的库基本上都是些宏定义，大小可以忽略不计，而且每个线程只占用2个字节
2、无机器码，纯c实现，所以可移植性很好
3、无堆栈
4、简单使用可以只把他当个调度程序，复杂点也能把他当操作系统来使
恩。。其实我也才接触。。了解不全
现在边研究边更新吧，主要是这几天太忙了。。
PT作者的首页http://www.sics.se/~adam/pt/

问：新手，求教一下，看了下示例，不知这定时准确度如何？执行中断后，这定时器时间是否会延长？
答：上面的示例只是用了一个delay()来设定时间片，用来演示一个简单的程序罢了
写程序最好不要用delay，一delay程序就不能干别的事了，最好的办法是一遇到要delay就去干别的事，时间到了再接着运行刚才的代码，所以PT结合定时器可以很大的提高程序的实时性
上面的定时器库采用的是内部定时器，至于是TCN几我也没仔细看，不过他们与PT结合的不是很好，下次我再发一个定时器库吧
中断肯定会有影响的，只是影响的大小罢了，所以在中断里一般都不会放大的程序，我用中断一般都是用来计数、改变状态，这点时间可以忽略
附录：
官方原版库1.4
pt-1.4.zip (256.5 KB, 下载次数: 50)
arduino版1.4.01
ProtoThreads.rar (12.31 KB, 下载次数: 56)
新发现了几个定时器库，还没来得及试用，都是arduino Library上下载的，大家可以先拿过去试试

SimpleTimer.rar (4.27 KB, 下载次数: 18)
TimedAction-1_6.zip (3.92 KB, 下载次数: 20)
TimerOne-v9.zip (5.71 KB, 下载次数: 18)


作者: panpan221    时间: 2017-2-21 09:55
谢谢分享！学些
作者: duanyz    时间: 2017-3-7 22:03
非常感谢楼主分享
作者: 浩克qwe    时间: 2017-3-12 20:40
谢谢分享，怎么用呢？
作者: BIT_小彦    时间: 2017-3-22 00:26
学习了
作者: liuyunyou    时间: 2017-4-8 08:49
感谢分享，最近在学习arduino，的确资源紧缺啊
作者: shalamonka    时间: 2017-8-5 15:31
不造这个一样吗

ProtoThreads.rar

56.95 KB, 下载次数: 7, 下载积分: 黑币 -5

作者: ashdood    时间: 2017-10-21 19:38
貌似arduino能用的多线程也就这个了，只是这个多线程任务管理功能还有待加强，做的更精细点，极可能的减少线程假死或者冲突，没办法，谁让单片机的内存太小呢
作者: michoal    时间: 2017-10-26 10:29
谢谢分享！黑币不足啊
作者: openpppp2017    时间: 2017-10-31 21:28
谢谢分享！黑币不足
作者: lujunda2    时间: 2017-11-22 14:27
16位单片机还能玩这么强，膜拜，大神
作者: linziol    时间: 2017-12-6 22:01
谢谢分享！
作者: lkhlkh    时间: 2018-1-21 10:47
想知道这个库是否为通用库，比如可以在不同的环境好不同核心使用。
作者: lkhlkh    时间: 2018-1-21 10:50
我现在玩arduino用的是stm32的核，外设和avr完全不同，目前使用的系统是freertos，这个系统好处是标准系统，功能完善，但是缺点显而易见，占空间比较大，所以不懂楼主这个系统能否通用，占用空间如何？
作者: renzeajkd    时间: 2018-6-9 18:47
谢谢分享！好东西



欢迎光临 (http://www.51hei.com/bbs/) Powered by Discuz! X3.1