Esempio n. 1
0
int NodeInit(int NodeID, int NodeType)
{
	if(NodeType)
		CANOpenShellOD_Data = &CANOpenShellMasterOD_Data;
	else
		CANOpenShellOD_Data = &CANOpenShellSlaveOD_Data;

	/* Load can library */
	LoadCanDriver(LibraryPath);

	/* Define callback functions */
	CANOpenShellOD_Data->initialisation = CANOpenShellOD_initialisation;
	CANOpenShellOD_Data->preOperational = CANOpenShellOD_preOperational;
	CANOpenShellOD_Data->operational = CANOpenShellOD_operational;
	CANOpenShellOD_Data->stopped = CANOpenShellOD_stopped;
	CANOpenShellOD_Data->post_sync = CANOpenShellOD_post_sync;
	CANOpenShellOD_Data->post_TPDO = CANOpenShellOD_post_TPDO;
	CANOpenShellOD_Data->post_SlaveBootup=CANOpenShellOD_post_SlaveBootup;

	/* Open the Peak CANOpen device */
	if(!canOpen(&Board,CANOpenShellOD_Data)) return INIT_ERR;

	/* Defining the node Id */
	setNodeId(CANOpenShellOD_Data, NodeID);
	/* Start Timer thread */
	StartTimerLoop(&Init);
	return 0;
}
Esempio n. 2
0
bool QCan::init()
{
    if (!LoadCanDriver("/usr/local/lib/libcanfestival_can_vscom.so"))
        return false;

    TimerInit();
    StartTimerLoop(Init);

    s_BOARD Board = {(char*)"/dev/ttyUSB0", (char*)"125K"};
    mPort = canOpen(&Board, mData);
    if(!mPort)
        return false;

    setState(mData, Initialisation);
    masterSendNMTstateChange(mData, 0, NMT_Reset_Node);

    return true;
}
Esempio n. 3
0
//****************************************************************************
//***************************  MAIN  *****************************************
//****************************************************************************
int
main_can (s_BOARD SlaveBoard, char *LibraryPath)
{
#if !defined(WIN32) && !defined(__CYGWIN__)
	//TimerInit();
#endif	
	TimerInit();
	printf ("Bus name: %s        Freq: %s       Driver: %s\n",
	  SlaveBoard.busname, SlaveBoard.baudrate, LibraryPath);

#ifndef NOT_USE_DYNAMIC_LOADING
  if (LoadCanDriver (LibraryPath) == NULL)
    *textLog << wxT ("Unable to load library\n");
#endif
  // Open CAN devices

  ObjDict_Data.heartbeatError = Call_heartbeatError;
  ObjDict_Data.initialisation = Call_initialisation;
  ObjDict_Data.preOperational = Call_preOperational;
  ObjDict_Data.operational = Call_operational;
  ObjDict_Data.stopped = Call_stopped;
  ObjDict_Data.post_sync = Call_post_sync;
  ObjDict_Data.post_TPDO = Call_post_TPDO;
  ObjDict_Data.storeODSubIndex = Call_storeODSubIndex;

  if (!canOpen (&SlaveBoard, &ObjDict_Data))
    {
      printf ("Cannot open Slave Board (%s,%s)\n", SlaveBoard.busname,
	      SlaveBoard.baudrate);
      return (1);
    }

  StartTimerLoop (&InitNodes);

  return 0;
}
Esempio n. 4
0
int main(int argc,char **argv)
{

  int c;
  extern char *optarg;
  char* LibraryPath="libcanfestival_can_virtual.so";
  char *snodeid;
  while ((c = getopt(argc, argv, "-m:s:M:S:l:i:")) != EOF)
  {
    switch(c)
    {
      case 'm' :
        if (optarg[0] == 0)
        {
          help();
          exit(1);
        }
        MasterBoard.busname = 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;
      case 'i' :
        if (optarg[0] == 0)
        {
          help();
          exit(1);
        }
        snodeid = optarg;
		sscanf(snodeid,"%x",&slavenodeid);
        break;
      default:
        help();
        exit(1);
    }
  }

#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
	LoadCanDriver(LibraryPath);
#endif		

	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;
	
	if(!canOpen(&MasterBoard,&TestMaster_Data)){
		eprintf("Cannot open Master Board\n");
		goto fail_master;
	}
	
	// Start timer thread
	StartTimerLoop(&InitNodes);

	// wait Ctrl-C
	pause();
	eprintf("Finishing.\n");
	
	// Reset the slave node for next use (will stop emitting heartbeat)
	masterSendNMTstateChange (&TestMaster_Data, slavenodeid, NMT_Reset_Node);
	
	// Stop master
	setState(&TestMaster_Data, Stopped);
	
	// Stop timer thread
	StopTimerLoop(&Exit);
	
fail_master:
	if(MasterBoard.baudrate) canClose(&TestMaster_Data);	

	TimerCleanup();
  	return 0;
}
Esempio n. 5
0
int main()
{
  LIB_HANDLE driver;

  /* handles for additional CO-PCICAN functions */
  int (*get_fd_of_port)( CAN_PORT port );
  int (*co_pcican_enter_run_mode)( const int fd );
  int (*co_pcican_enter_config_mode)( const int fd );
  int (*co_pcican_select_channel)( const unsigned char channel, const unsigned int direction );
  int (*co_pcican_configure_selected_channel)( const int fd, s_BOARD *board, const unsigned int direction );

  s_BOARD  bd;
  CO_Data  myData;
  CAN_PORT port;
  Message myMessage;
  const char busname[]  = "/dev/co_pcican-0";
  const char baudrate[] = "1M";
  int fd;

  memset( &myData, 0x00, sizeof(CO_Data) );
  myData.CurrentCommunicationState.csSYNC = 1;
  myData.post_sync = mySyncHandler;
  bd.busname  = (char*)busname;
  bd.baudrate = (char*)baudrate;

  printf( "This example sends three SYNCs from port#%u to port#%u with a CO-PCICAN card\n", CHTX, CHRX );

  driver = LoadCanDriver( "/usr/local/lib/libcanfestival_can_copcican_linux.so" );

  if( driver == NULL )
  {
    /* something strange happenend */
    return 0;
  }

  /* dynamic load of additional library functions */
  get_fd_of_port = dlsym( driver, "get_fd_of_port" );
  co_pcican_enter_run_mode = dlsym( driver, "co_pcican_enter_run_mode" );
  co_pcican_enter_config_mode = dlsym( driver, "co_pcican_enter_config_mode" );
  co_pcican_select_channel = dlsym( driver, "co_pcican_select_channel" );
  co_pcican_configure_selected_channel = dlsym( driver, "co_pcican_configure_selected_channel" );

  /* direction: 0=RX, 1=TX */
  co_pcican_select_channel( CHRX, 0 );
  co_pcican_select_channel( CHTX, 1 );

  port = canOpen( &bd, &myData );

  if( port == NULL )
  {
    UnLoadCanDriver( driver );

    /* something strange happenend */
    return 0;
  }

  /* get file descriptor to control the opened device */
  fd = get_fd_of_port( port );

  co_pcican_enter_config_mode( fd );
  co_pcican_configure_selected_channel( fd, &bd, 0 );
  co_pcican_configure_selected_channel( fd, &bd, 1 );
  co_pcican_enter_run_mode( fd );

  memset( &myMessage, 0x00, sizeof(Message) );
  myMessage.cob_id = 0x80; /* SYNC message */
  myMessage.len = 1;
  myMessage.data[0] = 0xA5;

  /* SEND HERE */
  canSend( port, &myMessage );

  myMessage.data[0] = 0x5A;
  canSend( port, &myMessage );

  myMessage.data[0] = 0xA5;
  canSend( port, &myMessage );

  /* mySyncHandler() is called by the receive thread and shows a received SYNC message on console */
  usleep( 1*1000*1000 ); /* 1s */

  canClose( &myData );

  UnLoadCanDriver( driver );

  return 0;
}
Esempio n. 6
0
int main(int argc, char *argv[])
  {
   UNS8 node_id = 0;
   s_BOARD MasterBoard = {"1", "125K"};
   char* dll_file_name;

   /* process command line arguments */
   if (argc < 2)
      {
      printf("USAGE: win32test <node_id> [can driver dll filename [baud rate]]\n");
      return 1;
      }

   node_id = atoi(argv[1]);
   if (node_id < 2 || node_id > 127)
      {
      printf("ERROR: node_id shoule be >=2 and <= 127\n");
      return 1;
      }

   if (argc > 2)
      dll_file_name = argv[2];
   else
      dll_file_name = "can_uvccm_win32.dll";

   if (argc > 3)
      MasterBoard.baudrate = argv[3];

   // load can driver
   if (!LoadCanDriver(dll_file_name))
      {
      printf("ERROR: could not load diver %s\n", dll_file_name);
      return 1;
      }
   
   if (canOpen(&MasterBoard,&win32test_Data))
      {
      /* Defining the node Id */
      setNodeId(&win32test_Data, 0x01);

      /* init */
      setState(&win32test_Data, Initialisation);

      /****************************** START *******************************/
      /* Put the master in operational mode */
      setState(&win32test_Data, Operational);

      /* Ask slave node to go in operational mode */
      masterSendNMTstateChange (&win32test_Data, 0, NMT_Start_Node);

      printf("\nStarting node %d (%xh) ...\n",(int)node_id,(int)node_id);
      
      /* wait untill mode will switch to operational state*/
      if (GetChangeStateResults(node_id, Operational, 3000) != 0xFF)
         {
         /* modify Client SDO 1 Parameter */
         UNS32 COB_ID_Client_to_Server_Transmit_SDO = 0x600 + node_id;
         UNS32 COB_ID_Server_to_Client_Receive_SDO  = 0x580 + node_id;
         UNS32 Node_ID_of_the_SDO_Server = node_id;
         UNS8 ExpectedSize = sizeof (UNS32);

         if (OD_SUCCESSFUL ==  writeLocalDict(&win32test_Data, 0x1280, 1, &COB_ID_Client_to_Server_Transmit_SDO, &ExpectedSize, RW) 
              && OD_SUCCESSFUL ==  writeLocalDict(&win32test_Data, 0x1280, 2, &COB_ID_Server_to_Client_Receive_SDO, &ExpectedSize, RW) 
              && OD_SUCCESSFUL ==  writeLocalDict(&win32test_Data, 0x1280, 3, &Node_ID_of_the_SDO_Server, &ExpectedSize, RW))
            {
            UNS32 dev_type = 0;
            char device_name[64]="";
            char hw_ver[64]="";
            char sw_ver[64]="";   
            UNS32 vendor_id = 0;            
            UNS32 prod_code = 0;
            UNS32 ser_num = 0;
            UNS8 size;
            UNS8 res;

            printf("\nnode_id: %d (%xh) info\n",(int)node_id,(int)node_id);
            printf("********************************************\n");

            size = sizeof (dev_type);
            res = ReadSDO(node_id, 0x1000, 0, uint32, &dev_type, &size);
            printf("device type: %d\n",dev_type & 0xFFFF);
           
            size = sizeof (device_name);
            res = ReadSDO(node_id, 0x1008, 0, visible_string, device_name, &size);
            printf("device name: %s\n",device_name);

            size = sizeof (hw_ver);
            res = ReadSDO(node_id, 0x1009, 0, visible_string, hw_ver, &size);
            printf("HW version: %s\n",hw_ver);

            size = sizeof (sw_ver);
            res = ReadSDO(node_id, 0x100A, 0, visible_string, sw_ver, &size);
            printf("SW version: %s\n",sw_ver);            
            
            size = sizeof (vendor_id);
            res = ReadSDO(node_id, 0x1018, 1, uint32, &vendor_id, &size);
            printf("vendor id: %d\n",vendor_id);

            size = sizeof (prod_code);
            res = ReadSDO(node_id, 0x1018, 2, uint32, &prod_code, &size);
            printf("product code: %d\n",prod_code);

            size = sizeof (ser_num);
            res = ReadSDO(node_id, 0x1018, 4, uint32, &ser_num, &size);
            printf("serial number: %d\n",ser_num);
            
            printf("********************************************\n");
            } 
         else
            {
            printf("ERROR: Object dictionary access failed\n");
            }
         }
      else
         {
         printf("ERROR: node_id %d (%xh) is not responding\n",(int)node_id,(int)node_id);
         }
         
      masterSendNMTstateChange (&win32test_Data, 0x02, NMT_Stop_Node);

      setState(&win32test_Data, Stopped);
      
      canClose(&win32test_Data);
      }
   return 0;
  }
