设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › Arduino › ProtoThreads多线程实例
返回列表 发新帖
查看: 3840|回复: 0
收起左侧

ProtoThreads多线程实例

[复制链接]
ID:112317 发表于 2016-4-9 20:14 | 显示全部楼层 |阅读模式
发一个我前段时间用ProtoThreads写的一个读取Serial角度并用模拟的方式驱动舵机
关于ProtoThreads的介绍：http://www.51hei.com/bbs/dpj-47836-1.html
代码如下

  1.     #include <PT_timer.h>
  2.     #include <pt.h>
  3.     int servopin=8;//定义舵机接口数字接口7
  4.     int myangle=100;//定义角度变量
  5.     int val=0;
  6.     static struct pt pt1,pt2;
  7.     PT_timer servotimer;
  8.     static int servoMove(struct pt *pt)
  9.     {  
  10.       PT_BEGIN(pt);  
  11.       while(1)
  12.       {
  13.             servotimer.setTimer(25);
  14.             PT_WAIT_UNTIL(pt,servotimer.Expired());
  15.             int pulsewidth;//定义脉宽变量
  16.             myangle%=156;//视舵机而定，防止越界
  17.             pulsewidth=myangle*11+500;//将角度转化为500-2205的脉宽值
  18.             digitalWrite(servopin,HIGH);//将舵机接口电平至高
  19.             delayMicroseconds(pulsewidth);//延时脉宽值的微秒数
  20.             digitalWrite(servopin,LOW);//将舵机接口电平至低
  21.       }
  22.       PT_END(pt);
  23.     }

  25.     String inString = "";
  26.     static int angleRead(struct pt *pt)
  27.     {
  28.       PT_BEGIN(pt);
  29.       while(1) {   
  30.         PT_WAIT_UNTIL(pt, Serial.available()>0);
  31.             int inChar = Serial.read();
  32.         if (isDigit(inChar))
  33.           inString += (char)inChar;
  34.         if (inChar == ' '||inChar=='\n') {
  35.           myangle=inString.toInt();
  36.               Serial.print("myangle=");
  37.               Serial.println(myangle);
  38.           inString = "";
  39.             }
  40.       }
  41.       PT_END(pt);
  42.     }
  43.     void setup()
  44.     {
  45.       pinMode(servopin,OUTPUT);//设定舵机接口为输出接口
  46.       PT_INIT(&pt1);
  47.       PT_INIT(&pt2);
  48.       Serial.begin(9600);
  49.     }
  50.     void loop()//
  51.     {
  52.         servoMove(&pt1);
  53.         angleRead(&pt2);
  54.     }
复制代码

ServoMove呢就是自己模拟出来的舵机函数，为什么不用servo库呢？因为arduino自身的servo库有很多限制，第一PWM不能用了，第二最小角度只有1度，当然这个程序里舵机的精度也是1度，只要把相应的变量改成float就能精确到小数了，不过最大的好处是舵机脚可以任意设定
servomove中限定了最大角度为155度，这个与舵机有关
angleRead中使用了stringtoInt，每次可以输入一个角度，角度可以以 空格 或 回车 结尾（操蛋的VC2010 SerialMonitor发送数据不带 回车的。。那就空格了）
程序中使用了定时器，自己用C++写的，第一次写库，照葫芦画瓢了。。。
感谢czad的扩展库翻译:http://www.51hei.com/bbs/dpj-47837-1.html
这个库用起来非常简单：
PT_Timer t;//定义一个定时器
t.setTimer(unsinged long time) //定时时间，单位ms
t.Expired()//判断定时器是否溢出，是返回值>0
在上面的代码中，一个舵机周期是20ms，前面的约2.5毫秒是信号周期，剩下的10多ms全是无用的低电平，然而又必不可少，所以果断用定时器取代delay
ok

