rlcanopendaemon.cpp File Reference

#include "rlcanopendaemon.h"

Include dependency graph for rlcanopendaemon.cpp:

Go to the source code of this file.

Functions
void	sdo_read (rlCanOpenDaemon *_daemonptr, rlSocket *_socket, IPCMSGSTRUCT *_message)
void	sdo_write (rlCanOpenDaemon *_daemonptr, rlSocket *_socket, IPCMSGSTRUCT *_message)
void	pdo_receive (rlCanOpenDaemon *_daemonptr, rlSocket *_socket, IPCMSGSTRUCT *_message)
void	pdo_transmit (rlCanOpenDaemon *_daemonptr, rlSocket *_socket, IPCMSGSTRUCT *_message)
void	nmt_transmit (rlCanOpenDaemon *_daemonptr, rlSocket *_socket, IPCMSGSTRUCT *_message)
void	restart_board (rlCanOpenDaemon *_daemonptr, rlSocket *_socket, IPCMSGSTRUCT *_message)
void	getNodeState (rlCanOpenDaemon *_daemonptr, rlSocket *_socket, IPCMSGSTRUCT *_message)
static void *	clientconnection (void *arg)
static void *	listenerthread (void *arg)

Function Documentation

clientconnection()

static void* clientconnection ( void *  arg )

static

handels a new client connection established by listener thread. Saves socket descriptor in new socket object. Runs a loop which reads IPCMSGSTRUCTs containing client requests and calls appropiate handler functions which communicate with the canopen device and send answers back to the client. clientconnection Thread is terminated when client disconnects.

Definition at line 172 of file rlcanopendaemon.cpp.

{
  //cout<<"\n client connection established...\n";
  
  rlCanOpenTypes cifmsg;
  THREAD_PARAM *p = (THREAD_PARAM *) arg;
  THREADTRANSFER *tr = (THREADTRANSFER*)p->user;
  IPCMSGSTRUCT message;
  int socketdescr = tr->socketdescr;
  rlCanOpenDaemon *daemonptr = tr->daemonptr;
  int ret;
  rlSocket socket(socketdescr);
  
  rlDebugPrintf("client connection established...\n");
  while(socket.isConnected())
  {
    ret = socket.read((void*) &message, sizeof(message));
    if(ret <= 0) break;
    if ((message.msgtype==MSG_SDO_READ)&&(message.transfertype==MSG_SEND)){
      sdo_read(daemonptr, &socket, &message);
    }
    if ((message.msgtype==MSG_SDO_WRITE)&&(message.transfertype==MSG_SEND)){
      sdo_write(daemonptr, &socket, &message);
    }
    if ((message.msgtype==MSG_PDO_RECEIVE)&&(message.transfertype==MSG_SEND)){
      pdo_receive(daemonptr, &socket, &message);
    }
    if ((message.msgtype==MSG_PDO_TRANSMIT)&&(message.transfertype==MSG_SEND)){
      pdo_transmit(daemonptr, &socket, &message);
    }
    if ((message.msgtype==MSG_NMT_TRANSMIT)&&(message.transfertype==MSG_SEND)){
      nmt_transmit(daemonptr, &socket, &message);
    }
    if ((message.msgtype==MSG_RESTART_BOARD)&&(message.transfertype==MSG_SEND)){
      restart_board(daemonptr, &socket, &message);
    }
    if ((message.msgtype==MSG_GET_NODE_STATE)&&(message.transfertype==MSG_SEND)){
      getNodeState(daemonptr, &socket, &message);
    }    
    
  }
  rlDebugPrintf("client disconnect...\n");
  //cout<<"\n client disconnect...\n";
  return NULL;
}

getNodeState()

void getNodeState	(	rlCanOpenDaemon *	_daemonptr,
		rlSocket *	_socket,
		IPCMSGSTRUCT *	_message
	)

gets called from clientconnection thread. performs a getNodeState command on the canopen interface. received data is stored in an IPCMSGSTRUCT and sent back to the clientprocess

