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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 24小时必答区 › 请问这个库函数程序是怎么循环执行的？
返回列表 发新帖
查看: 2077|回复: 8
打印 上一主题 下一主题
收起左侧

请问这个库函数程序是怎么循环执行的？

[复制链接]
跳转到指定楼层
楼主
ID:158981 发表于 2018-3-30 09:38 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
在学习使用“大连好人”的EasyStepper的步进电机控制库函数。

在看EasyStepper.cpp文件，看到图片中这个内容非常困惑。明明是if的命令，为什么程序能不断的循环？


请大家指教。附件是完整的EasyStepper库文件。










分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏 分享淘帖 顶顶 踩踩
回复

使用道具 举报

沙发
ID:158981 发表于 2018-3-30 09:39 | 只看该作者
本帖最后由 duanyz 于 2018-3-30 12:47 编辑


回复

使用道具 举报

板凳
ID:155507 发表于 2018-3-30 11:08 | 只看该作者

这段是参照网上编码器读取程序写的读取步进电机控制脉冲的程序

  1. #define countA  2   //脉冲
  2. #define countB  3   //方向
  3.  
  4. long int count = 0;
  5. //long int zuobiao = 0;
  6. void setup() {
  7.  
  8.  
  9.   pinMode(countA, INPUT);
  10.   digitalWrite(countA, HIGH);       // turn on pullup resistor
  11.   pinMode(countB, INPUT);
  12.   digitalWrite(countB, HIGH);       // turn on pullup resistor
  13.  
  14.   attachInterrupt(0, doCount, LOW );  // encoder pin on interrupt 0 - pin 2
  15.   Serial.begin (115200);
  16.   Serial.println("start");                // a personal quirk
  17.  
  18. }
  19.  
  20.  
  21. void loop(){
  22. // do some stuff here - the joy of interrupts is that they take care of themselves
  23. }
  24.  
  25. void doCount() {
  26.   /* If pinA and pinB are both high or both low, it is spinning
  27.    * forward. If they're different, it's going backward.
  28.    *
  29.    * For more information on speeding up this process, see
  30.    * [Reference/PortManipulation], specifically the PIND register.
  31.    */
  32.   if (digitalRead(countA) == digitalRead(countB)) {
  33.     count++;
  34.   } else {
  35.     count--;
  36.   }
  37.  // noInterrupts();
  38.  Serial.println (count, DEC);
  39.  // interrupts();
  40. }
复制代码



EasyStepper.h

  2. #ifndef EasyStepper_h
  3. #define EasyStepper_h

  5. #include <stdlib.h>
  6. #if ARDUINO >= 100
  7. #include <Arduino.h>
  8. #else
  9. #include <WProgram.h>
  10. #include <wiring.h>
  11. #endif

  13. /**
  14. * author [email]shangcm@gmail.com[/email]
  15. */
  16. class EasyStepper
  17. {
  18.         public:
  19.                
  20.                 /**
  21.                 * to create the EasyStepper
  22.                 * parameters:
  23.                 * stepPin the step pin
  24.                 * directionPin the direction pin
  25.                 * enablePin the enable pin
  26.                 * directionPinsInverted if the value is true then invert HIGH/LOW value for direction pin
  27.                 * enablePinsInverted if the value is true then invert HIGH/LOW value for enable pin
  28.                 */
  29.                 EasyStepper(byte stepPin, byte directionPin, byte enablePin, bool directionPinsInverted, bool enablePinsInverted);
  30.                
  31.                 /**
  32.                 * to startup the EasyStepper
  33.                 */
  34.                 void startup();
  35.                
  36.                 /**
  37.                 * to shutdown the EasyStepper, will release the enable pin to save power
  38.                 */
  39.                 void shutdown();
  40.                
  41.                 /**
  42.                 * to rotate steps from current position with speed, the acceleration = 0
  43.                 * speed the speed for rotation, the unit is steps per second
  44.                 * steps the steps to go
  45.                 */
  46.                 void rotate(float speed, int steps);
  47.                
  48.                 /**
  49.                 * to rotate steps from current position with speed
  50.                 * speed the speed for rotation, the unit is steps per second
  51.                 * steps the steps to go
  52.                 * acceleration the acceleration, if it = 0, means no acceleration
  53.                 */
  54.                 void rotate(float speed, int steps, int acceleration);
  55.                
  56.                 /**
  57.                 * to stop the stepper, the motor will stay at current position
  58.                 */
  59.                 void stop();
  60.    
  61.     /**
  62.     * run, you must call this as frequently as possible, but at least once per minimum step interval,
  63.     * preferably in your main loop.
  64.     */
  65.     void run();
  66.    
  67.     /**
  68.     * if return true means the action is done
  69.     */
  70.     boolean isDone();
  71.    
  72.     /**
  73.     * enable the debug mode?
  74.     */
  75.     void debugMode(boolean enabled);
  76.                
  77.         protected:
  78.                
  79.                 //
  80.                
  81.         private:
  82.                
  83.                 boolean debugModeFlag;
  84.                
  85.                 byte stepPin;
  86.                 byte directionPin;
  87.                 byte enablePin;
  88.                
  89.                 bool directionPinsInverted;
  90.                 bool enablePinsInverted;
  91.                
  92.                 int acceleration;
  93.                 int stage1; // the end step of the stage1
  94.                 int stage2; // the end step of the stage2
  95.                
  96.                 int stepsToGo;
  97.                 int stepsGone;
  98.                
  99.                 float stepTime;
  100.                 float startTime;
  101.                 float stage1StepTime;
  102.                 float stage3StepTime;
  103.                 unsigned long nextTimestamp;
  104.                
  105.                 boolean done;
  106.                
  107.                 void step();
  108.                
  109. };

  111. #endif

