examples/TestMasterSlaveLSS/TestMasterSlaveLSS.c

   1 /*
   2 This file is part of CanFestival, a library implementing CanOpen Stack.
   3
   4 Copyright (C): Edouard TISSERANT and Francis DUPIN
   5
   6 See COPYING file for copyrights details.
   7
   8 This library is free software; you can redistribute it and/or
   9 modify it under the terms of the GNU Lesser General Public
  10 License as published by the Free Software Foundation; either
  11 version 2.1 of the License, or (at your option) any later version.
  12
  13 This library is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16 Lesser General Public License for more details.
  17
  18 You should have received a copy of the GNU Lesser General Public
  19 License along with this library; if not, write to the Free Software
  20 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21 */
  22
  23 #if defined(WIN32) && !defined(__CYGWIN__)
  24 #include <windows.h>
  25 #include "getopt.h"
  26 void pause(void)
  27 {
  28         system("PAUSE");
  29 }
  30 #else
  31 #include <stdio.h>
  32 #include <string.h>
  33 #include <unistd.h>
  34 #include <stdlib.h>
  35 #include <signal.h>
  36 #endif
  37
  38 #include "canfestival.h"
  39 //#include <can_driver.h>
  40 //#include <timers_driver.h>
  41
  42 #include "Master.h"
  43 #include "SlaveA.h"
  44 #include "SlaveB.h"
  45 #include "TestMasterSlaveLSS.h"
  46
  47 s_BOARD SlaveBoardA = {"0", "125K"};
  48 s_BOARD SlaveBoardB = {"1", "125K"};
  49 s_BOARD MasterBoard = {"2", "125K"};
  50
  51 #if !defined(WIN32) || defined(__CYGWIN__)
  52 void catch_signal(int sig)
  53 {
  54   signal(SIGTERM, catch_signal);
  55   signal(SIGINT, catch_signal);
  56   eprintf("Got Signal %d\n",sig);
  57 }
  58 #endif
  59
  60 void help(void)
  61 {
  62   printf("**************************************************************\n");
  63   printf("*  TestMasterSlaveLSS                                        *\n");
  64   printf("*                                                            *\n");
  65   printf("*  A LSS example for PC. It does implement 3 CanOpen         *\n");
  66   printf("*  nodes in the same process. A master and 2 slaves. All     *\n");
  67   printf("*  communicate together, exchanging periodically NMT, SYNC,  *\n");
  68   printf("*  SDO and PDO. Master configure heartbeat producer time     *\n");
  69   printf("*  at 1000 ms for the slaves by concise DCF.                 *\n");
  70   printf("*                                                            *\n");
  71   printf("*   Usage:                                                   *\n");
  72   printf("*   ./TestMasterSlaveLSS  [OPTIONS]                          *\n");
  73   printf("*                                                            *\n");
  74   printf("*   OPTIONS:                                                 *\n");
  75   printf("*     -l : Can library [\"libcanfestival_can_virtual.so\"]     *\n");
  76   printf("*                                                            *\n");
  77   printf("*    SlaveA:                                                 *\n");
  78   printf("*     -a : bus name [\"0\"]                                    *\n");
  79   printf("*     -A : 1M,500K,250K,125K,100K,50K,20K,10K,none(disable)  *\n");
  80   printf("*                                                            *\n");
  81   printf("*    SlaveB:                                                 *\n");
  82   printf("*     -b : bus name [\"1\"]                                    *\n");
  83   printf("*     -B : 1M,500K,250K,125K,100K,50K,20K,10K,none(disable)  *\n");
  84   printf("*                                                            *\n");
  85   printf("*    Master:                                                 *\n");
  86   printf("*     -m : bus name [\"2\"]                                    *\n");
  87   printf("*     -M : 1M,500K,250K,125K,100K,50K,20K,10K,none(disable)  *\n");
  88   printf("*                                                            *\n");
  89   printf("**************************************************************\n");
  90 }
  91
  92 /***************************  INIT  *****************************************/
  93 void InitNodes(CO_Data* d, UNS32 id)
  94 {
  95         /****************************** INITIALISATION SLAVE_A *******************************/
  96         if(strcmp(SlaveBoardA.baudrate, "none")) {
  97                 /* Set an invalid nodeID */
  98                 setNodeId(&TestSlaveA_Data, 0xFF);
  99
 100                 /* init */
 101                 setState(&TestSlaveA_Data, Initialisation);
 102         }
 103
 104         /****************************** INITIALISATION SLAVE_B *******************************/
 105         if(strcmp(SlaveBoardB.baudrate, "none")) {
 106
 107                 /* Set an invalid nodeID */
 108                 setNodeId(&TestSlaveB_Data, 0xFF);
 109
 110                 /* init */
 111                 setState(&TestSlaveB_Data, Initialisation);
 112         }
 113
 114         /****************************** INITIALISATION MASTER *******************************/
 115         if(strcmp(MasterBoard.baudrate, "none")){
 116
 117                 /* Defining the node Id */
 118                 setNodeId(&TestMaster_Data, 0x01);
 119
 120                 /* init */
 121                 setState(&TestMaster_Data, Initialisation);
 122         }
 123 }
 124
 125 /***************************  EXIT  *****************************************/
 126 void Exit(CO_Data* d, UNS32 id)
 127 {
 128         if(strcmp(MasterBoard.baudrate, "none")){
 129         eprintf("Finishing.\n");
 130         masterSendNMTstateChange (&TestMaster_Data, 0x00, NMT_Stop_Node);
 131
 132         eprintf("reset\n");
 133
 134         // Stop master
 135         setState(&TestMaster_Data, Stopped);
 136         }
 137 }
 138
 139 /****************************************************************************/
 140 /***************************  MAIN  *****************************************/
 141 /****************************************************************************/
 142 int main(int argc,char **argv)
 143 {
 144
 145   int c;
 146   extern char *optarg;
 147   char* LibraryPath="../../drivers/can_virtual/libcanfestival_can_virtual.so";
 148
 149   while ((c = getopt(argc, argv, "-m:a:b:M:A:B:l:")) != EOF)
 150   {
 151     switch(c)
 152     {
 153       case 'a' :
 154         if (optarg[0] == 0)
 155         {
 156           help();
 157           exit(1);
 158         }
 159         SlaveBoardA.busname = optarg;
 160         break;
 161       case 'b' :
 162         if (optarg[0] == 0)
 163         {
 164           help();
 165           exit(1);
 166         }
 167         SlaveBoardB.busname = optarg;
 168         break;
 169       case 'm' :
 170         if (optarg[0] == 0)
 171         {
 172           help();
 173           exit(1);
 174         }
 175         MasterBoard.busname = optarg;
 176         break;
 177       case 'A' :
 178         if (optarg[0] == 0)
 179         {
 180           help();
 181           exit(1);
 182         }
 183         SlaveBoardA.baudrate = optarg;
 184         break;
 185       case 'B' :
 186         if (optarg[0] == 0)
 187         {
 188           help();
 189           exit(1);
 190         }
 191         SlaveBoardB.baudrate = optarg;
 192         break;
 193       case 'M' :
 194         if (optarg[0] == 0)
 195         {
 196           help();
 197           exit(1);
 198         }
 199         MasterBoard.baudrate = optarg;
 200         break;
 201       case 'l' :
 202         if (optarg[0] == 0)
 203         {
 204           help();
 205           exit(1);
 206         }
 207         LibraryPath = optarg;
 208         break;
 209       default:
 210         help();
 211         exit(1);
 212     }
 213   }
 214
 215 #if !defined(WIN32) || defined(__CYGWIN__)
 216   /* install signal handler for manual break */
 217         signal(SIGTERM, catch_signal);
 218         signal(SIGINT, catch_signal);
 219         TimerInit();
 220 #endif
 221
 222 #ifndef NOT_USE_DYNAMIC_LOADING
 223         if (LoadCanDriver(LibraryPath) == NULL)
 224             printf("Unable to load library: %s\n",LibraryPath);
 225 #endif
 226         // Open CAN devices
 227
 228         if(strcmp(SlaveBoardA.baudrate, "none")){
 229
 230                 TestSlaveA_Data.heartbeatError = TestSlaveA_heartbeatError;
 231                 TestSlaveA_Data.initialisation = TestSlaveA_initialisation;
 232                 TestSlaveA_Data.preOperational = TestSlaveA_preOperational;
 233                 TestSlaveA_Data.operational = TestSlaveA_operational;
 234                 TestSlaveA_Data.stopped = TestSlaveA_stopped;
 235                 TestSlaveA_Data.post_sync = TestSlaveA_post_sync;
 236                 TestSlaveA_Data.post_TPDO = TestSlaveA_post_TPDO;
 237                 TestSlaveA_Data.storeODSubIndex = TestSlaveA_storeODSubIndex;
 238                 TestSlaveA_Data.post_emcy = TestSlaveA_post_emcy;
 239                 /* in this example the slave doesn't implement NMT_Slave_Communications_Reset_Callback */
 240                 //TestSlaveA_Data.NMT_Slave_Communications_Reset_Callback = TestSlaveA_NMT_Slave_Communications_Reset_Callback;
 241                 TestSlaveA_Data.lss_StoreConfiguration = TestSlaveA_StoreConfiguration;
 242
 243                 if(!canOpen(&SlaveBoardA,&TestSlaveA_Data)){
 244                         eprintf("Cannot open SlaveA Board (%s,%s)\n",SlaveBoardA.busname, SlaveBoardA.baudrate);
 245                         goto fail_slaveA;
 246                 }
 247         }
 248
 249         if(strcmp(SlaveBoardB.baudrate, "none")){
 250
 251                 TestSlaveB_Data.heartbeatError = TestSlaveB_heartbeatError;
 252                 TestSlaveB_Data.initialisation = TestSlaveB_initialisation;
 253                 TestSlaveB_Data.preOperational = TestSlaveB_preOperational;
 254                 TestSlaveB_Data.operational = TestSlaveB_operational;
 255                 TestSlaveB_Data.stopped = TestSlaveB_stopped;
 256                 TestSlaveB_Data.post_sync = TestSlaveB_post_sync;
 257                 TestSlaveB_Data.post_TPDO = TestSlaveB_post_TPDO;
 258                 TestSlaveB_Data.storeODSubIndex = TestSlaveB_storeODSubIndex;
 259                 TestSlaveB_Data.post_emcy = TestSlaveB_post_emcy;
 260                 TestSlaveB_Data.NMT_Slave_Communications_Reset_Callback = TestSlaveB_NMT_Slave_Communications_Reset_Callback;
 261                 TestSlaveB_Data.lss_StoreConfiguration = TestSlaveB_StoreConfiguration;
 262
 263                 if(!canOpen(&SlaveBoardB,&TestSlaveB_Data)){
 264                         eprintf("Cannot open SlaveB Board (%s,%s)\n",SlaveBoardB.busname, SlaveBoardB.baudrate);
 265                         goto fail_slaveB;
 266                 }
 267         }
 268
 269         if(strcmp(MasterBoard.baudrate, "none")){
 270
 271                 TestMaster_Data.heartbeatError = TestMaster_heartbeatError;
 272                 TestMaster_Data.initialisation = TestMaster_initialisation;
 273                 TestMaster_Data.preOperational = TestMaster_preOperational;
 274                 TestMaster_Data.operational = TestMaster_operational;
 275                 TestMaster_Data.stopped = TestMaster_stopped;
 276                 TestMaster_Data.post_sync = TestMaster_post_sync;
 277                 TestMaster_Data.post_TPDO = TestMaster_post_TPDO;
 278                 TestMaster_Data.post_emcy = TestMaster_post_emcy;
 279                 TestMaster_Data.post_SlaveBootup=TestMaster_post_SlaveBootup;
 280
 281                 if(!canOpen(&MasterBoard,&TestMaster_Data)){
 282                         eprintf("Cannot open Master Board (%s,%s)\n",MasterBoard.busname, MasterBoard.baudrate);
 283                         goto fail_master;
 284                 }
 285         }
 286
 287         // Start timer thread
 288         StartTimerLoop(&InitNodes);
 289
 290         // wait Ctrl-C
 291
 292         pause();
 293
 294         // Stop timer thread
 295         StopTimerLoop(&Exit);
 296
 297         // Close CAN devices (and can threads)
 298         if(strcmp(MasterBoard.baudrate, "none")) canClose(&TestMaster_Data);
 299 fail_master:
 300         if(strcmp(SlaveBoardB.baudrate, "none")) canClose(&TestSlaveB_Data);
 301 fail_slaveB:
 302         if(strcmp(SlaveBoardA.baudrate, "none")) canClose(&TestSlaveA_Data);
 303 fail_slaveA:
 304         TimerCleanup();
 305         return 0;
 306 }