Definition at line 149 of file rlcanopendaemon.cpp.

                                         {
  int returnvalue;
  rlCanOpenTypes cifmsg;
  cifmsg.getIpcMsg(*_message);
  _daemonptr->daemon_thread.lock();
    returnvalue=_daemonptr->nodes->getNodeState(_message->boardid,
                                                _message->nodeid, 
                                                cifmsg);
  _daemonptr->daemon_thread.unlock();
  *_message = cifmsg.createIpcMsg();
  _message->msgtype=MSG_GET_NODE_STATE; _message->transfertype=returnvalue;
  _socket->write((void*) _message, sizeof(*_message));   
}

listenerthread()

static void* listenerthread ( void *  arg )

static

listenerthread waits for incoming client connections on the confugured port and spawns a new clientthread for each of them.

Definition at line 221 of file rlcanopendaemon.cpp.

{
  
  // socketdescriptor;
  int socketdescr;
  // parameter struct for accessing function parameters
  THREAD_PARAM *p = (THREAD_PARAM *) arg;
  // new parameter struct for passing parameters to handler thread
  THREADTRANSFER tr;
  rlCanOpenDaemon *daemonptr = (rlCanOpenDaemon*) p->user;
  tr.daemonptr = daemonptr;
  int port = daemonptr->getPort();
  // wait for connections with accept();
  rlDebugPrintf("\n starting listener on port %d...\n", port);
  // initialize socket with daemonport
  rlSocket s("localhost",port,0);
  // listener main loop
  while(1){
    socketdescr = s.connect();
    if(socketdescr == -1) break;
    tr.socketdescr = socketdescr;
    daemonptr->daemon_thread.create(clientconnection, &tr);
    // wait for clientconnection to save socketdescriptor
    rlsleep(100); 
  }
  rlDebugPrintf("\n killing listener...\n");
  return NULL;
}

nmt_transmit()

void nmt_transmit	(	rlCanOpenDaemon *	_daemonptr,
		rlSocket *	_socket,
		IPCMSGSTRUCT *	_message
	)

gets called from clientconnection thread. performs a nmt_transmit command on the canopen interface. received data is stored in an IPCMSGSTRUCT and sent back to the clientprocess

Definition at line 118 of file rlcanopendaemon.cpp.

                                         {
  char returnvalue;
  _daemonptr->daemon_thread.lock();
    returnvalue=_daemonptr->nodes->sendNMTCommand(_message->boardid, 
                                                  _message->nodeid, 
                                                  _message->mtext[0]);
  _daemonptr->daemon_thread.unlock();
  _message->msgtype=MSG_PDO_TRANSMIT; _message->transfertype=returnvalue;
  _socket->write((void*) _message, sizeof(*_message));   
}

pdo_receive()

void pdo_receive	(	rlCanOpenDaemon *	_daemonptr,
		rlSocket *	_socket,
		IPCMSGSTRUCT *	_message
	)

gets called from clientconnection thread. performs a pdo_receive command on the canopen interface. received data is stored in an IPCMSGSTRUCT and sent back to the clientprocess

Definition at line 58 of file rlcanopendaemon.cpp.

                                        {
  int returnvalue;
  rlCanOpenTypes cifmsg;
  cifmsg.getIpcMsg(*_message);
  _daemonptr->daemon_thread.lock();
    if (_message->mappingid==-1){
      returnvalue=_daemonptr->nodes->pdo_receive(_message->boardid, 
                                                _message->nodeid, 
                                                _message->pdoid, 
                                                cifmsg);
    }
    else
    {
      returnvalue=_daemonptr->nodes->pdo_receive(_message->boardid, 
                                                _message->nodeid, 
                                                _message->pdoid, 
                                                _message->mappingid, 
                                                cifmsg);  
    }
  _daemonptr->daemon_thread.unlock();
  *_message = cifmsg.createIpcMsg();
  _message->msgtype=MSG_PDO_RECEIVE; _message->transfertype=returnvalue;
  _socket->write((void*) _message, sizeof(*_message));   
}

pdo_transmit()

