|
|
/*------------------------------------------------------------------------------
|
|
|
-- This file is a part of the SocExplorer Software
|
|
|
-- Copyright (C) 2014, Plasma Physics Laboratory - CNRS
|
|
|
--
|
|
|
-- This program is free software; you can redistribute it and/or modify
|
|
|
-- it under the terms of the GNU General Public License as published by
|
|
|
-- the Free Software Foundation; either version 3 of the License, or
|
|
|
-- (at your option) any later version.
|
|
|
--
|
|
|
-- This program is distributed in the hope that it will be useful,
|
|
|
-- but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
-- GNU General Public License for more details.
|
|
|
--
|
|
|
-- You should have received a copy of the GNU General Public License
|
|
|
-- along with this program; if not, write to the Free Software
|
|
|
-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
|
-------------------------------------------------------------------------------*/
|
|
|
/*-- Author : Alexis Jeandet
|
|
|
-- Mail : alexis.jeandet@member.fsf.org
|
|
|
----------------------------------------------------------------------------*/
|
|
|
#include "gr_esb_bridge.h"
|
|
|
#include "gr_esb_ui.h"
|
|
|
#include <unistd.h>
|
|
|
#include "spw.h"
|
|
|
#include <socexplorerengine.h>
|
|
|
|
|
|
GR_ESB_bridge::GR_ESB_bridge(socexplorerplugin *parent) :
|
|
|
abstractSpwBridge(parent)
|
|
|
{
|
|
|
this->p_GUI = new GR_ESB_ui();
|
|
|
this->manager = new GR_ESB_Manager(parent,this);
|
|
|
|
|
|
connect((GR_ESB_ui*)(this->p_GUI),SIGNAL(ipchanged(QString)),this,SLOT(setIP(QString)));
|
|
|
connect((GR_ESB_ui*)(this->p_GUI),SIGNAL(vlinkchanged(QString)),this,SLOT(setVirtualLink(QString)));
|
|
|
connect((GR_ESB_ui*)(this->p_GUI),SIGNAL(connectClicked()),this,SLOT(toggleBridgeConnection()));
|
|
|
this->manager->virtualLinkIndex = 0;
|
|
|
this->manager->start();
|
|
|
}
|
|
|
|
|
|
GR_ESB_bridge::~GR_ESB_bridge()
|
|
|
{
|
|
|
this->manager->requestInterruption();
|
|
|
while(this->manager->isRunning());
|
|
|
}
|
|
|
|
|
|
void GR_ESB_bridge::toggleBridgeConnection()
|
|
|
{
|
|
|
if(this->plugin->isConnected())
|
|
|
{
|
|
|
this->disconnectBridge();
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
this->connectBridge();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
bool GR_ESB_bridge::connectBridge()
|
|
|
{
|
|
|
if(this->manager->connectBridge())
|
|
|
{
|
|
|
((GR_ESB_ui*)this->p_GUI)->lock(true);
|
|
|
emit setConnected(true);
|
|
|
return true;
|
|
|
}
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
bool GR_ESB_bridge::disconnectBridge()
|
|
|
{
|
|
|
if(this->manager->disconnectBridge())
|
|
|
{
|
|
|
((GR_ESB_ui*)this->p_GUI)->lock(false);
|
|
|
emit setConnected(false);
|
|
|
return true;
|
|
|
}
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
void GR_ESB_bridge::setIP(QString ip)
|
|
|
{
|
|
|
this->manager->IP = ip;
|
|
|
}
|
|
|
|
|
|
void GR_ESB_bridge::setVirtualLink(QString vlink)
|
|
|
{
|
|
|
vlink = vlink.section("Virtual link",0,0);
|
|
|
bool success;
|
|
|
int vlinkTmp = vlink.toInt(&success);
|
|
|
if(success)
|
|
|
{
|
|
|
setVirtualLink(vlinkTmp);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void GR_ESB_bridge::setVirtualLink(qint32 vlink)
|
|
|
{
|
|
|
if(vlink<6 && vlink>=0)
|
|
|
{
|
|
|
this->manager->virtualLinkIndex = vlink;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
unsigned int GR_ESB_bridge::Write(unsigned int *Value, unsigned int count, unsigned int address)
|
|
|
{
|
|
|
// TODO write ME!
|
|
|
Q_UNUSED(count)
|
|
|
Q_UNUSED(Value)
|
|
|
Q_UNUSED(address)
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
unsigned int GR_ESB_bridge::Read(unsigned int *Value, unsigned int count, unsigned int address)
|
|
|
{
|
|
|
// TODO write ME!
|
|
|
Q_UNUSED(Value)
|
|
|
Q_UNUSED(count)
|
|
|
Q_UNUSED(address)
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
int GR_ESB_bridge::pushRMAPPacket(char *packet, int size)
|
|
|
{
|
|
|
return this->manager->sendPacket(packet,size);
|
|
|
}
|
|
|
|
|
|
|
|
|
GR_ESB_Manager::GR_ESB_Manager(socexplorerplugin *plugin, QObject *parent)
|
|
|
:QThread((QObject*)parent)
|
|
|
{
|
|
|
this->Read_soc = new QTcpSocket(this);
|
|
|
this->Write_soc = new QTcpSocket(this);
|
|
|
this->RMAPtimeout = 2000;
|
|
|
this->handleMutex = new QMutex(QMutex::NonRecursive);
|
|
|
this->RMAP_AnswersSem = new QSemaphore(0);
|
|
|
this->RMAP_AnswersMtx=new QMutex(QMutex::Recursive);
|
|
|
this->RMAP_pending_transaction_IDsMtx=new QMutex(QMutex::Recursive);
|
|
|
this->plugin = plugin;
|
|
|
connected = false;
|
|
|
this->moveToThread(this);
|
|
|
}
|
|
|
|
|
|
GR_ESB_Manager::~GR_ESB_Manager()
|
|
|
{
|
|
|
|
|
|
}
|
|
|
|
|
|
void GR_ESB_Manager::run()
|
|
|
{
|
|
|
SocExplorerEngine::message(this->plugin,"Starting GRESB pooling thread",1);
|
|
|
while (!this->isInterruptionRequested())
|
|
|
{
|
|
|
if(this->connected)
|
|
|
{
|
|
|
handleMutex->lock();
|
|
|
SocExplorerEngine::message(this->plugin,"Looking for new RMAP packets",4);
|
|
|
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
//do some sanity checks!
|
|
|
|
|
|
usleep(RMAPtimeout/2);
|
|
|
}
|
|
|
usleep(1000);
|
|
|
}
|
|
|
SocExplorerEngine::message(this->plugin,"Exiting Startdundee USB pooling thread",1);
|
|
|
}
|
|
|
|
|
|
bool GR_ESB_Manager::connectBridge()
|
|
|
{
|
|
|
int timeout=60;
|
|
|
if(this->Read_soc->state()==QTcpSocket::UnconnectedState)
|
|
|
{
|
|
|
this->Read_soc->connectToHost(IP,gresb_Conf[virtualLinkIndex].Read_port);
|
|
|
this->Read_soc->waitForConnected(30000);
|
|
|
}
|
|
|
if(this->Write_soc->state()==QTcpSocket::UnconnectedState)
|
|
|
{
|
|
|
this->Write_soc->connectToHost(IP,gresb_Conf[virtualLinkIndex].Write_port);
|
|
|
this->Write_soc->waitForConnected(30000);
|
|
|
}
|
|
|
while((this->Read_soc->state()!=QTcpSocket::ConnectedState) && (this->Write_soc->state()!=QTcpSocket::ConnectedState))
|
|
|
{
|
|
|
usleep(100000);
|
|
|
if(timeout--==0)return false;
|
|
|
}
|
|
|
return true;
|
|
|
|
|
|
}
|
|
|
|
|
|
bool GR_ESB_Manager::disconnectBridge()
|
|
|
{
|
|
|
int timeout=60;
|
|
|
if(this->Read_soc->state()!=QTcpSocket::UnconnectedState)
|
|
|
{
|
|
|
this->Read_soc->disconnectFromHost();
|
|
|
this->Read_soc->waitForDisconnected(30000);
|
|
|
}
|
|
|
if(this->Write_soc->state()!=QTcpSocket::UnconnectedState)
|
|
|
{
|
|
|
this->Write_soc->disconnectFromHost();
|
|
|
this->Write_soc->waitForDisconnected(30000);
|
|
|
}
|
|
|
while((this->Read_soc->state()!=QTcpSocket::UnconnectedState) && (this->Write_soc->state()!=QTcpSocket::UnconnectedState))
|
|
|
{
|
|
|
usleep(100000);
|
|
|
if(timeout--==0)return false;
|
|
|
}
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
int GR_ESB_Manager::getRMAPtransactionID()
|
|
|
{
|
|
|
// TODO write ME!
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
int GR_ESB_Manager::getRMAPanswer(int transactionID, char **buffer)
|
|
|
{
|
|
|
// TODO write ME!
|
|
|
Q_UNUSED(transactionID)
|
|
|
Q_UNUSED(buffer)
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
bool GR_ESB_Manager::sendPacket(char *packet, int size)
|
|
|
{
|
|
|
// TODO write ME!
|
|
|
Q_UNUSED(packet)
|
|
|
Q_UNUSED(size)
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
void GR_ESB_Manager::pushRmapPacket(char *packet, int len)
|
|
|
{
|
|
|
// TODO write ME!
|
|
|
Q_UNUSED(packet)
|
|
|
Q_UNUSED(len)
|
|
|
}
|
|
|
|
