add mode change callback

Author: timhendriks93

examples/SwitchModeButton/SwitchModeButton.ino

@@ -3,9 +3,13 @@
 
   In this example we are using the OneButton library to handle both short and
   long button presses. Note that the animation will be in default mode first,
-  meaning that the servo will not move until the button is pressed shortly to
-  start the animation. See the comments below to understand what happens when
-  pressing the button short or long according to the current mode.
+  meaning that the servo will not move until the button is shortly pressed to
+  start the animation.
+
+  We also register a callback which is triggered whenever the animation mode
+  changes. For example, this can be used to control the animation audio. See the
+  comments below to understand what happens on a short or long button press
+  based on the current mode.
 */
 
 #include "simple.h"
@@ -31,6 +35,22 @@ void move(byte servoID, int angle) {
   myServo.write(angle);
 }
 
+// Callback function which is called whenever the animation mode changes
+void modeChanged(byte prevMode, byte newMode) {
+  switch (newMode) {
+  case BlenderServoAnimation::Animation::MODE_PLAY:
+    if (prevMode == BlenderServoAnimation::Animation::MODE_PAUSE) {
+      // E.g. resume audio
+    } else {
+      // E.g. start audio
+    }
+    break;
+  case BlenderServoAnimation::Animation::MODE_PAUSE:
+    // E.g. pause audio
+    break;
+  }
+}
+
 // Animation object to represent the original Blender animation
 BlenderServoAnimation::Animation animation(FPS, FRAMES);
 
