Revision 0:a24686ca50ab, committed 2015-04-17

Comitter:

kikoaac

Date:

Fri Apr 17 06:44:34 2015 +0000

Commit message:

???????????

Changed in this revision

diff -r 000000000000 -r a24686ca50ab QEI.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/QEI.cpp	Fri Apr 17 06:44:34 2015 +0000
@@ -0,0 +1,182 @@
+#include "QEI.h"
+
+QEI::QEI(PinName channelA,
+         PinName channelB,
+         PinName index,
+         int pulsesPerRev,
+         Encoding encoding
+         ) : channelA_(channelA), channelB_(channelB),
+        index_(index) {
+
+    pulses_       = 0;
+    revolutions_  = 0;
+    pulsesPerRev_ = pulsesPerRev;
+    encoding_     = encoding;
+    
+    //Workout what the current state is.
+    int chanA = channelA_.read();
+    int chanB = channelB_.read();
+
+    //2-bit state.
+    currState_ = (chanA << 1) | (chanB);
+    prevState_ = currState_;
+
+    channelA_.rise(this, &QEI::encode);
+    channelA_.fall(this, &QEI::encode);
+
+
+    if (encoding == X4_ENCODING) {
+        channelB_.rise(this, &QEI::encode);
+        channelB_.fall(this, &QEI::encode);
+    }
+    if (index !=  NC) {
+        index_.rise(this, &QEI::index);
+    }
+
+}
+
+void QEI::reset(void) {
+
+    pulses_      = 0;
+    revolutions_ = 0;
+    round_rev = 0;
+    sumangle = angle_ =0;
+}
+void QEI::set(int pul , int rev) {
+
+    pulses_      = pul;
+    revolutions_ = rev;
+
+}
+int QEI::getCurrentState(void) {
+
+    return currState_;
+
+}
+
+int QEI::getPulses(void) {
+
+    return pulses_;
+
+}
+
+int QEI::getRevolutions(void) {
+
+    return revolutions_;
+
+}
+double QEI::getAngle()
+{
+    return angle_;
+}
+int QEI::getAng_rev()
+{
+    return round_rev;
+}
+double QEI::getSumangle()
+{
+    return sumangle;
+}
+
+double QEI::getRPM()
+{
+    static double prev_angle;
+        Mper.stop();
+        
+        RPM = (sumangle - prev_angle) / Mper.read() * 60.0 / 360;
+        Mper.reset();
+        Mper.start();
+        prev_angle = sumangle;        
+    return RPM;
+}
+double QEI::getRPS()
+{
+    static double prev_angle;
+        Rper.stop();
+        
+        RPS = (sumangle - prev_angle) / Rper.read() / 360;
+        Rper.reset();
+        Rper.start();
+        prev_angle = sumangle;  
+    return RPS;
+}
+double QEI::getRPMS()
+{    static double prev_angle;
+        MSper.stop();
+        
+        RPMS = (sumangle - prev_angle) / (double)MSper.read_ms() / 360;
+        MSper.reset();
+        MSper.start();
+        prev_angle = sumangle;  
+    return RPMS;
+}
+double QEI::getRPUS()
+{    static double prev_angle;
+        USper.stop();
+        
+        RPUS = (sumangle - prev_angle) / (double)USper.read_us() / 360;
+        USper.reset();
+        USper.start();
+        prev_angle = sumangle;  
+    return RPUS;
+}
+void QEI::encode(void) {
+
+    int change = 0;
+    int chanA  = channelA_.read();
+    int chanB  = channelB_.read();
+
+    currState_ = (chanA << 1) | (chanB);
+    
+    if (encoding_ == X2_ENCODING) {
+
+        if ((prevState_ == 0x3 && currState_ == 0x0) ||
+                (prevState_ == 0x0 && currState_ == 0x3)) {
+
+            pulses_++;
+            angle_pulses++;
+
+        }
+        else if ((prevState_ == 0x2 && currState_ == 0x1) ||
+                 (prevState_ == 0x1 && currState_ == 0x2)) {
+
+            pulses_--;
+            angle_pulses--;
+
+        }
+
+    } else if (encoding_ == X4_ENCODING) {
+
+        if (((currState_ ^ prevState_) != INVALID) && (currState_ != prevState_)) {
+            change = (prevState_ & PREV_MASK) ^ ((currState_ & CURR_MASK) >> 1);
+
+            if (change == 0) {
+                change = -1;
+            }
+
+            pulses_ -= change;
+            angle_pulses -= change;
+        }
+
+    }
+    angle_ = angle_pulses*360/((double)pulsesPerRev_*4);
+    sumangle = pulses_*360/((double)pulsesPerRev_*4);
+    if(angle_>=360)
+    {
+        angle_pulses = angle_ = 0;
+        round_rev++;
+    }
+    else if(angle_<=-360)
+    {
+        angle_pulses = angle_ = 0;
+        round_rev--;
+    }
+    prevState_ = currState_;
+}
+
+void QEI::index(void) {
+
+    revolutions_++;
+
+}
+

diff -r 000000000000 -r a24686ca50ab QEI.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/QEI.h	Fri Apr 17 06:44:34 2015 +0000
@@ -0,0 +1,76 @@
+
+
+#ifndef QEI_H
+#define QEI_H
+
+
+#include "mbed.h"
+
+
+#define PREV_MASK 0x1 //Mask for the previous state in determining direction
+//of rotation.
+#define CURR_MASK 0x2 //Mask for the current state in determining direction
+//of rotation.
+#define INVALID   0x3 //XORing two states where both bits have changed.
+
+class QEI {
+
+public:
+
+    typedef enum Encoding {
+
+        X2_ENCODING,
+        X4_ENCODING
+
+    } Encoding;
+
+
+    QEI(PinName channelA, PinName channelB, PinName index, int pulsesPerRev, Encoding encoding = X2_ENCODING);
+
+    void reset(void);
+
+    int getCurrentState(void);
+
+
+    void set(int pul , int rev);  
+     
+    int getPulses(void);
+
+    int getRevolutions(void);
+    
+    int getAng_rev();
+    
+    double getAngle();
+    double getSumangle();
+    double getRPM();
+    double getRPS();
+    double getRPMS();
+    double getRPUS();
+    int          pulsesPerRev_;
+private:
+    Timer Mper , Rper ,MSper ,USper; 
+    Ticker Tick;
+    double RPM , RPS ,RPMS , RPUS;
+
+    void encode(void);
+
+ 
+    void index(void);
+
+    Encoding encoding_;
+
+    InterruptIn channelA_;
+    InterruptIn channelB_;
+    InterruptIn index_;
+    int          round_rev;
+
+    int          prevState_;
+    int          currState_;
+    double angle_ , sumangle;
+    int angle_pulses;
+    volatile int pulses_;
+    volatile int revolutions_;
+
+};
+
+#endif