pt.h
  1. /*
  2. * Copyright (c) 2004-2006, Swedish Institute of Computer Science.
  3. * All rights reserved.
  4. *
  5. * Redistribution and use in source and binary forms, with or without
  6. * modification, are permitted provided that the following conditions
  7. * are met:
  8. * 1. Redistributions of source code must retain the above copyright
  9. *    notice, this list of conditions and the following disclaimer.
  10. * 2. Redistributions in binary form must reproduce the above copyright
  11. *    notice, this list of conditions and the following disclaimer in the
  12. *    documentation and/or other materials provided with the distribution.
  13. * 3. Neither the name of the Institute nor the names of its contributors
  14. *    may be used to endorse or promote products derived from this software
  15. *    without specific prior written permission.
  16. *
  17. * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
  18. * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19. * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20. * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
  21. * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22. * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23. * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24. * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25. * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26. * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27. * SUCH DAMAGE.
  28. *
  29. * Author: Adam Dunkels <adam@sics.se>
  30. *
  31. * $Id: pt.h,v 1.6 2006/06/03 11:29:43 adam Exp $
  32. */

  34. /**
  35. * \addtogroup pt
  36. * @{
  37. */

  39. /**
  40. * \file
  41. * Protothreads implementation.
  42. * \author
  43. * Adam Dunkels <adam@sics.se>
  44. *
  45. */

  47. #ifndef __PT_H__
  48. #define __PT_H__

  50. #include "lc.inc"


  53. struct pt {
  54.   lc_t lc;
  55. };

  57. #define PT_WAITING 0
  58. #define PT_EXITED  1
  59. #define PT_ENDED   2
  60. #define PT_YIELDED 3

  62. /**
  63. * \name Initialization
  64. * @{
  65. */

  67. /**
  68. * Initialize a protothread.
  69. *
  70. * Initializes a protothread. Initialization must be done prior to
  71. * starting to execute the protothread.
  72. *
  73. * \param pt A pointer to the protothread control structure.
  74. *
  75. * \sa PT_SPAWN()
  76. *
  77. * \hideinitializer
  78. */
  79. #define PT_INIT(pt)   LC_INIT((pt)->lc)

  81. /** @} */

  83. /**
  84. * \name Declaration and definition
  85. * @{
  86. */

  88. /**
  89. * Declaration of a protothread function.
  90. *
  91. * This macro is used to declare a protothread function. Protothreads
  92. * function should be declared with this macro, but can also be
  93. * declared as regular C functions that return an integer value.
  94. *
  95. * \param name_args The name and arguments of the C function
  96. * implementing the protothread.
  97. *
  98. * \hideinitializer
  99. */
  100. #define PT_THREAD(name_args) char name_args

  102. /**
  103. * Declare the start of a protothread inside the C function
  104. * implementing the protothread.
  105. *
  106. * This macro is used to declare the starting point of a
  107. * protothread. It should be placed at the start of the function in
  108. * which the protothread runs. All C statements above the PT_BEGIN()
  109. * invokation will be executed each time the protothread is scheduled.
  110. *
  111. * \param pt A pointer to the protothread control structure.
  112. *
  113. * \hideinitializer
  114. */
  115. #define PT_BEGIN(pt) { char PT_YIELD_FLAG = 1; LC_RESUME((pt)->lc)

  117. /**
  118. * Declare the end of a protothread.
  119. *
  120. * This macro is used for declaring that a protothread ends. It must
  121. * always be used together with a matching PT_BEGIN() macro.
  122. *
  123. * \param pt A pointer to the protothread control structure.
  124. *
  125. * \hideinitializer
  126. */
  127. #define PT_END(pt) LC_END((pt)->lc); PT_YIELD_FLAG = 0; \
  128.                    PT_INIT(pt); return PT_ENDED; }

  130. /** @} */

  132. /**
  133. * \name Blocked wait
  134. * @{
  135. */

  137. /**
  138. * Block and wait until condition is true.
  139. *
  140. * This macro blocks the protothread until the specified condition is
  141. * true.
  142. *
  143. * \param pt A pointer to the protothread control structure.
  144. * \param condition The condition.
  145. *
  146. * \hideinitializer
  147. */
  148. #define PT_WAIT_UNTIL(pt, condition)                \
  149.   do {                                                \
  150.     LC_SET((pt)->lc);                                \
  151.     if(!(condition)) {                                \
  152.       return PT_WAITING;                        \
  153.     }                                                \
  154.   } while(0)

  156. /**
  157. * Block and wait while condition is true.
  158. *
  159. * This function blocks and waits while condition is true. See
  160. * PT_WAIT_UNTIL().
  161. *
  162. * \param pt A pointer to the protothread control structure.
  163. * \param cond The condition.
  164. *
  165. * \hideinitializer
  166. */
  167. #define PT_WAIT_WHILE(pt, cond)  PT_WAIT_UNTIL((pt), !(cond))

  169. /** @} */

  171. /**
  172. * \name Hierarchical protothreads
  173. * @{
  174. */

  176. /**
  177. * Block and wait until a child protothread completes.
  178. *
  179. * This macro schedules a child protothread. The current protothread
  180. * will block until the child protothread completes.
  181. *
  182. * \note The child protothread must be manually initialized with the
  183. * PT_INIT() function before this function is used.
  184. *
  185. * \param pt A pointer to the protothread control structure.
  186. * \param thread The child protothread with arguments
  187. *
  188. * \sa PT_SPAWN()
  189. *
  190. * \hideinitializer
  191. */
  192. #define PT_WAIT_THREAD(pt, thread) PT_WAIT_WHILE((pt), PT_SCHEDULE(thread))

  194. /**
  195. * Spawn a child protothread and wait until it exits.
  196. *
  197. * This macro spawns a child protothread and waits until it exits. The
  198. * macro can only be used within a protothread.
  199. *
  200. * \param pt A pointer to the protothread control structure.
  201. * \param child A pointer to the child protothread's control structure.
  202. * \param thread The child protothread with arguments
  203. *
  204. * \hideinitializer
  205. */
  206. #define PT_SPAWN(pt, child, thread)                \
  207.   do {                                                \
  208.     PT_INIT((child));                                \
  209.     PT_WAIT_THREAD((pt), (thread));                \
  210.   } while(0)

  212. /** @} */

  214. /**
  215. * \name Exiting and restarting
  216. * @{
  217. */

  219. /**
  220. * Restart the protothread.
  221. *
  222. * This macro will block and cause the running protothread to restart
  223. * its execution at the place of the PT_BEGIN() call.
  224. *
  225. * \param pt A pointer to the protothread control structure.
  226. *
  227. * \hideinitializer
  228. */
  229. #define PT_RESTART(pt)                                \
  230.   do {                                                \
  231.     PT_INIT(pt);                                \
  232.     return PT_WAITING;                        \
  233.   } while(0)

  235. /**
  236. * Exit the protothread.
  237. *
  238. * This macro causes the protothread to exit. If the protothread was
  239. * spawned by another protothread, the parent protothread will become
  240. * unblocked and can continue to run.
  241. *
  242. * \param pt A pointer to the protothread control structure.
  243. *
  244. * \hideinitializer
  245. */
  246. #define PT_EXIT(pt)                                \
  247.   do {                                                \
  248.     PT_INIT(pt);                                \
  249.     return PT_EXITED;                        \
  250.   } while(0)

  252. /** @} */

  254. /**
  255. * \name Calling a protothread
  256. * @{
  257. */

  259. /**
  260. * Schedule a protothread.
  261. *
  262. * This function shedules a protothread. The return value of the
  263. * function is non-zero if the protothread is running or zero if the
  264. * protothread has exited.
  265. *
  266. * \param f The call to the C function implementing the protothread to
  267. * be scheduled
  268. *
  269. * \hideinitializer
  270. */
  271. #define PT_SCHEDULE(f) ((f) == PT_WAITING)

  273. /** @} */

  275. /**
  276. * \name Yielding from a protothread
  277. * @{
  278. */

  280. /**
  281. * Yield from the current protothread.
  282. *
  283. * This function will yield the protothread, thereby allowing other
  284. * processing to take place in the system.
  285. *
  286. * \param pt A pointer to the protothread control structure.
  287. *
  288. * \hideinitializer
  289. */
  290. #define PT_YIELD(pt)                                \
  291.   do {                                                \
  292.     PT_YIELD_FLAG = 0;                                \
  293.     LC_SET((pt)->lc);                                \
  294.     if(PT_YIELD_FLAG == 0) {                        \
  295.       return PT_YIELDED;                        \
  296.     }                                                \
  297.   } while(0)

  299. /**
  300. * \brief      Yield from the protothread until a condition occurs.
  301. * \param pt   A pointer to the protothread control structure.
  302. * \param cond The condition.
  303. *
  304. *             This function will yield the protothread, until the
  305. *             specified condition evaluates to true.
  306. *
  307. *
  308. * \hideinitializer
  309. */
  310. #define PT_YIELD_UNTIL(pt, cond)                \
  311.   do {                                                \
  312.     PT_YIELD_FLAG = 0;                                \
  313.     LC_SET((pt)->lc);                                \
  314.     if((PT_YIELD_FLAG == 0) || !(cond)) {        \
  315.       return PT_YIELDED;                        \
  316.     }                                                \
  317.   } while(0)

  319. /** @} */

  321. #endif /* __PT_H__ */

  323. /** @} */
复制代码

附上
ProtoThreads Timer.rar (13.23 KB, 下载次数: 11)
多线程

相关帖子
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表