rllib  1
 All Classes Files Functions Variables Typedefs Enumerations Enumerator Macros
Functions
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

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";
THREAD_PARAM *p = (THREAD_PARAM *) arg;
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;
}
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;
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));
}
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
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;
// wait for clientconnection to save socketdescriptor
rlsleep(100);
}
rlDebugPrintf("\n killing listener...\n");
return NULL;
}
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));
}
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;
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));
}
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;
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));
}
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));
}
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.

{
_daemonptr->daemon_thread.lock();
_daemonptr->nodes->sdo_read(_message->boardid,
_message->nodeid,
_message->objectindex,
_message->subindex, cifmsg);
_daemonptr->daemon_thread.unlock();
*_message = cifmsg.createIpcMsg();
_socket->write((void*) _message, sizeof(*_message));
}
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.

{
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();
_socket->write((void*) _message, sizeof(*_message));
}