Terminé le projet de base (sans cam)

software/raspberry/superviseur-robot/nbproject/Makefile-Debug__RPI_.mk

 AS=as
 
 # Macros
-CND_PLATFORM=GNU-None
+CND_PLATFORM=GNU-Linux
 CND_DLIB_EXT=so
 CND_CONF=Debug__RPI_
 CND_DISTDIR=dist

software/raspberry/superviseur-robot/nbproject/Makefile-variables.mk

 CND_PACKAGE_NAME_Debug__PC_=superviseur-robot.tar
 CND_PACKAGE_PATH_Debug__PC_=dist/Debug__PC_/GNU-Linux/package/superviseur-robot.tar
 # Debug__RPI_ configuration
-CND_PLATFORM_Debug__RPI_=GNU-None
-CND_ARTIFACT_DIR_Debug__RPI_=dist/Debug__RPI_/GNU-None
+CND_PLATFORM_Debug__RPI_=GNU-Linux
+CND_ARTIFACT_DIR_Debug__RPI_=dist/Debug__RPI_/GNU-Linux
 CND_ARTIFACT_NAME_Debug__RPI_=superviseur-robot
-CND_ARTIFACT_PATH_Debug__RPI_=dist/Debug__RPI_/GNU-None/superviseur-robot
-CND_PACKAGE_DIR_Debug__RPI_=dist/Debug__RPI_/GNU-None/package
+CND_ARTIFACT_PATH_Debug__RPI_=dist/Debug__RPI_/GNU-Linux/superviseur-robot
+CND_PACKAGE_DIR_Debug__RPI_=dist/Debug__RPI_/GNU-Linux/package
 CND_PACKAGE_NAME_Debug__RPI_=superviseur-robot.tar
-CND_PACKAGE_PATH_Debug__RPI_=dist/Debug__RPI_/GNU-None/package/superviseur-robot.tar
+CND_PACKAGE_PATH_Debug__RPI_=dist/Debug__RPI_/GNU-Linux/package/superviseur-robot.tar
 #
 # include compiler specific variables
 #

software/raspberry/superviseur-robot/nbproject/Package-Debug__RPI_.bash

 
 # Macros
 TOP=`pwd`
-CND_PLATFORM=GNU-None
+CND_PLATFORM=GNU-Linux
 CND_CONF=Debug__RPI_
 CND_DISTDIR=dist
 CND_BUILDDIR=build

software/raspberry/superviseur-robot/nbproject/private/configurations.xml

     </conf>
     <conf name="Debug__RPI_" type="1">
       <toolsSet>
-        <developmentServer>pi@10.105.1.01:22</developmentServer>
-        <platform>6</platform>
+        <developmentServer>pi@10.105.1.11:22</developmentServer>
+        <platform>2</platform>
       </toolsSet>
       <dbx_gdbdebugger version="1">
         <gdb_pathmaps>

software/raspberry/superviseur-robot/nbproject/private/private.xml

             <file>file:/home/tali/Temps_Reel/dumber/software/raspberry/superviseur-robot/main.cpp</file>
             <file>file:/home/tali/Temps_Reel/dumber/software/raspberry/superviseur-robot/tasks.cpp</file>
             <file>file:/home/tali/Temps_Reel/dumber/software/raspberry/superviseur-robot/tasks.h</file>
+            <file>file:/home/tali/Temps_Reel/dumber/software/raspberry/superviseur-robot/lib/img.cpp</file>
             <file>file:/home/tali/Temps_Reel/dumber/software/raspberry/superviseur-robot/lib/comrobot.h</file>
-            <file>file:/home/tali/Temps_Reel/dumber/software/raspberry/superviseur-robot/lib/messages.cpp</file>
+            <file>file:/home/tali/Temps_Reel/dumber/software/raspberry/superviseur-robot/lib/img.h</file>
             <file>file:/home/tali/Temps_Reel/dumber/software/raspberry/superviseur-robot/lib/commonitor.cpp</file>
         </group>
     </open-files>

