Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
+#if defined(WIN32) && !defined(__CYGWIN__)
+#include <windows.h>
+#include "getopt.h"
+void pause(void)
+{
+ system("PAUSE");
+}
+#else
#include <stdio.h>
#include <string.h>
-#include <sys/time.h>
#include <unistd.h>
#include <stdlib.h>
#include <signal.h>
+#endif
-#include <applicfg.h>
-#include <can_driver.h>
-#include <timers_driver.h>
+#include "canfestival.h"
+//#include <can_driver.h>
+//#include <timers_driver.h>
#include "Master.h"
#include "Slave.h"
#include "TestMasterSlave.h"
-#define MyCase(fc) case fc: eprintf(#fc);break;
-void print_message(Message *m)
-{
- int i;
- switch(m->cob_id.w >> 7)
- {
- MyCase(SYNC)
- MyCase(TIME_STAMP)
- MyCase(PDO1tx)
- MyCase(PDO1rx)
- MyCase(PDO2tx)
- MyCase(PDO2rx)
- MyCase(PDO3tx)
- MyCase(PDO3rx)
- MyCase(PDO4tx)
- MyCase(PDO4rx)
- MyCase(SDOtx)
- MyCase(SDOrx)
- MyCase(NODE_GUARD)
- MyCase(NMT)
- }
- eprintf(" rtr:%d", m->rtr);
- eprintf(" len:%d", m->len);
- for (i = 0 ; i < m->len ; i++)
- eprintf(" %02x", m->data[i]);
- eprintf("\n");
-}
-
UNS32 OnMasterMap1Update(CO_Data* d, const indextable * unsused_indextable, UNS8 unsused_bSubindex)
{
eprintf("OnSlaveMap1Update:%d\n", SlaveMap1);
return 0;
}
+s_BOARD SlaveBoard = {"0", "125K"};
+s_BOARD MasterBoard = {"1", "125K"};
-
-void InitNodes(CO_Data* d, UNS32 id)
-{
-// TestSlave_Index2000_callbacks[0] = &OnMasterMap1Update;
- RegisterSetODentryCallBack(&TestMaster_Data, 0x2000, 0, &OnMasterMap1Update);
-
- /****************************** INITIALISATION MASTER *******************************/
- /* Defining the node Id */
- setNodeId(&TestMaster_Data, 0x01);
-
- /* init */
- setState(&TestMaster_Data, Initialisation);
-
- /****************************** INITIALISATION SLAVE *******************************/
- /* Defining the node Id */
- setNodeId(&TestSlave_Data, 0x02);
-
- /* init */
- setState(&TestSlave_Data, Initialisation);
-
- /****************************** START *******************************/
- /* Put the master in operational mode */
- setState(&TestMaster_Data, Operational);
-
- masterSendNMTstateChange (&TestMaster_Data, 0x02, NMT_Start_Node);
-
-}
-
-CAN_HANDLE SlaveCanHandle;
-CAN_HANDLE MasterCanHandle;
-
-// Baudrate values for Peak board :
-// CAN_BAUD_1M CAN_BAUD_500K CAN_BAUD_250K CAN_BAUD_125K CAN_BAUD_100K CAN_BAUD_50K
-// CAN_BAUD_20K CAN_BAUD_10K CAN_BAUD_5K
-
-#ifdef CAN_BAUD_500K
-// Appli have been compiled for Peak. Baudrate is defined
-# define BAUDRATE CAN_BAUD_500K
-#else
-// Appli have been compiled for Generic. Baudrate not used
-# define BAUDRATE 0
-#endif
-
+#if !defined(WIN32) || defined(__CYGWIN__)
void catch_signal(int sig)
{
signal(SIGTERM, catch_signal);
signal(SIGINT, catch_signal);
- stopTimer();
- eprintf("Got Sigterm - Finishing.\n");
+ eprintf("Got Signal %d\n",sig);
}
+#endif
-
-void help()
+void help(void)
{
printf("**************************************************************\n");
printf("* TestMasterSlave *\n");
printf("* *\n");
printf("* A simple example for PC. It does implement 2 CanOpen *\n");
printf("* nodes in the same process. A master and a slave. Both *\n");
- printf("* communicate together, exchanging periodically NMT, SYNC, *\n");
- printf("* SDO and PDO. *\n");
+ printf("* communicate together, exchanging periodically NMT, SYNC, *\n");
+ printf("* SDO and PDO. Master configure heartbeat producer time *\n");
+ printf("* at 1000 ms for slave node-id 0x02 by concise DCF. *\n");
+ printf("* *\n");
+ printf("* Usage: *\n");
+ printf("* ./TestMasterSlave [OPTIONS] *\n");
printf("* *\n");
- printf("* If you have chosen virtual CAN driver, just type *\n");
- printf("* ./TestMasterSlave *\n");
+ printf("* OPTIONS: *\n");
+ printf("* -l : Can library [\"libcanfestival_can_virtual.so\"] *\n");
printf("* *\n");
- printf("* Else you need to specify bus: *\n");
+ printf("* Slave: *\n");
+ printf("* -s : bus name [\"0\"] *\n");
+ printf("* -S : 1M,500K,250K,125K,100K,50K,20K,10K,none(disable) *\n");
printf("* *\n");
- printf("* -s : slave CAN bus [default 0, peak first PCI] *\n");
- printf("* -m : master CAN bus [default 1, peak second PCI] *\n");
+ printf("* Master: *\n");
+ printf("* -m : bus name [\"1\"] *\n");
+ printf("* -M : 1M,500K,250K,125K,100K,50K,20K,10K,none(disable) *\n");
printf("* *\n");
printf("**************************************************************\n");
}
+/*************************** INIT *****************************************/
+void InitNodes(CO_Data* d, UNS32 id)
+{
+ /****************************** INITIALISATION SLAVE *******************************/
+ if(strcmp(SlaveBoard.baudrate, "none")) {
+ setNodeId(&TestSlave_Data, 0x02);
+
+ /* init */
+ setState(&TestSlave_Data, Initialisation);
+ }
+
+ /****************************** INITIALISATION MASTER *******************************/
+ if(strcmp(MasterBoard.baudrate, "none")){
+ RegisterSetODentryCallBack(&TestMaster_Data, 0x2000, 0, &OnMasterMap1Update);
+
+ /* Defining the node Id */
+ setNodeId(&TestMaster_Data, 0x01);
+
+ /* init */
+ setState(&TestMaster_Data, Initialisation);
+
+ }
+}
+
+/*************************** EXIT *****************************************/
+void Exit(CO_Data* d, UNS32 id)
+{
+ masterSendNMTstateChange(&TestMaster_Data, 0x02, NMT_Reset_Node);
+
+ //Stop master
+ setState(&TestMaster_Data, Stopped);
+}
+
/****************************************************************************/
/*************************** MAIN *****************************************/
/****************************************************************************/
int main(int argc,char **argv)
{
- s_BOARD SlaveBoard = {"0", BAUDRATE, &TestSlave_Data};
- s_BOARD MasterBoard = {"1", BAUDRATE, &TestMaster_Data};
-
- char c;
+ int c;
extern char *optarg;
+ char* LibraryPath="../../drivers/can_virtual/libcanfestival_can_virtual.so";
- while ((c = getopt(argc, argv, "-m:s:")) != EOF)
+ while ((c = getopt(argc, argv, "-m:s:M:S:l:")) != EOF)
{
switch(c)
{
}
MasterBoard.busname = optarg;
break;
+ case 'S' :
+ if (optarg[0] == 0)
+ {
+ help();
+ exit(1);
+ }
+ SlaveBoard.baudrate = optarg;
+ break;
+ case 'M' :
+ if (optarg[0] == 0)
+ {
+ help();
+ exit(1);
+ }
+ MasterBoard.baudrate = optarg;
+ break;
+ case 'l' :
+ if (optarg[0] == 0)
+ {
+ help();
+ exit(1);
+ }
+ LibraryPath = optarg;
+ break;
default:
help();
exit(1);
}
}
- /* install signal handler for manual break */
+#if !defined(WIN32) || defined(__CYGWIN__)
+ /* install signal handler for manual break */
signal(SIGTERM, catch_signal);
signal(SIGINT, catch_signal);
-
+ TimerInit();
+#endif
+
+#ifndef NOT_USE_DYNAMIC_LOADING
+ if (LoadCanDriver(LibraryPath) == NULL)
+ printf("Unable to load library: %s\n",LibraryPath);
+#endif
// Open CAN devices
- SlaveCanHandle = canOpen(&SlaveBoard);
- MasterCanHandle = canOpen(&MasterBoard);
-
- // Will call InitNodes, and wait and handle next timer events.
- TimerLoop(&InitNodes);
-
- // Close CAN devices
- canClose(SlaveCanHandle);
- canClose(MasterCanHandle);
-
- return 0;
+ if(strcmp(SlaveBoard.baudrate, "none")){
+
+ TestSlave_Data.heartbeatError = TestSlave_heartbeatError;
+ TestSlave_Data.initialisation = TestSlave_initialisation;
+ TestSlave_Data.preOperational = TestSlave_preOperational;
+ TestSlave_Data.operational = TestSlave_operational;
+ TestSlave_Data.stopped = TestSlave_stopped;
+ TestSlave_Data.post_sync = TestSlave_post_sync;
+ TestSlave_Data.post_TPDO = TestSlave_post_TPDO;
+ TestSlave_Data.storeODSubIndex = TestSlave_storeODSubIndex;
+ TestSlave_Data.post_emcy = TestSlave_post_emcy;
+
+ if(!canOpen(&SlaveBoard,&TestSlave_Data)){
+ eprintf("Cannot open Slave Board (%s,%s)\n",SlaveBoard.busname, SlaveBoard.baudrate);
+ goto fail_slave;
+ }
+ }
+ if(strcmp(MasterBoard.baudrate, "none")){
+
+ TestMaster_Data.heartbeatError = TestMaster_heartbeatError;
+ TestMaster_Data.initialisation = TestMaster_initialisation;
+ TestMaster_Data.preOperational = TestMaster_preOperational;
+ TestMaster_Data.operational = TestMaster_operational;
+ TestMaster_Data.stopped = TestMaster_stopped;
+ TestMaster_Data.post_sync = TestMaster_post_sync;
+ TestMaster_Data.post_TPDO = TestMaster_post_TPDO;
+ TestMaster_Data.post_emcy = TestMaster_post_emcy;
+ TestMaster_Data.post_SlaveBootup=TestMaster_post_SlaveBootup;
+
+ if(!canOpen(&MasterBoard,&TestMaster_Data)){
+ eprintf("Cannot open Master Board (%s,%s)\n",MasterBoard.busname, MasterBoard.baudrate);
+ goto fail_master;
+ }
+ }
+
+ // Start timer thread
+ StartTimerLoop(&InitNodes);
+
+ // wait Ctrl-C
+ pause();
+
+ // Stop timer thread
+ StopTimerLoop(&Exit);
+
+ // Close CAN devices (and can threads)
+ if(strcmp(MasterBoard.baudrate, "none")) canClose(&TestMaster_Data);
+fail_master:
+ if(strcmp(SlaveBoard.baudrate, "none")) canClose(&TestSlave_Data);
+fail_slave:
+ TimerCleanup();
+ return 0;
}
projects / CanFestival-3.git / blobdiff