Esempio n. 7
0
int main(int argc,char **argv)
{
	struct sigaction act;
	uint8_t nodeid = 2;

    // register handler on SIGINT signal 
    act.sa_handler=sortie;
    sigemptyset(&act.sa_mask);
    act.sa_flags=0;
    sigaction(SIGINT,&act,0);

    // Check that we have the right command line parameters
    if(argc != 3){
        display_usage(argv[0]);
        exit(1);
    }

    // get command line parameters
    nodeid = strtoul(argv[2], NULL, 10);
    SlaveBoard0.busname = argv[1];
    printf("Starting on %s with node id = %u\n", SlaveBoard0.busname, nodeid);

    // register the callbacks we use
    RegisterSetODentryCallBack(&slavedic_Data, 0x2001, 0, callback_on_position);
    slavedic_Data.initialisation=state_change;
    slavedic_Data.preOperational=state_change;
    slavedic_Data.operational=state_change;
    slavedic_Data.stopped=state_change;

	// Init Canfestival
	if (LoadCanDriver("./libcanfestival_can_socket.so") == NULL){
	    printf("Unable to load driver library\n");
        printf("please put file libcanfestival_can_socket.so in the current directory\n");
        exit(1);
    }
	if(!canOpen(&SlaveBoard0,&slavedic_Data)){
		printf("Cannot open can interface %s\n",SlaveBoard0.busname);
		exit(1);
	}

    TimerInit();
	setNodeId(&slavedic_Data, nodeid);
	setState(&slavedic_Data, Initialisation);

    printf("Canfestival initialisation done\n");
	Run = 1;
	while(Run)
	{
        sleep(1);
        EnterMutex();
        counter += nodeid;
        LeaveMutex();
	}

	// Stop timer thread
	StopTimerLoop(&Exit);
	// Close CAN devices (and can threads)
	canClose(&slavedic_Data);
	return 0;

}