software/raspberry/superviseur-robot/nbproject/private/timestamps-10.105.1.11-pi-22

+#Mon Mar 15 11:43:08 CET 2021
+/home/tali/Temps_Reel/dumber/software/raspberry/superviseur-robot/scriptRasp.sh=c1614326506000
+/home/tali/Temps_Reel/dumber/software/raspberry/superviseur-robot/lib/camera.cpp=c1614324985000
+/home/tali/Temps_Reel/dumber/software/raspberry/superviseur-robot/lib/img.cpp=c1614324985000
+/home/tali/Temps_Reel/dumber/software/raspberry/superviseur-robot/lib/comrobot.cpp=c1614324985000
+/home/tali/Temps_Reel/dumber/software/raspberry/superviseur-robot/lib/base64/test.cpp=c1614324985000
+/home/tali/Temps_Reel/dumber/software/raspberry/superviseur-robot/nbproject/project.xml=c1614324985000
+/home/tali/Temps_Reel/dumber/software/raspberry/superviseur-robot/lib/commonitor.cpp=c1614324985000
+/home/tali/Temps_Reel/dumber/software/raspberry/superviseur-robot/lib/base64/base64.h=c1614324985000
+/home/tali/Temps_Reel/dumber/software/raspberry/superviseur-robot/lib/base64/LICENSE=c1614324985000
+/home/tali/Temps_Reel/dumber/software/raspberry/superviseur-robot/nbproject/project.properties=c1614324985000
+/home/tali/Temps_Reel/dumber/software/raspberry/superviseur-robot/tasks.h=c1615800561000
+/home/tali/Temps_Reel/dumber/software/raspberry/superviseur-robot/lib/img.h=c1614324985000
+/home/tali/Temps_Reel/dumber/software/raspberry/superviseur-robot/lib/messages.h=c1614324985000
+/home/tali/Temps_Reel/dumber/software/raspberry/superviseur-robot/tasks.cpp=c1615804981000
+/home/tali/Temps_Reel/dumber/software/raspberry/superviseur-robot/nbproject/Makefile-impl.mk=c1614324985000
+/home/tali/Temps_Reel/dumber/software/raspberry/superviseur-robot/lib/.gitignore=c1614324985000
+/home/tali/Temps_Reel/dumber/software/raspberry/superviseur-robot/nbproject/Package-Debug__PC_.bash=c1614324985000
+/home/tali/Temps_Reel/dumber/software/raspberry/superviseur-robot/gdbsudo.sh=c1614324985000
+VERSION=1.3
+/home/tali/Temps_Reel/dumber/software/raspberry/superviseur-robot/lib/commonitor.h=c1614324985000
+/home/tali/Temps_Reel/dumber/software/raspberry/superviseur-robot/README.md=c1614324985000
+/home/tali/Temps_Reel/dumber/software/raspberry/superviseur-robot/lib/base64/README.md=c1614324985000
+/home/tali/Temps_Reel/dumber/software/raspberry/superviseur-robot/.dep.inc=c1614324985000
+/home/tali/Temps_Reel/dumber/software/raspberry/superviseur-robot/lib/comrobot.h=c1614324985000
+/home/tali/Temps_Reel/dumber/software/raspberry/superviseur-robot/lib/base64/.gitignore=c1614324985000
+/home/tali/Temps_Reel/dumber/software/raspberry/superviseur-robot/nbproject/private/Makefile-variables.mk=c1614324985000
+/home/tali/Temps_Reel/dumber/software/raspberry/superviseur-robot/nbproject/Package-Debug__RPI_.bash=c1615797916000
+/home/tali/Temps_Reel/dumber/software/raspberry/superviseur-robot/Makefile=c1614324985000
+/home/tali/Temps_Reel/dumber/software/raspberry/superviseur-robot/nbproject/Makefile-Debug__RPI_.mk=c1615797916000
+/home/tali/Temps_Reel/dumber/software/raspberry/superviseur-robot/nbproject/Makefile-variables.mk=c1615797916000
+/home/tali/Temps_Reel/dumber/software/raspberry/superviseur-robot/.gitignore=c1614324985000
+/home/tali/Temps_Reel/dumber/software/raspberry/superviseur-robot/lib/messages.cpp=c1614324985000
+/home/tali/Temps_Reel/dumber/software/raspberry/superviseur-robot/nbproject/Makefile-Debug__PC_.mk=c1614324985000
+/home/tali/Temps_Reel/dumber/software/raspberry/superviseur-robot/lib/base64/compile-and-run-test=c1614324985000
+/home/tali/Temps_Reel/dumber/software/raspberry/superviseur-robot/superviseur.doxygen=c1614324985000
+/home/tali/Temps_Reel/dumber/software/raspberry/superviseur-robot/lib/base64/base64.cpp=c1614324985000
+/home/tali/Temps_Reel/dumber/software/raspberry/superviseur-robot/lib/camera.h=c1614324985000
+/home/tali/Temps_Reel/dumber/software/raspberry/superviseur-robot/main.cpp=c1614324985000

