PJRC Encoder Object as Property of Another Object - c++

Question

I'm borrowing PJRC's Encoder library to manage a stepper-powered syringe pump I am running off a Sparkfun RedBoard and a BigEasy Driver.
I've been developing the program modularly, defining lower-level classes first and working up from there. It is my desire that higher-level classes take instances of lower classes as properties. In my current nightmare, I'm building a syringe Pump class with Stepper motor and Encoder objects as properties.
I'm organizing the library into a header file and '.cpp' file as recommended by the Arduino Tutorials. The Pump class is declared as follows in 'Pump.h':
#include "Arduino.h"
#include "Stepper.h"
#include "Encoder.h"
#define PUMP_TOP_SPEED 50 // ml/min top pump speed
#define PUMP_ERROR 10 // encoder counts acceptable error
class Pump {
private:
Stepper motor; // object stepper motor
Encoder encoder; // object attached encoder
int countPerRev; // # encoder counts per relovlution
float nominalVolume; // mL nominal syringe volume
float innerDiameter; // cm syringe inner diameter
float shaftLead; // cm driveshaft threading lead distance
float degVolume; // mL effective volume change per degree of rotation
bool state; // boolean T = ready, F = slept
public:
// constructor
Pump(const Stepper& stp, const Encoder& enc, int cpr, float vol, float diam, float lead);
float volume(); // returns nominalVolume
float position(); // returns current pump position in mL
void hold(); // high power state to resist back-pressure
void relax(); // low power state
void pump(float vol, float rate); // pumps the requested volume at requested rate
void release(); // moves the plunger all the way out so syringe can be serviced
void set(); // returns plunger to zero mL
};
The relevant code in 'Pump.cpp' file which I have been testing with is the constructor and the definition of the pump() method, which goes like so:
// constructor
Pump::Pump(const Stepper& stp, const Encoder& enc, int cpr, float vol, float diam, float lead) : motor(stp), encoder(enc), countPerRev(cpr), nominalVolume(vol), innerDiameter(diam), shaftLead(lead) {
// calculate volume per degree
// (diameter^2 / 4) * PI * (lead / 360) = mL / deg
// diam * diam * lead * PI / 360 / 4 = (diam diam lead PI) / 1440
degVolume = innerDiameter * innerDiameter * shaftLead * PI / 1440;
// construct the encoder inside here
/*encoder = new(Encoder(2,3));
// set it to 0
encoder.write(0);*/
}
// pumping function
void Pump::pump(float vol, float rate) {
/*
vol < 0 INFUSE
vol > 0 WITHDRAW
*/
if (rate > PUMP_TOP_SPEED) rate = PUMP_TOP_SPEED; // limit rate
if (!state) hold(); // wake up the motor if it's asleep
// make sure this doesn't push outside of the acceptable range
if (position() + vol <= nominalVolume && position() + vol >= 0) {
// (mL) / (mL/deg) = deg
float degrees = vol / degVolume; // find number of degrees to turn the motor
Serial.print("Looking to turn ");
Serial.print(degrees, DEC);
Serial.print(" degrees at ");
// (count) + (deg) * (count/rev) / (deg/rev) = count
long goal = encoder.read() + degrees * countPerRev / 360; // set target encoder reading
// (mL/min) / (mL/deg) / (deg/rev) = RPM
int rpm = abs(rate) / degVolume / 360; // find RPM to turn the motor
Serial.print(rpm, DEC);
Serial.println(" RPM in full-stepping mode");
Serial.print("Going from encoder count ");
Serial.print(encoder.read(), DEC);
Serial.print(" to ");
Serial.println(goal, DEC);
motor.drive(degrees, 1, rpm); // drive the pump
int err = goal - encoder.read(); // how far from the goal are we in counts?
Serial.print("Reached encoder count ");
Serial.println(encoder.read(), DEC);
Serial.print("Missed by ");
Serial.println(err, DEC);
}
}
I've been testing my pump() method and threw in a whole bunch of Serial.print() to try to debug and figure out what is happening and from what I can see, the Encoder object that is a property of the Pump object doesn't have its position updated as the shaft turns, whereas the Encoder object declared in the Arduino sketch and passed to the Pump constructor does.
As you can see above I've tried to initialize the encoder within the pump constructor but the 2 or 3 things I tried all threw a bunch of cryptic errors in the Arduino IDE when I tried to compile, left that commented out section so you can see what I was trying.
What I find exceedingly annoying is that while my own Stepper object works fine, the Pump object can turn the motor, the Encoder object won't function inside the Pump object. When I run the sketch:
#include <Stepper.h>
#include <Encoder.h>
#include <Pump.h>
// initialize stepper
Stepper motor(4, 5, 6, 7, 8, 9, 10, 11);
// initialize encoder
Encoder encoder(2, 3);
// initialize the pump
Pump pump(motor, encoder, 1440, 25, 2.328, 0.1);
void setup() {
// start the Serial connection
Serial.begin(9600);
// set up the motor
motor.enable();
motor.reset();
// pump
pump.pump(0.25,25);
Serial.print("Pump reading: ");
Serial.println(pump.position(), DEC);
Serial.print("Encoder reading: ");
Serial.println(encoder.read(), DEC);
// cool boards
pump.relax();
}
void loop() {}
I get back the following in the Serial monitor:
Looking to turn 211.4397277832 degrees at 58 RPM in full-stepping mode
Going from encoder count 0 to 845
Reached encoder count 0
Missed by 845
Pump reading: 0.0000000000
Encoder reading: 845
So, the method encoder.read() always returns zero in the Pump object but when I called it at the end of my sketch in the setup() function it turns I turned exactly as far as I wanted to.
Thank you for reading. I'd appreciate guidance on how to either properly pass an active Encoder object to Pump, or how to properly initialize an Encoder object within Pump without freaking out the compiler.

Answer 1

The key was, in-fact, to initialize the encoder within the Pump object, as I've been reading on the Arduino boards posted by people some variant of my issue.
I constructed the encoder within the property declarations of 'Pump.h'. Since the RedBoard I'm working with is an Arduino Uno, in essence, the only acceptable pins are 2 and 3 for interrupts. I declared the encoder with the following line under the class's list of private properties:
Encoder encoder = Encoder(2,3); // attached encoder
And it now works flawlessly. There is likely an option to pass the encoder pins to the Pump constructor and have it be flexible, but for the time being I need something that works more than I need something perfect.