void pdo_transmit	(	rlCanOpenDaemon *	_daemonptr,
		rlSocket *	_socket,
		IPCMSGSTRUCT *	_message
	)

gets called from clientconnection thread. performs a pdo_transmit command on the canopen interface. received data is stored in an IPCMSGSTRUCT and sent back to the clientprocess

Definition at line 88 of file rlcanopendaemon.cpp.

                                         {
  int returnvalue;
  rlCanOpenTypes cifmsg;
  cifmsg.getIpcMsg(*_message);
  _daemonptr->daemon_thread.lock();
    if (_message->mappingid==-1){
      returnvalue=_daemonptr->nodes->pdo_transmit(_message->boardid, 
                                                  _message->nodeid, 
                                                  _message->pdoid, 
                                                  cifmsg);
    }
    else
    {
      returnvalue=_daemonptr->nodes->pdo_transmit(_message->boardid, 
                                                  _message->nodeid, 
                                                  _message->pdoid, 
                                                  _message->mappingid, 
                                                  cifmsg);  
    }
  _daemonptr->daemon_thread.unlock();
  *_message = cifmsg.createIpcMsg();
  _message->msgtype=MSG_PDO_TRANSMIT; _message->transfertype=returnvalue;
  _socket->write((void*) _message, sizeof(*_message));   
}

restart_board()

void restart_board	(	rlCanOpenDaemon *	_daemonptr,
		rlSocket *	_socket,
		IPCMSGSTRUCT *	_message
	)

gets called from clientconnection thread. performs a restartBoard command on the canopen interface. received data is stored in an IPCMSGSTRUCT and sent back to the clientprocess

Definition at line 134 of file rlcanopendaemon.cpp.

                                          {
  char returnvalue;
  _daemonptr->daemon_thread.lock();
    returnvalue=_daemonptr->nodes->restartBoard(_message->boardid, 
                                                (int) _message->mtext[0]);
  _daemonptr->daemon_thread.unlock();
  _message->msgtype=MSG_PDO_TRANSMIT; _message->transfertype=returnvalue;
  _socket->write((void*) _message, sizeof(*_message));   
}

sdo_read()

void sdo_read	(	rlCanOpenDaemon *	_daemonptr,
		rlSocket *	_socket,
		IPCMSGSTRUCT *	_message
	)

gets called from clientconnection thread. performs a sdo_read command on the canopen interface. received data is stored in an IPCMSGSTRUCT and sent back to the clientprocess

Definition at line 21 of file rlcanopendaemon.cpp.

                                     {
  rlCanOpenTypes cifmsg;
  _daemonptr->daemon_thread.lock();
    _daemonptr->nodes->sdo_read(_message->boardid, 
                                _message->nodeid, 
                                _message->objectindex, 
                                _message->subindex, cifmsg);
  _daemonptr->daemon_thread.unlock();
  *_message = cifmsg.createIpcMsg();
  _message->msgtype=MSG_SDO_READ; _message->transfertype=MSG_RECEIVE;
  _socket->write((void*) _message, sizeof(*_message));
}

sdo_write()

void sdo_write	(	rlCanOpenDaemon *	_daemonptr,
		rlSocket *	_socket,
		IPCMSGSTRUCT *	_message
	)

gets called from clientconnection thread. performs a sdo_write command on the canopen interface. received data is stored in an IPCMSGSTRUCT and sent back to the clientprocess

Definition at line 39 of file rlcanopendaemon.cpp.

                                      {
  rlCanOpenTypes cifmsg;
  cifmsg.getIpcMsg(*_message);
  _daemonptr->daemon_thread.lock();
    _daemonptr->nodes->sdo_write(_message->boardid, 
                                 _message->nodeid, 
                                 _message->objectindex, 
                                 _message->subindex, cifmsg);
  _daemonptr->daemon_thread.unlock();
  *_message = cifmsg.createIpcMsg();
  _message->msgtype=MSG_SDO_WRITE; _message->transfertype=MSG_RECEIVE;
  _socket->write((void*) _message, sizeof(*_message));   
}