@@ -43,17 +63,14 @@ void onPressed() {
   switch (animation.getMode()) {
     // On short press in default mode, we want to start the animation
   case BlenderServoAnimation::Animation::MODE_DEFAULT:
-    // Hint: here you could also trigger some audio
     animation.play();
     break;
     // On short press in play mode, we want to pause the animation
   case BlenderServoAnimation::Animation::MODE_PLAY:
     animation.pause();
-    // Hint: here you could also pause some audio
     break;
     // On short press in pause mode, we want to resume the animation
   case BlenderServoAnimation::Animation::MODE_PAUSE:
-    // Hint: here you could also resume some audio
     animation.play();
     break;
   }
@@ -86,6 +103,9 @@ void setup() {
 
   // Add the Blender servo object to the animation
   animation.addServo(myBlenderServo);
+
+  // Register the mode change callback function
+  animation.onModeChange(modeChanged);
 }
 
 void loop() {

src/BlenderServoAnimation.cpp

@@ -25,6 +25,19 @@ void Animation::addServos(Servo servos[], byte servoAmount) {
   }
 }
 
+void Animation::onModeChange(mcb modeCallback) {
+  this->modeCallback = modeCallback;
+}
+
+void Animation::changeMode(byte mode) {
+  byte prevMode = this->mode;
+  this->mode = mode;
+
+  if (this->modeCallback) {
+    this->modeCallback(prevMode, mode);
+  }
+}
+
 void Animation::run(unsigned long currentMicros) {
   switch (mode) {
   case MODE_PLAY:
@@ -79,7 +92,7 @@ void Animation::handleStopMode() {
   }
 
   if (allNeutral) {
-    this->mode = Animation::MODE_DEFAULT;
+    this->changeMode(Animation::MODE_DEFAULT);
     return;
   }
 
@@ -111,23 +124,23 @@ void Animation::handleLiveMode() {
 }
 
 void Animation::play() {
-  this->mode = Animation::MODE_PLAY;
   this->lastMicros = micros();
+  this->changeMode(Animation::MODE_PLAY);
 }
 
 void Animation::pause() {
-  this->mode = Animation::MODE_PAUSE;
+  this->changeMode(Animation::MODE_PAUSE);
 }
 
 void Animation::stop(byte stepDelay) {
-  this->mode = Animation::MODE_STOP;
   this->stopStepDelay = stepDelay;
   this->frame = 0;
+  this->changeMode(Animation::MODE_STOP);
 }
 
 void Animation::live(Stream &serial) {
-  this->mode = Animation::MODE_LIVE;
   this->serial = &serial;
+  this->changeMode(Animation::MODE_LIVE);
 }
 
 byte Animation::getMode() {

src/BlenderServoAnimation.h

@@ -7,6 +7,8 @@
 
 namespace BlenderServoAnimation {
 class Animation {
+  typedef void (*mcb)(byte, byte);
+
 private:
   static const int MAX_SERVO_COUNT = 256;
   static const long SECOND_IN_MICROS = 1000000;
@@ -26,11 +28,11 @@ class Animation {
   Servo *servos[MAX_SERVO_COUNT] = {};
   Stream *serial;
   Command command;
+  mcb modeCallback = nullptr;
 
+  void changeMode(byte mode);
   void handlePlayMode(unsigned long currentMicros);
-
   void handleStopMode();
-
   void handleLiveMode();
 
 public:
@@ -41,25 +43,16 @@ class Animation {
   static const byte MODE_LIVE = 4;
 
   Animation();
-
   Animation(byte fps, int frames);
-
   void addServo(Servo &servo);
-
   void addServos(Servo servos[], byte servoAmount);
-
+  void onModeChange(mcb modeCallback);
   void run(unsigned long currentMicros = micros());
-
   void play();
-
   void pause();
-
   void stop(byte stepDelay = 20);
-
   void live(Stream &serial);
-
   byte getMode();
-
   int getFrame();
 };
 } // namespace BlenderServoAnimation

src/servo/Servo.h

@@ -20,19 +20,12 @@ class Servo {
 
 public:
   Servo(byte id, const int positions[], cb moveCallback, byte threshold = 20);
-
   Servo(byte id, cb moveCallback, byte threshold = 20);
-
   void move(int position, bool force = false);
-
   void moveByStep(int step);
-
   void moveTowardsNeutral(bool inSteps = true);
-
   bool isNeutral();
-
   bool hasPositions();
-
   byte getID();
 };
 } // namespace BlenderServoAnimation

test/test_animation/test_animation.cpp

@@ -15,6 +15,14 @@ struct positionLog {
 
 positionLog lastPositions[16];
 
+struct modeLog {
+  byte prevMode;
+  byte newMode;
+};
+
+byte modeIndex = 0;
+modeLog lastModes[10];
+
 void setUp(void) {
   for (int id = 0; id < 16; id++) {
     lastPositions[id].index = 0;
@@ -23,6 +31,13 @@ void setUp(void) {
       lastPositions[id].positions[i] = 0;
     }
   }
+
+  for (int i = 0; i < 10; i++) {
+    lastModes[i].prevMode = 0;
+    lastModes[i].newMode = 0;
+  }
+
+  modeIndex = 0;
 }
 
 void move(byte servoID, int position) {
@@ -31,6 +46,12 @@ void move(byte servoID, int position) {
   lastPositions[servoID].index++;
 }
 
+void onModeChange(byte prevMode, byte newMode) {
+  lastModes[modeIndex].prevMode = prevMode;
+  lastModes[modeIndex].newMode = newMode;
+  modeIndex++;
+}
+
 const int positionsA[5] PROGMEM = {350, 340, 330, 340, 330};
 const int positionsB[5] PROGMEM = {250, 240, 230, 240, 230};
 
@@ -155,11 +176,35 @@ void test_live(void) {
   TEST_ASSERT_EQUAL(355, lastPositions[1].positions[1]);
 }
 
+void test_mode_change(void) {
+  SerialMock mock;
+  Animation animation(FPS, FRAMES);
+
+  animation.onModeChange(onModeChange);
+
+  animation.play();
+  TEST_ASSERT_EQUAL(Animation::MODE_DEFAULT, lastModes[0].prevMode);
+  TEST_ASSERT_EQUAL(Animation::MODE_PLAY, lastModes[0].newMode);
+  animation.pause();
+  TEST_ASSERT_EQUAL(Animation::MODE_PLAY, lastModes[1].prevMode);
+  TEST_ASSERT_EQUAL(Animation::MODE_PAUSE, lastModes[1].newMode);
+  animation.stop();
+  TEST_ASSERT_EQUAL(Animation::MODE_PAUSE, lastModes[2].prevMode);
+  TEST_ASSERT_EQUAL(Animation::MODE_STOP, lastModes[2].newMode);
+  animation.run();
+  TEST_ASSERT_EQUAL(Animation::MODE_STOP, lastModes[3].prevMode);
+  TEST_ASSERT_EQUAL(Animation::MODE_DEFAULT, lastModes[3].newMode);
+  animation.live(mock);
+  TEST_ASSERT_EQUAL(Animation::MODE_DEFAULT, lastModes[4].prevMode);
+  TEST_ASSERT_EQUAL(Animation::MODE_LIVE, lastModes[4].newMode);
+}
+
 int main(int argc, char **argv) {
   UNITY_BEGIN();
   RUN_TEST(test_play);
   RUN_TEST(test_pause);
   RUN_TEST(test_stop);
   RUN_TEST(test_live);
+  RUN_TEST(test_mode_change);
   UNITY_END();
 }