examples/TestMasterSlave/TestMasterSlave.c
changeset 149 fe50ada8020b
parent 145 e747d2e26af0
child 156 515d11cb496e
equal deleted inserted replaced
148:ad3de8730172 149:fe50ada8020b
    76 {
    76 {
    77 	eprintf("OnSlaveMap1Update:%d\n", SlaveMap1);
    77 	eprintf("OnSlaveMap1Update:%d\n", SlaveMap1);
    78 	return 0;
    78 	return 0;
    79 }
    79 }
    80 
    80 
    81 CAN_PORT SlaveCanHandle;
       
    82 CAN_PORT MasterCanHandle;
       
    83 
       
    84 s_BOARD SlaveBoard = {"0", "500K"};
    81 s_BOARD SlaveBoard = {"0", "500K"};
    85 s_BOARD MasterBoard = {"1", "500K"};
    82 s_BOARD MasterBoard = {"1", "500K"};
    86 
    83 
    87 #if !defined(WIN32) || defined(__CYGWIN__)
    84 #if !defined(WIN32) || defined(__CYGWIN__)
    88 void catch_signal(int sig)
    85 void catch_signal(int sig)
   219 #ifndef NOT_USE_DYNAMIC_LOADING
   216 #ifndef NOT_USE_DYNAMIC_LOADING
   220 	LoadCanDriver(LibraryPath);
   217 	LoadCanDriver(LibraryPath);
   221 #endif		
   218 #endif		
   222 	// Open CAN devices
   219 	// Open CAN devices
   223 	if(SlaveBoard.baudrate){
   220 	if(SlaveBoard.baudrate){
   224 		SlaveCanHandle = canOpen(&SlaveBoard,&TestSlave_Data);
   221 		
   225 		if(SlaveCanHandle == NULL){
   222 		TestSlave_Data.heartbeatError = TestSlave_heartbeatError;
       
   223 		TestSlave_Data.SDOtimeoutError = TestSlave_SDOtimeoutError;
       
   224 		TestSlave_Data.initialisation = TestSlave_initialisation;
       
   225 		TestSlave_Data.preOperational = TestSlave_preOperational;
       
   226 		TestSlave_Data.operational = TestSlave_operational;
       
   227 		TestSlave_Data.stopped = TestSlave_stopped;
       
   228 		TestSlave_Data.post_sync = TestSlave_post_sync;
       
   229 		TestSlave_Data.post_TPDO = TestSlave_post_TPDO;
       
   230 
       
   231 		if(!canOpen(&SlaveBoard,&TestSlave_Data)){
   226 			eprintf("Cannot open Slave Board (%s,%s)\n",SlaveBoard.busname, SlaveBoard.baudrate);
   232 			eprintf("Cannot open Slave Board (%s,%s)\n",SlaveBoard.busname, SlaveBoard.baudrate);
   227 			goto fail_slave;
   233 			goto fail_slave;
   228 		}
   234 		}
   229 	}
   235 	}
   230 
   236 
   231 	if(MasterBoard.baudrate){
   237 	if(MasterBoard.baudrate){
   232 		MasterCanHandle = canOpen(&MasterBoard,&TestMaster_Data);
   238 		
   233 		if(MasterCanHandle == NULL){
   239 		TestMaster_Data.heartbeatError = TestMaster_heartbeatError;
       
   240 		TestMaster_Data.SDOtimeoutError = TestMaster_SDOtimeoutError;
       
   241 		TestMaster_Data.initialisation = TestMaster_initialisation;
       
   242 		TestMaster_Data.preOperational = TestMaster_preOperational;
       
   243 		TestMaster_Data.operational = TestMaster_operational;
       
   244 		TestMaster_Data.stopped = TestMaster_stopped;
       
   245 		TestMaster_Data.post_sync = TestMaster_post_sync;
       
   246 		TestMaster_Data.post_TPDO = TestMaster_post_TPDO;
       
   247 		
       
   248 		if(!canOpen(&MasterBoard,&TestMaster_Data)){
   234 			eprintf("Cannot open Master Board (%s,%s)\n",SlaveBoard.busname, SlaveBoard.baudrate);
   249 			eprintf("Cannot open Master Board (%s,%s)\n",SlaveBoard.busname, SlaveBoard.baudrate);
   235 			goto fail_master;
   250 			goto fail_master;
   236 		}
   251 		}
   237 	}
   252 	}
   238 	
   253 	
   245 	
   260 	
   246 	// Stop timer thread
   261 	// Stop timer thread
   247 	StopTimerLoop();
   262 	StopTimerLoop();
   248 	
   263 	
   249 	// Close CAN devices (and can threads)
   264 	// Close CAN devices (and can threads)
   250 	if(SlaveBoard.baudrate) canClose(SlaveCanHandle);
   265 	if(SlaveBoard.baudrate) canClose(&TestSlave_Data);
   251 fail_master:
   266 fail_master:
   252 	if(MasterBoard.baudrate) canClose(MasterCanHandle);	
   267 	if(MasterBoard.baudrate) canClose(&TestMaster_Data);	
   253 fail_slave:
   268 fail_slave:
   254 	
   269 	
   255 
   270 
   256   return 0;
   271   return 0;
   257 }
   272 }