rlcanopendaemon.cpp

Go to the documentation of this file.

/***************************************************************************
                          rlcanopen.cpp  -  description
                             -------------------
    begin     : Tue March 03 2004
    copyright : (C) 2004 by Marc Br�tigam, Christian Wilmes, Rainer Lehrig
    email     : lehrig@t-online.de
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This library is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU LESSER GENERAL PUBLIC LICENSE as        *
 *   published by the Free Software Foundation                             *
 *                                                                         *
 ***************************************************************************/
#include "rlcanopendaemon.h"

void sdo_read(rlCanOpenDaemon *_daemonptr, 
              rlSocket* _socket, 
              IPCMSGSTRUCT* _message){
  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));
}

void sdo_write(rlCanOpenDaemon *_daemonptr, 
               rlSocket* _socket, 
               IPCMSGSTRUCT* _message){
  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));   
}

void pdo_receive(rlCanOpenDaemon *_daemonptr,
                 rlSocket* _socket, 
                 IPCMSGSTRUCT* _message){
  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));   
}

void pdo_transmit(rlCanOpenDaemon *_daemonptr,
                  rlSocket* _socket,
                  IPCMSGSTRUCT* _message){
  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));   
}

void nmt_transmit(rlCanOpenDaemon *_daemonptr, 
                  rlSocket* _socket, 
                  IPCMSGSTRUCT* _message){
  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 restart_board(rlCanOpenDaemon *_daemonptr, 
                   rlSocket* _socket, 
                   IPCMSGSTRUCT* _message){
  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 getNodeState(rlCanOpenDaemon *_daemonptr, 
                  rlSocket* _socket, 
                  IPCMSGSTRUCT* _message){
  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));   
}

static void *clientconnection(void *arg)
{
  //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;
}


static void *listenerthread(void *arg)
{
  
  // 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;
}



rlCanOpenDaemon::rlCanOpenDaemon(){
  nodes = new rlCanOpen();
  port = 5000;
}

rlCanOpenDaemon::rlCanOpenDaemon(int _port, char* _iniFileName){
  if (_iniFileName!=0){
    nodes = new rlCanOpen(_iniFileName);
  }
  else{
    nodes = new rlCanOpen();
  }
  port = _port;
  
        
}

rlCanOpenDaemon::~rlCanOpenDaemon(){
  rlDebugPrintf("destruktor rlCanOpenDaemon\n");
  if (nodes!=0){
    delete nodes;
  }
}

int rlCanOpenDaemon::getPort(){
  return port;
}


void rlCanOpenDaemon::start(){
  daemon_thread.create(listenerthread, this);
  /* NO NO this has to be done by the user RL 17.06.2004
    while(1){
    rlsleep(100);
  }
  */
}