software/raspberry/superviseur-robot/tasks.cpp

 #define PRIORITY_TRECEIVEFROMMON 25
 #define PRIORITY_TSTARTROBOT 20
 #define PRIORITY_TCAMERA 21
+#define PRIORITY_TWATCHDOG 35
+#define PRIORITY_TBATTERY 20
 
 /*
  * Some remarks:
         cerr << "Error task create: " << strerror(-err) << endl << flush;
         exit(EXIT_FAILURE);
     }
-    if (err = rt_task_create(&th_battery, "th_battery", 0, PRIORITY_TMOVE, 0)) {
+    if (err = rt_task_create(&th_battery, "th_battery", 0, PRIORITY_TBATTERY, 0)) {
         cerr << "Error task create: " << strerror(-err) << endl << flush;
         exit(EXIT_FAILURE);
     }
         cerr << "Error task create: " << strerror(-err) << endl << flush;
         exit(EXIT_FAILURE);
     }
-    if (err = rt_task_create(&th_watchdog, "th_watchdog", 0, PRIORITY_TMOVE, 0)) {
+    if (err = rt_task_create(&th_watchdog, "th_watchdog", 0, PRIORITY_TWATCHDOG, 0)) {
         cerr << "Error task create: " << strerror(-err) << endl << flush;
         exit(EXIT_FAILURE);
     }
-    if (err = rt_task_create(&th_camera, "th_camera", 0, PRIORITY_TMOVE, 0)) {
+    if (err = rt_task_create(&th_camera, "th_camera", 0, PRIORITY_TCAMERA, 0)) {
         cerr << "Error task create: " << strerror(-err) << endl << flush;
         exit(EXIT_FAILURE);
     }
-    if (err = rt_task_create(&th_startCamera, "th_startCamera", 0, PRIORITY_TMOVE, 0)) {
+    if (err = rt_task_create(&th_startCamera, "th_startCamera", 0, PRIORITY_TCAMERA, 0)) {
         cerr << "Error task create: " << strerror(-err) << endl << flush;
         exit(EXIT_FAILURE);
     }
  */
 void Tasks::ReceiveFromMonTask(void *arg) {
     Message *msgRcv;
+    int err;
     
     cout << "Start " << __PRETTY_FUNCTION__ << endl << flush;
     // Synchronization barrier (waiting that all tasks are starting)
     /**************************************************************************************/
     /* The task receiveFromMon starts here                                                */
     /**************************************************************************************/
-    rt_sem_p(&sem_serverOk, TM_INFINITE);
-    cout << "Received message from monitor activated" << endl << flush;
+    while(1){
+        rt_sem_p(&sem_serverOk, TM_INFINITE);
+        cout << "Received message from monitor activated" << endl << flush;
+        while (1) {
+            msgRcv = monitor.Read();
+            cout << "Rcv <= " << msgRcv->ToString() << endl << flush;
 
-    while (1) {
-        msgRcv = monitor.Read();
-        cout << "Rcv <= " << msgRcv->ToString() << endl << flush;
-
-        if (msgRcv->CompareID(MESSAGE_MONITOR_LOST)) {
-            delete(msgRcv);
-            exit(-1);
-        } else if (msgRcv->CompareID(MESSAGE_ROBOT_COM_OPEN)) {
-            rt_sem_v(&sem_openComRobot);
-        } else if (msgRcv->CompareID(MESSAGE_ROBOT_START_WITHOUT_WD)) {
-            rt_sem_v(&sem_startRobot);
-        } else if (msgRcv->CompareID(MESSAGE_ROBOT_GO_FORWARD) ||
-                msgRcv->CompareID(MESSAGE_ROBOT_GO_BACKWARD) ||
-                msgRcv->CompareID(MESSAGE_ROBOT_GO_LEFT) ||
-                msgRcv->CompareID(MESSAGE_ROBOT_GO_RIGHT) ||
-                msgRcv->CompareID(MESSAGE_ROBOT_STOP)) {
-
-            rt_mutex_acquire(&mutex_move, TM_INFINITE);
-            move = msgRcv->GetID();
-            rt_mutex_release(&mutex_move);
+            if (msgRcv->CompareID(MESSAGE_MONITOR_LOST)) {
+                cout << "On est dans le message monitor lost" << endl << flush;
+
+                rt_mutex_acquire(&mutex_robot, TM_INFINITE);
+                int cpMove = MESSAGE_ROBOT_STOP;
+                robot.Write(new Message((MessageID)cpMove));
+                rt_mutex_release(&mutex_robot);
+                robot.Close();
+                monitor.Close();
+                rt_mutex_acquire(&mutex_move, TM_INFINITE);
+                move = MESSAGE_ROBOT_STOP;
+                rt_mutex_release(&mutex_move);
+                rt_mutex_acquire(&mutex_robotStarted, TM_INFINITE);
+                robotStarted = 0;
+                rt_mutex_release(&mutex_robotStarted);
+                rt_mutex_acquire(&mutex_watchdog, TM_INFINITE);
+                watchdog = 0;
+                rt_mutex_release(&mutex_watchdog);
+                //Close Camrera + etatCamera
+                /* if (err = rt_task_delete(&th_server)) {
+                    cerr << "Error task delete: " << strerror(-err) << endl << flush;
+                    //exit(EXIT_FAILURE);
+                } */
+                if (err = rt_task_create(&th_server, "th_server", 0, PRIORITY_TSERVER, 0)) {
+                    cerr << "Error task create: " << strerror(-err) << endl << flush;
+                    exit(EXIT_FAILURE);
+                } 
+                if (err = rt_task_start(&th_server, (void(*)(void*)) & Tasks::ServerTask, this)) {
+                    cerr << "Error task start: " << strerror(-err) << endl << flush;
+                    exit(EXIT_FAILURE);
+                }
+                rt_sem_v(&sem_barrier);
+                Kill_StartWD();
+                break;
+            } else if (msgRcv->CompareID(MESSAGE_ROBOT_COM_OPEN)) {
+                rt_sem_v(&sem_openComRobot);
+            } else if (msgRcv->CompareID(MESSAGE_ROBOT_START_WITHOUT_WD)) {
+                rt_sem_v(&sem_startRobot);
+            } else if (msgRcv->CompareID(MESSAGE_ROBOT_GO_FORWARD) ||
+                    msgRcv->CompareID(MESSAGE_ROBOT_GO_BACKWARD) ||
+                    msgRcv->CompareID(MESSAGE_ROBOT_GO_LEFT) ||
+                    msgRcv->CompareID(MESSAGE_ROBOT_GO_RIGHT) ||
+                    msgRcv->CompareID(MESSAGE_ROBOT_STOP)) {
+                rt_mutex_acquire(&mutex_move, TM_INFINITE);
+                move = msgRcv->GetID();
+                rt_mutex_release(&mutex_move);
+                cout << "On est dans le message mouvement" << endl << flush;
+            }
+            else if (msgRcv->CompareID(MESSAGE_ROBOT_START_WITH_WD)){
+                rt_mutex_acquire(&mutex_watchdog, TM_INFINITE);
+                watchdog = 1;
+                rt_mutex_release(&mutex_watchdog);
+                rt_sem_v(&sem_startRobot);
+                cout << "On a start le robot avec Watchdog" << endl << flush;
+            }
+            delete(msgRcv); // mus be deleted manually, no consumer
         }
-        delete(msgRcv); // mus be deleted manually, no consumer
     }
 }
 
  * @brief Thread starting the communication with the robot.
  */
 void Tasks::StartRobotTask(void *arg) {
+    int etatWD;
     cout << "Start " << __PRETTY_FUNCTION__ << endl << flush;
     // Synchronization barrier (waiting that all tasks are starting)
     rt_sem_p(&sem_barrier, TM_INFINITE);
     /* The task startRobot starts here                                                    */
     /**************************************************************************************/
     while (1) {
-
+        
         Message * msgSend;
         rt_sem_p(&sem_startRobot, TM_INFINITE);
-        cout << "Start robot without watchdog (";
+        cout << "Start robot (";
         rt_mutex_acquire(&mutex_robot, TM_INFINITE);
-        msgSend = robot.Write(robot.StartWithoutWD());
-        rt_mutex_release(&mutex_robot);
-        cout << msgSend->GetID();
-        cout << ")" << endl;
+        rt_mutex_acquire(&mutex_watchdog, TM_INFINITE);
+        etatWD = watchdog;
+        rt_mutex_release(&mutex_watchdog);
+        cout << "Watchdog = " << etatWD << endl << flush;
+        if (etatWD == 0){
+            cout << "Dans le if without WD" << etatWD << endl << flush;
+            msgSend = robot.Write(robot.StartWithoutWD());
+            rt_mutex_release(&mutex_robot);
+            cout << msgSend->GetID();
+            cout << ")" << endl;
 
-        cout << "Movement answer: " << msgSend->ToString() << endl << flush;
-        WriteInQueue(&q_messageToMon, msgSend);  // msgSend will be deleted by sendToMon
+            cout << "Movement answer: " << msgSend->ToString() << endl << flush;
+            WriteInQueue(&q_messageToMon, msgSend);  // msgSend will be deleted by sendToMon
 
-        if (msgSend->GetID() == MESSAGE_ANSWER_ACK) {
-            rt_mutex_acquire(&mutex_robotStarted, TM_INFINITE);
-            robotStarted = 1;
-            rt_mutex_release(&mutex_robotStarted);
+            if (msgSend->GetID() == MESSAGE_ANSWER_ACK) {
+                rt_mutex_acquire(&mutex_robotStarted, TM_INFINITE);
+                robotStarted = 1;
+                rt_mutex_release(&mutex_robotStarted);
+            }
+        }
+        else{
+            cout << "Dans le if with WD" << etatWD << endl << flush;
+            msgSend = robot.Write(robot.StartWithWD());
+            rt_mutex_release(&mutex_robot);
+            cout << msgSend->GetID();
+            cout << ")" << endl;
+
+            cout << "Movement answer: " << msgSend->ToString() << endl << flush;
+            WriteInQueue(&q_messageToMon, msgSend);  // msgSend will be deleted by sendToMon
+
+            if (msgSend->GetID() == MESSAGE_ANSWER_ACK) {
+                rt_mutex_acquire(&mutex_robotStarted, TM_INFINITE);
+                robotStarted = 1;
+                rt_mutex_release(&mutex_robotStarted);
+                rt_sem_v(&sem_startWD);
+            }
         }
     }
 }
     int rs;
     int cpMove;
     int previousMove = -1;
+    int cpt = 0;
+    
     
+    Message * response;
     cout << "Start " << __PRETTY_FUNCTION__ << endl << flush;
     // Synchronization barrier (waiting that all tasks are starting)
     rt_sem_p(&sem_barrier, TM_INFINITE);
                 cout << " move: " << cpMove;
 
                 rt_mutex_acquire(&mutex_robot, TM_INFINITE);
-                robot.Write(new Message((MessageID)cpMove));
+                response = robot.Write(new Message((MessageID)cpMove));
                 rt_mutex_release(&mutex_robot);
+                
+                if (response->CompareID(MESSAGE_ANSWER_ACK)){
+                    cpt = 0;
+                }
+                else{
+                    cpt++;
+                    if (cpt == 3){
+                        Message * respToMon = new Message(MESSAGE_ANSWER_COM_ERROR);
+                        WriteInQueue(&q_messageToMon,respToMon);
+                        rt_mutex_acquire(&mutex_robotStarted, TM_INFINITE);
+                        robotStarted = 0;
+                        rt_mutex_release(&mutex_robotStarted);
+                        rt_mutex_acquire(&mutex_watchdog, TM_INFINITE);
+                        watchdog = 0;
+                        rt_mutex_release(&mutex_watchdog);
+                        Kill_StartWD();
+                        cpt = 0;
+                    }
+                }
                 previousMove = cpMove;
             }
         }
 }
 
 /**
+ * @brief Kills and restart the thread watchdog
+ */
+void Tasks::Kill_StartWD(){
+    int err;
+    if (err = rt_task_delete(&th_watchdog)) {
+        cerr << "Error task delete: " << strerror(-err) << endl << flush;
+        exit(EXIT_FAILURE);
+    }
+    if (err = rt_task_create(&th_watchdog, "th_watchdog", 0, PRIORITY_TWATCHDOG, 0)) {
+        cerr << "Error task create: " << strerror(-err) << endl << flush;
+        exit(EXIT_FAILURE);
+    }
+    if (err = rt_task_start(&th_watchdog, (void(*)(void*)) & Tasks::ReloadWatchdogTask, this)) {
+        cerr << "Error task start: " << strerror(-err) << endl << flush;
+        exit(EXIT_FAILURE);
+    }
+    rt_sem_broadcast(&sem_barrier);
+}
+
+/**
  * Write a message in a given queue
  * @param queue Queue identifier
  * @param msg Message to be stored
     
     //We wait for the signal startWd
     rt_sem_p(&sem_startWD, TM_INFINITE);
-    
+    cout << "thread WD started" << endl << flush;
         /**************************************************************************************/
     /* The task starts here                                                               */
     /**************************************************************************************/
-    rt_task_set_periodic(NULL, TM_NOW, 50000000);
+    rt_task_set_periodic(NULL, TM_NOW, 1000000000);
     
     while(1){
         rt_task_wait_period(NULL);
             cout << "Periodic watchdog reload" << endl << flush;
             
             rt_mutex_acquire(&mutex_robot, TM_INFINITE);
-            responseBattery = robot.Write(new Message(MESSAGE_ROBOT_RELOAD_WD));
+            robot.Write(new Message(MESSAGE_ROBOT_RELOAD_WD));
             rt_mutex_release(&mutex_robot);
         }
     }

software/raspberry/superviseur-robot/tasks.h

         int cameraStarted = 0;
         int getImg = 0;
         int askArena = 0;
-        Arena arena = void;
+        Arena* arena = new Arena();
         int getPos = 0;
     };
     struct etatCamera_t etatCamera;
+    int watchdog = 0;
     
     /**********************************************************************/
     /* Tasks                                                              */
     */
    void ReloadWatchdogTask(void *arg);
    
+   /**
+    * @brief Kills and restart the thread watchdog
+    */
+    void Kill_StartWD();
+   
     /**********************************************************************/
     /* Queue services                                                     */
     /**********************************************************************/