复制代码


再来看 EasyStepper.cpp （代码里面有注释）

  2. #include "EasyStepper.h"

  4. EasyStepper::EasyStepper(byte stepPin, byte directionPin, byte enablePin, bool directionPinsInverted, bool enablePinsInverted)
  5. {
  6.         // save the parameters
  7.         this->stepPin = stepPin;
  8.         this->directionPin = directionPin;
  9.         this->enablePin = enablePin;
  10.         this->directionPinsInverted = directionPinsInverted;
  11.         this->enablePinsInverted = enablePinsInverted;
  12. }

  14. void EasyStepper::startup()
  15. {
  16.         // set the pin mode
  17.         pinMode(this->stepPin, OUTPUT);
  18.         pinMode(this->directionPin, OUTPUT);
  19.         pinMode(this->enablePin, OUTPUT);
  20.         // enable the stepper
  21.         digitalWrite(enablePin, HIGH ^ this->enablePinsInverted);
  22.         // initialize the done to true
  23.         this->done = true;
  24. }

  26. void EasyStepper::shutdown()
  27. {
  28.         // disable the stepper
  29.         digitalWrite(enablePin, LOW ^ this->enablePinsInverted);
  30. }

  32. void EasyStepper::debugMode(boolean enabled)
  33. {
  34.         this->debugModeFlag = enabled;
  35. }

  37. void EasyStepper::rotate(float speed, int steps)
  38. {
  39.         this->rotate(speed, steps, 0);
  40. }

  42. void EasyStepper::rotate(float speed, int steps, int acceleration)
  43. {
  44.         // ignore the zero value
  45.         if (speed != 0 && steps != 0)
  46.         {
  47.                 if (steps > 0)
  48.                 {
  49.                         // CW
  50.                         digitalWrite(directionPin, HIGH ^ this->directionPinsInverted);
  51.                 }
  52.                 else if (steps < 0)
  53.                 {
  54.                         // CCW
  55.                         digitalWrite(directionPin, LOW ^ this->directionPinsInverted);
  56.                 }
  57.                 // done flag
  58.                 this->done = false;
  59.                 // the steps to go
  60.                 this->stepsToGo = abs(steps);
  61.                 // the acceleration
  62.                 this->acceleration = abs(acceleration);
  63.                 if (this->stepsToGo <= 4)
  64.                 {
  65.                         this->acceleration = 0;
  66.                 }
  67.                 // change the speed to stepTime, micro seconds per step
  68.                 this->stepTime = 1000.0 * 1000.0 / abs(speed);
  69.                 // start time
  70.                 this->startTime = this->stepTime * (this->acceleration + 1);
  71.                 // stage1
  72.                 this->stage1 = this->stepsToGo / 4;
  73.                 this->stage1StepTime = (float) this->acceleration * this->stepTime / this->stage1;
  74.                 // stage2
  75.                 this->stage2 = this->stepsToGo / 4 * 3;
  76.                 this->stage3StepTime = (float) this->acceleration * this->stepTime / (this->stepsToGo - this->stage2);
  77.                 // the steps gone
  78.                 this->stepsGone = 0;
  79.                 // current timestamp
  80.                 unsigned long time = micros();
  81.                 if (this->debugModeFlag)
  82.                 {
  83.                         Serial.print("rotate: direction=");
  84.                         Serial.print(steps > 0 ? "CW" : "CCW");
  85.                         Serial.print(", stepsToGo=");
  86.                         Serial.print(this->stepsToGo);
  87.                         Serial.print(", acceleration=");
  88.                         Serial.print(this->acceleration);
  89.                         Serial.print(", startTime=");
  90.                         Serial.print(this->startTime);
  91.                         Serial.print(", stage1=");
  92.                         Serial.print(this->stage1);
  93.                         Serial.print(", stage1StepTime=");
  94.                         Serial.print(this->stage1StepTime);
  95.                         Serial.print(", stage2=");
  96.                         Serial.print(this->stage2);
  97.                         Serial.print(", stage3StepTime=");
  98.                         Serial.print(this->stage3StepTime);
  99.                         Serial.print(", stepTime=");
  100.                         Serial.print(this->stepTime);
  101.                         Serial.print(", currentTimestamp=");
  102.                         Serial.println(time);
  103.                 }
  104.                 // call the step method to rotate the motor
  105.                 this->step();
  106.         }
  107. }

  109. void EasyStepper::stop()
  110. {
  111.         this->stepsToGo = 0;
  112.         this->done = true;
  113. }

  115. void EasyStepper::run()
  116. {
  117.         // the current timestamp
  118.         unsigned long time = micros();
  119.         if (!this->done && time >= this->nextTimestamp)
  120.         {
  121.                 this->step();
  122.         }
  123.         if (this->debugModeFlag)
  124.         {
  125.                 Serial.print("currentTimeStamp=");
  126.                 Serial.println(time);
  127.         }
  128. }

  130. void EasyStepper::step()
  131. {
  132.         // are there some steps to rotate?
  133.         if (this->stepsToGo > this->stepsGone)
  134.         {
  135.                 // HIGH value
  136.                 digitalWrite(stepPin, HIGH);
  137.                 // delay
  138.                 delayMicroseconds(2);
  139.                 // LOW value
  140.                 digitalWrite(stepPin, LOW);
  141.                 // increase the stepsGone
  142.                 this->stepsGone++;
  143.                 // default: stage2
  144.                 float nextStepTime = this->stepTime;
  145.                 if (this->acceleration != 0)
  146.                 {
  147.                         if (this->stepsGone < this->stage1)
  148.                         {
  149.                                 // stage1: down to stepTime from startTime
  150.                                 nextStepTime = this->startTime - this->stage1StepTime * this->stepsGone;
  151.                         }
  152.                         else if (this->stepsGone >= this->stage2)
  153.                         {
  154.                                 // stage3: up to startTime from stepTime
  155.                                 nextStepTime = this->stepTime + this->stage3StepTime * (this->stepsGone - this->stage2 + 1);
  156.                         }
  157.                 }
  158.                 // current timestamp
  159.                 unsigned long time = micros();
  160.                 this->nextTimestamp = time + nextStepTime;
  161.                 if (this->debugModeFlag)
  162.                 {
  163.                         Serial.print("step: stepsGone=");
  164.                         Serial.print(this->stepsGone);
  165.                         Serial.print(", currentTimestamp=");
  166.                         Serial.print(time);
  167.                         Serial.print(", nextTimestamp=");
  168.                         Serial.print(this->nextTimestamp);
  169.                         Serial.print(", nextStepTime=");
  170.                         Serial.println(nextStepTime);
  171.                 }
  172.         }
  173.         else
  174.         {
  175.                 this->done = true;
  176.         }
  177. }
  178.    
  179. boolean EasyStepper::isDone()
  180. {
  181.         return this->done;
  182. }
复制代码
回复

使用道具 举报

地板
ID:158981 发表于 2018-3-30 12:44 | 只看该作者

回复

使用道具 举报

5#
ID:158981 发表于 2018-3-30 19:30 | 只看该作者
angmall 发表于 2018-3-30 11:08
这段是参照网上编码器读取程序写的读取步进电机控制脉冲的程序

请总工来指点一下，不胜感激！
回复

使用道具 举报

6#
ID:299646 发表于 2018-3-30 20:48 | 只看该作者
要有break试试
回复

使用道具 举报

7#
ID:299646 发表于 2018-3-30 20:51 | 只看该作者
可以了吗
回复

使用道具 举报

8#
ID:158981 发表于 2018-3-31 09:26 | 只看该作者
liunian00 发表于 2018-3-30 20:51
可以了吗

什么可以了？我就是想知道为什么if语句里面的内容能循环执行的？能指点下吗？
回复

使用道具 举报

9#
ID:158981 发表于 2018-3-31 19:34 | 只看该作者
感谢上面各位，今天重复看了这个程序，才发现循环调用是要在写程序里实现的，跟库文件的内容没啥关系。

初学者多笑话
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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