2025 RPi state machine and player control

controller/software/CMakeLists.txt

@@ -45,11 +45,14 @@ include_directories(${INCLUDES} ${HARDWARE_INCLUDES})
 add_library(playerLIB STATIC
   ${SOURCE}/player/LEDPlayer.cpp ${SOURCE}/player/OFPlayer.cpp
   ${SOURCE}/commands/player.cpp )
-  # ${SOURCE}/commands/player.cpp ${SOURCE}/player/StateMachine.cpp)
-  add_library(StateMachineLIB STATIC ${SOURCE}/player/StateMachine.cpp ${SOURCE}/player/FSM_Common.cpp)
+
+add_library(StateMachineLIB STATIC ${SOURCE}/player/state_machine.cpp)
+
+add_library(timevalLIB STATIC ${SOURCE}/timeval_tools.cpp)
+
 # target_include_directories(playerLIB PUBLIC ${INCLUDES} ${HARDWARE_INCLUDES})
-target_link_libraries(playerLIB StateMachineLIB ${Boost_LIBRARIES} ${HARDWARE_LIBRARIES})
-target_link_libraries(StateMachineLIB playerLIB ${Boost_LIBRARIES} ${HARDWARE_LIBRARIES})
+target_link_libraries(playerLIB StateMachineLIB timevalLIB ${Boost_LIBRARIES} ${HARDWARE_LIBRARIES})
+target_link_libraries(StateMachineLIB playerLIB timevalLIB ${Boost_LIBRARIES} ${HARDWARE_LIBRARIES})
 
 # list
 add_executable(
@@ -73,7 +76,7 @@ target_link_libraries(load ${Boost_LIBRARIES} ${HARDWARE_LIBRARIES} playerLIB)
 # playerctl
 add_executable(playerctl ${SOURCE}/commands/playerctl.cpp)
 # target_include_directories(playerctl PUBLIC ${INCLUDES})
-target_link_libraries(playerctl ${Boost_LIBRARIES})
+target_link_libraries(playerctl timevalLIB ${Boost_LIBRARIES})
 
 # ledtest
 # add_executable(

controller/software/inc/LEDPlayer.h

@@ -26,7 +26,7 @@
 #include <boost/serialization/version.hpp>
 
 #include "LEDController.h"
-#include "StateMachine.h"
+#include "state_machine.h"
 #include "const.h"
 
 using namespace std;
@@ -65,7 +65,7 @@ class LEDPlayer {
     // threading function
     void* loop_helper(void *context, StateMachine* fsm);
     void loop(StateMachine *fsm);
-    void delayDisplay(const bool *delayingDisplay);
+    void delayDisplay(bool delayingDisplay);
     void darkAll();
     template <class Archive>
     void serialize(Archive &archive, const unsigned int version);

controller/software/inc/OFPlayer.h

@@ -27,7 +27,7 @@
 #include <boost/serialization/version.hpp>
 
 #include "OFController.h"
-#include "StateMachine.h"
+#include "state_machine.h"
 #include "const.h"
 
 using namespace std;
@@ -67,7 +67,7 @@ class OFPlayer {
     // threading function
    // void* loop_helper(void* context, StateMachine *fsm);
     void loop(StateMachine *fsm);
-    void delayDisplay(const bool *delayingDisplay);
+    void delayDisplay(bool delayingDisplay);
     void init();
     void darkAll();
     template <class Archive>

controller/software/inc/const.h

@@ -6,4 +6,7 @@
 #define LED_NUM 8
 #define UPDATE_INTERVAL 30000 //microseconds(us)
 
+#define FIFO_CMD_TO_PLAYER "/tmp/cmd_to_player"
+#define FIFO_PLAYER_TO_CMD "/tmp/player_to_cmd"
+
 #endif

controller/software/inc/machine_tools.h

@@ -0,0 +1,95 @@
+#ifndef _MACINE_TOOLS_H_
+#define _MACINE_TOOLS_H_
+
+#include <thread>
+
+#include <LEDPlayer.h>
+#include <OFPlayer.h>
+#include <player.h>
+#include <const.h>
+#include <utils.h>
+#include <timeval_tools.h>
+
+extern const char *TAG;
+
+std::thread led_loop, of_loop;
+Player player;
+LEDPlayer led_player;
+OFPlayer of_player;
+int dancer_fd;
+const string path_to_dat = string(BASE_PATH) + "data/dancer.dat";
+
+void delayDisplay(bool display)
+{
+    led_player.delayDisplay(display);
+    of_player.delayDisplay(display);
+    return;
+}
+
+timeval getCalculatedTime(timeval subtrahend) {
+    timeval currentTime;
+    gettimeofday(&currentTime, NULL);
+    timeval time;
+    time.tv_sec = currentTime.tv_sec - subtrahend.tv_sec;
+    time.tv_usec = currentTime.tv_usec - subtrahend.tv_usec;
+    if (time.tv_usec < 0) {
+        time.tv_sec--;
+        time.tv_usec += 1000000;
+    }
+    return time;
+}
+
+bool restart() {
+    fprintf(stderr, "%srestart\n", TAG);
+    dancer_fd = tryGetLock(path_to_dat.c_str());
+    if (dancer_fd == -1) {
+        fprintf(stderr, "%sDancer is playing! Please stop it first!\n", TAG);
+        return 0;
+    } else if (dancer_fd == -2) {
+        fprintf(stderr, "%sdancer.dat cannot found\n", TAG);
+        return 0;
+    }
+
+    if (!restorePlayer(player, path_to_dat.c_str())) {
+        fprintf(stderr, "%scannot restore player\n", TAG);
+        return false;
+    }
+    led_player = player.myLEDPlayer;
+    led_player.init();
+    of_player = player.myOFPlayer;
+    of_player.init();
+    fprintf(stderr, "%sPlayer loaded\n", TAG);
+    return true;
+   }
+
+void resume( StateMachine* fsm ){
+	led_loop = std::thread(&LEDPlayer::loop, &led_player, fsm);
+	of_loop = std::thread(&OFPlayer::loop, &of_player, fsm);
+	//led_loop.detach();
+	//of_loop.detach();
+	// pthread_create(&led_loop, NULL,&LEDPlayer::loop_helper, &led_player, fsm);
+	// pthread_create(&of_loop, NULL,&OFPlayer::loop_helper, &of_player , fsm);
+	cerr << "[Common] thread running\n";
+	return;
+}
+
+void Loop_Join()
+{
+    if(led_loop.joinable()){
+        led_loop.join();
+        fprintf(stderr, "%sled_loop joined\n", TAG);
+    }
+    else{
+        fprintf(stderr, "%sled_loop cannot join\n", TAG);
+    }
+    if(of_loop.joinable()){
+        of_loop.join();
+        fprintf(stderr, "%sof_loop joined\n", TAG);
+    }
+    else{
+        fprintf(stderr, "%sof_loop cannot join\n", TAG);
+    }
+    return;
+}
+
+#endif // _MACINE_TOOLS_H_

controller/software/inc/FSM_Common.h → controller/software/inc/oriFSM_Common.h

@@ -3,25 +3,25 @@
 
 #include <sys/time.h>
 #include <iostream>
-#include <thread> 
+#include <thread>
 #include <const.h>
-#include <StateMachine.h>
+#include <oriStateMachine.h>
 #include <LEDPlayer.h>
 #include <OFPlayer.h>
 #include <player.h>
 #include <string>
 
-
-enum CMD { C_PLAY, C_PAUSE, C_STOP, C_RESUME };
-extern const std::string cmds[10];
+//enum CMD { C_PLAY, C_PAUSE, C_STOP, C_RESUME };
+//extern const std::string cmds[10];
 extern std::thread led_loop, of_loop;
 extern Player player;
 extern LEDPlayer led_player;
 extern OFPlayer of_player;
 extern int dancer_fd;
 extern string path ;
-extern const char *rd_fifo;
+//extern const char *rd_fifo;
 extern const char *wr_fifo;
+
 inline void write_fifo(bool success) {
     int wr_fd;
     std::string msg;
@@ -69,10 +69,11 @@ inline timeval getCalculatedTime(timeval subtrahend) {
     }
     return time;
 }
+
 inline bool restart() {
     printf("restart\n");
     dancer_fd = tryGetLock(path.c_str());
- if (dancer_fd == -1) {
+    if (dancer_fd == -1) {
         cerr << "[Common] Dancer is playing! Please stop it first!\n";
         return 0;
     } else if (dancer_fd == -2) {
@@ -91,7 +92,8 @@ inline bool restart() {
     of_player.init();
     cerr << "[Common] Player loaded\n";
     return true;
-   }
+}
+
 inline void resume( StateMachine* fsm ){
 	led_loop = std::thread(&LEDPlayer::loop, &led_player, fsm);
 	of_loop = std::thread(&OFPlayer::loop, &of_player, fsm);
@@ -103,6 +105,7 @@ inline void resume( StateMachine* fsm ){
 	 return;
    }
 
+<<<<<<< HEAD:controller/software/inc/FSM_Common.h
 inline int parse_command(StateMachine* fsm,std::string str) {
     if (str.length() == 1){
 	    write_fifo(false); 
@@ -129,15 +132,15 @@ inline int parse_command(StateMachine* fsm,std::string str) {
                 } else if (cmd.size() >= 3 && cmd[cmd.size() - 2] == "-d") {
                     fsm->data.delayTime = std::stoi(cmd[cmd.size() - 1]);//*1000;//saved as us
                     if (cmd.size() > 3) {
-                        startusec = std::stoi(cmd[1])*1000;
+                        startusec = std::stoi(cmd[1]);
                     }
                     if (cmd.size() > 4) {
                         fsm->data.stopTime = std::stoi(cmd[2]);
                         fsm->data.stopTimeAssigned = true;
                     }
                 } else {
                     if (cmd.size()>1) {
-                        startusec = std::stoi(cmd[1])*1000;
+                        startusec = std::stoi(cmd[1]);
 		            }
                     if (cmd.size() > 2) {
                         fsm->data.stopTime = std::stoi(cmd[2]);
@@ -157,5 +160,7 @@ inline int parse_command(StateMachine* fsm,std::string str) {
     write_fifo(false); 
     return -1;
 }
+=======
+>>>>>>> test_fsm:controller/software/inc/oriFSM_Common.h
 
 #endif

controller/software/inc/StateMachine.h → controller/software/inc/oriStateMachine.h

@@ -12,10 +12,14 @@
 #include <string>
 #include <thread>
 #include <vector>
-#include <unordered_map>  
+#include <unordered_map>
 #include <utility>
 #include <utils.h>
+<<<<<<< HEAD:controller/software/inc/StateMachine.h
 #include <iostream>
+#include <fstream>
+=======
+>>>>>>> test_fsm:controller/software/inc/oriStateMachine.h
 #define STATE_NUM 3
 using namespace std;
 enum Event { PLAY, PAUSE, STOP, RESUME,INVALID_CMD=-1}; // Event type
@@ -36,6 +40,7 @@ typedef struct {
 
 class StateMachine{
     private:
+        fstream fsm_log;
         int currentState,nextState; 
         int TransitionTable[3][4]={
         {EVENT_IGNORE, S_PAUSE,S_STOP, CANNOT_HAPPEN},
@@ -69,7 +74,7 @@ class StateMachine{
             &StateMachine::EN_Pause,
             &StateMachine::EN_Stop
         };
-        public:
+    public:
         enum { EVENT_IGNORE = 0xef, CANNOT_HAPPEN = 0xff };
         playLoop_Data data; 
         StateMachine(); //init from initial state, maybe need to add more init parameters?
@@ -81,9 +86,11 @@ class StateMachine{
         //void setState(int nextState);
         void setData(timeval _baseTime, timeval _playedTime, long _stopTime, long _delayTime, bool _stopTimeAssigned, bool _isLiveEditting);
         timeval getPlayedTime();
-	void Loop_Join();
+	    void Loop_Join();
+        ~StateMachine();
+
 };
 
 
-int parse_command(string cmd);
+int parse_command(StateMachine * fsm, string cmd);
 #endif

controller/software/inc/state_machine.h

@@ -0,0 +1,85 @@
+#ifndef _STATE_MACHINE_H_
+#define _STATE_MACHINE_H_
+
+#include <sys/time.h>
+#include <sstream>
+
+#define DEFAULT_DELAY_DISPLAY_RATIO 0.2
+
+enum STATE
+{
+    STATE_STOP, 
+    STATE_PLAY, 
+    STATE_PAUSE, 
+    STATE_DELAY, 
+    NUM_OF_STATES, 
+    STATE_NULL
+};
+
+enum EVENT
+{
+    EVENT_PLAY, 
+    EVENT_STOP, 
+    EVENT_PAUSE, 
+    EVENT_RESUME,
+    NUM_OF_EVENTS, 
+    EVENT_NULL
+};
+
+struct playLoop_Data
+{
+    // specified
+    timeval start_time_stamp;
+    timeval stop_time_stamp;
+    timeval delay_duration;
+    float delay_display_ratio;
+    // private record
+    timeval start_time;
+    timeval enter_delay_time;
+    timeval enter_pause_time;
+    timeval total_pause_time;
+    timeval curr_time_stamp;
+};
+
+class StateMachine
+{
+private: 
+    STATE m_state;
+    playLoop_Data data;
+    static const STATE m_transition_table[NUM_OF_STATES][NUM_OF_EVENTS];
+    void exitState(STATE state);
+    void execState(STATE state);
+    void enterState(STATE state);
+    void exitSTOP();
+    void exitPLAY();
+    void exitPAUSE();
+    void exitDELAY();
+    void execSTOP();
+    void execPLAY();
+    void execPAUSE();
+    void execDELAY();
+    void enterSTOP();
+    void enterPLAY();
+    void enterPAUSE();
+    void enterDELAY();
+
+public: 
+    StateMachine();
+    ~StateMachine();
+    bool processEvent(EVENT event);
+    void execCurrState();
+    timeval getCurrTimeStamp() const;
+    void setStartTime(timeval _start_time_stamp);
+    void setStopTime(timeval _stop_time_stamp);
+    void setDelayTime(timeval _delay_time, float _delay_display_ratio = DEFAULT_DELAY_DISPLAY_RATIO);
+    STATE getCurrState() const;
+
+friend class LEDPlayer;
+friend class OFPlayer;
+};
+
+EVENT parse_event(const char *str);
+std::string stateToStr(STATE state);
+std::string eventToStr(EVENT event);
+
+#endif // _STATE_MACHINE_H_