標(biāo)題: 請問這個庫函數(shù)程序是怎么循環(huán)執(zhí)行的？ [打印本頁]
作者: duanyz    時間: 2018-3-30 09:38
標(biāo)題: 請問這個庫函數(shù)程序是怎么循環(huán)執(zhí)行的？
在學(xué)習(xí)使用“大連好人”的EasyStepper的步進電機控制庫函數(shù)。

在看EasyStepper.cpp文件，看到圖片中這個內(nèi)容非常困惑。明明是if的命令，為什么程序能不斷的循環(huán)？


請大家指教。附件是完整的EasyStepper庫文件。






[attach]106354[/attach]



作者: duanyz    時間: 2018-3-30 09:39
本帖最后由 duanyz 于 2018-3-30 12:47 編輯


作者: angmall    時間: 2018-3-30 11:08

這段是參照網(wǎng)上編碼器讀取程序?qū)懙淖x取步進電機控制脈沖的程序

  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. }
復(fù)制代碼



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

復(fù)制代碼


再來看 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. }
復(fù)制代碼
作者: duanyz    時間: 2018-3-30 12:44

作者: duanyz    時間: 2018-3-30 19:30
angmall 發(fā)表于 2018-3-30 11:08
這段是參照網(wǎng)上編碼器讀取程序?qū)懙淖x取步進電機控制脈沖的程序

請總工來指點一下，不勝感激！
作者: liunian00    時間: 2018-3-30 20:48
要有break試試
作者: liunian00    時間: 2018-3-30 20:51
可以了嗎
作者: duanyz    時間: 2018-3-31 09:26
liunian00 發(fā)表于 2018-3-30 20:51
可以了嗎

什么可以了？我就是想知道為什么if語句里面的內(nèi)容能循環(huán)執(zhí)行的？能指點下嗎？
作者: duanyz    時間: 2018-3-31 19:34
感謝上面各位，今天重復(fù)看了這個程序，才發(fā)現(xiàn)循環(huán)調(diào)用是要在寫程序里實現(xiàn)的，跟庫文件的內(nèi)容沒啥關(guān)系。

初學(xué)者多笑話



歡迎光臨 (http://www.torrancerestoration.com/bbs/) Powered by Discuz! X3.1