HG_REPOSITORIES/LPP/INSTRUMENTATION/SocExplorerPlugins Commit - r71:81feb673e028

GRESB WIP.

Jeandet Alexis -

r71:81feb673e028 GRESB

parent child

Context file:

r71:81feb673e028

Collapse all files

spwplugin/GR-ESB/gr_esb_bridge.cpp +233 -44

             /*------------------------------------------------------------------------------
             --  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!
+                char writeBuffer[RMAP_WRITE_PACKET_MIN_SZ((RMAP_MAX_XFER_SIZE*4))];
-                Q_UNUSED(count)
+                char *RMAPAckBuff;
-                Q_UNUSED(Value)
+                int transactionID = 0;
-                Q_UNUSED(address)
+                int written=0;
-                return 0;
+                SocExplorerEngine::message(this->plugin,"Enter Write function",2);
+                QProgressBar* progress=NULL;
+                SocExplorerAutoProgressBar autopb;
+                if(count>RMAP_MAX_XFER_SIZE)
+                {
+                    progress= SocExplorerEngine::getProgressBar("Writing on SPW @0x"+QString::number(address,16)+" %v of "+QString::number(count)+" words ",count);
+                    autopb.setProgressBar(progress);
+                }
+                //Quite stupide loop, I guess that I always get the number of byte I asked for!
+                while(count>=RMAP_MAX_XFER_SIZE)
+                {
+                    for(int i=0;i<(RMAP_MAX_XFER_SIZE);i++)
+                    {
+                        writeBuffer[RMAP_WRITE_HEADER_MIN_SZ+(i*4)+0] = (char)(((unsigned int)Value[i+written]>>24)&0xFF);
+                        writeBuffer[RMAP_WRITE_HEADER_MIN_SZ+(i*4)+1] = (char)(((unsigned int)Value[i+written]>>16)&0xFF);
+                        writeBuffer[RMAP_WRITE_HEADER_MIN_SZ+(i*4)+2] = (char)(((unsigned int)Value[i+written]>>8)&0xFF);
+                        writeBuffer[RMAP_WRITE_HEADER_MIN_SZ+(i*4)+3] = (char)(((unsigned int)Value[i+written])&0xFF);
+                    }
+                    transactionID=manager->getRMAPtransactionID();
+                    SocExplorerEngine::message(this->plugin,QString("Sending Write request with ID=%1").arg(transactionID),2);
+                    RMAP_build_tx_request_header(
+                                this->manager->destinationLogicalAddress,
+                                this->manager->destinationKey,
+                                this->manager->sourceLogicalAddress,
+                                transactionID,
+                                address+(written*4),
+                                RMAP_MAX_XFER_SIZE*4,
+                                writeBuffer);
+                    manager->sendPacket(writeBuffer,RMAP_WRITE_PACKET_MIN_SZ(RMAP_MAX_XFER_SIZE*4));
+                    manager->getRMAPanswer(transactionID,&RMAPAckBuff);
+                    free(RMAPAckBuff);
+                    written+=RMAP_MAX_XFER_SIZE;
+                    count-=RMAP_MAX_XFER_SIZE;
+                    progress->setValue(written);
+                    qApp->processEvents();
+                }
+                if(count>0)
+                {
+                    for(int i=0;i<((int)count);i++)
+                    {
+                        writeBuffer[RMAP_WRITE_HEADER_MIN_SZ+(i*4)+0] = (char)(((unsigned int)Value[i+written]>>24)&0xFF);
+                        writeBuffer[RMAP_WRITE_HEADER_MIN_SZ+(i*4)+1] = (char)(((unsigned int)Value[i+written]>>16)&0xFF);
+                        writeBuffer[RMAP_WRITE_HEADER_MIN_SZ+(i*4)+2] = (char)(((unsigned int)Value[i+written]>>8)&0xFF);
+                        writeBuffer[RMAP_WRITE_HEADER_MIN_SZ+(i*4)+3] = (char)(((unsigned int)Value[i+written])&0xFF);
+                    }
+                    transactionID=manager->getRMAPtransactionID();
+                    SocExplorerEngine::message(this->plugin,QString("Sending Write request with ID=%1").arg(transactionID),2);
+                    RMAP_build_tx_request_header(
+                                this->manager->destinationLogicalAddress,
+                                this->manager->destinationKey,
+                                this->manager->sourceLogicalAddress,
+                                transactionID,
+                                address+(written*4),
+                                count*4,
+                                writeBuffer);
+                    manager->sendPacket(writeBuffer,RMAP_WRITE_PACKET_MIN_SZ(count*4));
+                    manager->getRMAPanswer(transactionID,&RMAPAckBuff);
+                    free(RMAPAckBuff);
+                    written+=count;
+                    if(progress!=NULL)
+                    {
+                        progress->setValue(written);
+                        qApp->processEvents();
+                    }
+                }
+                return written;
             }
             unsigned int GR_ESB_bridge::Read(unsigned int *Value, unsigned int count, unsigned int address)
             {
-                // TODO write ME!
+                char requestBuffer[RMAP_READ_HEADER_MIN_SZ];
-                Q_UNUSED(Value)
+                char* RMAP_AnswerBuffer;
-                Q_UNUSED(count)
+                requestBuffer[0]=this->manager->linkNumber;//Link number
-                Q_UNUSED(address)
+                int transactionID = 0;
-                return 0;
+                int read=0;
+                QProgressBar* progress=NULL;
+                SocExplorerAutoProgressBar autopb;
+                if(count>RMAP_MAX_XFER_SIZE)
+                {
+                    progress= SocExplorerEngine::getProgressBar("Reading on SPW @0x"+QString::number(address,16)+" %v of "+QString::number(count)+" words ",count);
+                    autopb.setProgressBar(progress);
+                }
+                SocExplorerEngine::message(this->plugin,QString("Enter read function, count=%1, RMAP_MAX_XFER_SIZE=%2").arg(count).arg(RMAP_MAX_XFER_SIZE),2);
+                //Quite stupide loop, I guess that I always get the number of byte I asked for!
+                while((int)count>=(int)RMAP_MAX_XFER_SIZE)
+                {
+                    transactionID = manager->getRMAPtransactionID();
+                    SocExplorerEngine::message(this->plugin,QString("New transactionID:%1").arg(transactionID),2);
+                    RMAP_build_rx_request_header(
+                                this->manager->destinationLogicalAddress,
+                                this->manager->destinationKey,
+                                this->manager->sourceLogicalAddress,
+                                transactionID,
+                                address+(read*4),
+                                RMAP_MAX_XFER_SIZE*4,
+                                requestBuffer);
+                    manager->sendPacket(requestBuffer,RMAP_READ_HEADER_MIN_SZ);
+                    int len=manager->getRMAPanswer(transactionID,&RMAP_AnswerBuffer);
+                    if(len==-1)
+                    {
+                        this->toggleBridgeConnection();
+                        return 0;
+                    }
+                    for(int i=0;i<((len-13)/4);i++)
+                    {
+                        Value[read+i] =   0x0FF & ((unsigned int)RMAP_AnswerBuffer[(4*i)+12]);
+                        Value[read+i] =  (Value[read+i]<<8) + (0x0FF & ((unsigned int)RMAP_AnswerBuffer[(4*i)+13]));
+                        Value[read+i] =  (Value[read+i]<<8) + (0x0FF & ((unsigned int)RMAP_AnswerBuffer[(4*i)+14]));
+                        Value[read+i] =  (Value[read+i]<<8) + (0x0FF & ((unsigned int)RMAP_AnswerBuffer[(4*i)+15]));
+                    }
+                    free(RMAP_AnswerBuffer);
+                    read+=RMAP_MAX_XFER_SIZE;
+                    count-=RMAP_MAX_XFER_SIZE;
+                    progress->setValue(read);
+                    qApp->processEvents();
+                }
+                if((int)count>0)
+                {
+                    transactionID = manager->getRMAPtransactionID();
+                    SocExplorerEngine::message(this->plugin,QString("New transactionID: %1").arg(transactionID),2);
+                    SocExplorerEngine::message(this->plugin,QString("Building request with:"),2);
+                    SocExplorerEngine::message(this->plugin,QString("Address = %1").arg(address+(read*4),8,16),2);
+                    SocExplorerEngine::message(this->plugin,QString("Size = %1").arg(count*4),2);
+                    SocExplorerEngine::message(this->plugin,QString("Size + 13 = %1").arg((count*4)+13),2);
+                    RMAP_build_rx_request_header(
+                                this->manager->destinationLogicalAddress,
+                                this->manager->destinationKey,
+                                this->manager->sourceLogicalAddress,
+                                transactionID,
+                                address+(read*4),
+                                count*4,
+                                requestBuffer);
+                    manager->sendPacket(requestBuffer,RMAP_READ_HEADER_MIN_SZ);
+                    int len=manager->getRMAPanswer(transactionID,&RMAP_AnswerBuffer);
+                    if(len==-1)
+                    {
+                        this->toggleBridgeConnection();
+                        return 0;
+                    }
+                    for(int i=0;i<((len-13)/4);i++)
+                    {
+                        Value[read+i] =   0x0FF & ((unsigned int)RMAP_AnswerBuffer[(4*i)+12]);
+                        Value[read+i] =  (Value[read+i]<<8) + (0x0FF & ((unsigned int)RMAP_AnswerBuffer[(4*i)+13]));
+                        Value[read+i] =  (Value[read+i]<<8) + (0x0FF & ((unsigned int)RMAP_AnswerBuffer[(4*i)+14]));
+                        Value[read+i] =  (Value[read+i]<<8) + (0x0FF & ((unsigned int)RMAP_AnswerBuffer[(4*i)+15]));
+                    }
+                    free(RMAP_AnswerBuffer);
+                    read+=count;
+                    if(progress!=NULL)
+                    {
+                        progress->setValue(read);
+                        qApp->processEvents();
+                    }
+                }
+                return read;
             }
             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)
+                :abstractSpwManager(plugin, 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()
             {
+                char buffer[(RMAP_MAX_XFER_SIZE*4)+50];
                 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);
+                        SocExplorerEngine::message(this->plugin,"Looking for new RMAP packets",5);
+                        if(Read_soc->waitForReadyRead(100))
+                        {
+                            QByteArray data = Read_soc->readAll();
+                            int PacketLen= ((int)data.at(2)& 0x0FF) + (((int)data.at(3)& 0x0FF)<<8) + (((int)data.at(4)& 0x0FF)<<16);
+                            if(data[1]==(char)SPW_PROTO_ID_RMAP) //RMAP packet
+                            {
+                                RMAP_Answer* packet;
+                                SocExplorerEngine::message(this->plugin,"Got RMAP packet",2);
+                                SocExplorerEngine::message(this->plugin,QString("Rmap packet size %1").arg(PacketLen),2);
+                                char* packetbuffer = (char*)malloc(PacketLen);
+                                memcpy(packetbuffer,data.data(),PacketLen);
+                                this->handleMutex->unlock();
+                                if(PacketLen==8)
+                                {
+                                    packet=new RMAP_Answer(RMAP_get_transactionID(buffer),packetbuffer,PacketLen);
+                                }
+                                else
+                                {
+                                    packet=new RMAP_Answer(RMAP_get_transactionID(buffer+1),packetbuffer,PacketLen);
+                                }
+                                RMAP_AnswersMtx->lock();
+                                RMAP_Answers.append(packet);
+                                RMAP_AnswersMtx->unlock();
+                                RMAP_AnswersSem->release();
+                            }
+                            else //any non-rmap packet will be pushed to the network
+                            {
+                                char* packetbuffer = (char*)malloc(PacketLen);
+                                memcpy(packetbuffer,data.data(),PacketLen);
+                                emit emitPacket(packetbuffer,PacketLen);
+                                this->handleMutex->unlock();
+                                SocExplorerEngine::message(this->plugin,"Got SPW packet",2);
+                            }
+                        }
+                        else
+                        {
+                            handleMutex->unlock();
+                        }
                     }
                     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!
+                bool result = false;
-                Q_UNUSED(packet)
+                char protocoleIdentifier;
-                Q_UNUSED(size)
+                SocExplorerEngine::message(this->plugin,"Sending SPW packet",2);
-                return false;
+                if(Q_UNLIKELY(this->Write_soc->state()!=QAbstractSocket::ConnectedState))
+                {
+                    SocExplorerEngine::message(this->plugin,"Socket closed",2);
+                    //TODO handle disconnection
+                }
+                char* SPWpacket = (char*)malloc(size+4);
+                if(SPWpacket!=NULL)
+                {
+                    SPWpacket[0]=0; //Protocol = spw
+                    memcpy(SPWpacket+4,packet,size);
+                    SPWpacket[1]=size & 0x0FF;
+                    SPWpacket[2]=(size>>8) & 0x0FF;
+                    SPWpacket[3]=(size>>16) & 0x0FF;
+                }
+                this->handleMutex->lock();
+                result = ((size+4) == this->Write_soc->write(SPWpacket,size+4));
+                this->handleMutex->unlock();
+                if (Q_UNLIKELY(!result))
+                {
+                    SocExplorerEngine::message(this->plugin,"ERR sending the READ command ",2);
+                    return false;
+                }
+                else
+                {
+                    emit bytesTransmittedToSpw( size-1 ); // -1 is for removing the first bytes added to the packet to route to the right link
+                    // read the protocole identifier
+                    protocoleIdentifier = packet[2];
+                    if (protocoleIdentifier == SPW_PROTO_ID_CCSDS)
+                            emit ccsdsPacketTransmittedToSpw();
+                    SocExplorerEngine::message(this->plugin,"Packet sent",2);
+                }
+                return true;
             }
-            void GR_ESB_Manager::pushRmapPacket(char *packet, int len)
-                // TODO write ME!
-                Q_UNUSED(packet)
-                Q_UNUSED(len)

spwplugin/GR-ESB/gr_esb_bridge.h +1 -10

             #ifndef GR_ESB_BRIDGE_H
             #define GR_ESB_BRIDGE_H
             #include "abstractspwbridge.h"
             #include <QTcpSocket>
             #include <QThread>
             #include <QMutex>
             #include <QSemaphore>
             struct gresb_Conf_str
             {
                 qint32 Read_port;
                 qint32 Write_port;
             };
             const struct gresb_Conf_str gresb_Conf[]=
             {
                 {3000,3001},  //Virtual link 0
                 {3002,3003},  //Virtual link 1
                 {3004,3005},  //Virtual link 2
                 {3006,3007},  //Virtual link 3
                 {3008,3009},  //Virtual link 4
                 {3010,3011}   //Virtual link 5
             };
-            class GR_ESB_Manager: public QThread
+            class GR_ESB_Manager: public abstractSpwManager
             {
                 Q_OBJECT
             public:
                 explicit GR_ESB_Manager(socexplorerplugin *plugin = 0,QObject* parent=0);
                 ~GR_ESB_Manager();
                 void run();
                 bool connectBridge();
                 bool disconnectBridge();
-                int getRMAPtransactionID();
-                int getRMAPanswer(int transactionID,char** buffer);
                 bool sendPacket(char* packet,int size);
             signals:
                 void emitPacket(char* packet,int size);
             private:
-                QMutex* handleMutex,*RMAP_AnswersMtx,*RMAP_pending_transaction_IDsMtx;
-                QSemaphore* RMAP_AnswersSem;
                 void pushRmapPacket(char* packet,int len);
-                socexplorerplugin* plugin;
-                bool connected;
                 char* SPWPacketBuff;
-                QList<RMAP_Answer*> RMAP_Answers;
-                QList<int> RMAP_pending_transaction_IDs;
             public:
                 QTcpSocket* Read_soc;
                 QTcpSocket* Write_soc;
                 QString IP;
                 int virtualLinkIndex;
-                int RMAPtimeout;
             };
             class GR_ESB_bridge : public abstractSpwBridge
             {
                 Q_OBJECT
             public:
                 explicit GR_ESB_bridge(socexplorerplugin *parent = 0);
                 ~GR_ESB_bridge();
             signals:
             public slots:
                 void toggleBridgeConnection();
                 bool connectBridge();
                 bool disconnectBridge();
                 void setIP(QString ip);
                 void setVirtualLink(QString vlink);
                 void setVirtualLink(qint32 vlink);
                 unsigned int Write(unsigned int *Value,unsigned int count, unsigned int address=0);
                 unsigned int Read(unsigned int *Value,unsigned int count, unsigned int address=0);
                 int pushRMAPPacket(char* packet,int size);
                 void packetReceived();
             private:
                 GR_ESB_Manager* manager;
             };
             #endif // GR_ESB_BRIDGE_H

spwplugin/StarDundee/stardundeespw_usb.cpp +2 -101

             /*------------------------------------------------------------------------------
             --  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 "stardundeespw_usb.h"
             #include "fakestardundeespwusb_lib.h"
             #include <socexplorerengine.h>
             #include <qhexedit.h>
             const QString dwLinkStatusQString[6] = {
                 "CFG_SPACEWIRE_ERROR_RESET",
                 "CFG_SPACEWIRE_ERROR_WAIT",
                 "CFG_SPACEWIRE_READY",
                 "CFG_SPACEWIRE_STARTED",
                 "CFG_SPACEWIRE_CONNECTING",
                 "CFG_SPACEWIRE_RUN"
             };
             stardundeeSPW_USB::stardundeeSPW_USB(socexplorerplugin *parent) :
                 abstractSpwBridge(parent)
             {
                 Q_UNUSED(parent)
                 this->manager = new stardundeeSPW_USB_Manager(parent,this);
                 makeGUI(parent);
-                this->manager->start();
                 connect(this->manager,SIGNAL(emitPacket(char*,int)),this,SIGNAL(pushPacketOverTCP(char*,int)));
                 connect(this->manager, SIGNAL(bytesReceivedFromSpw(uint)), this, SIGNAL(BytesReceivedFromSpw(uint)));
                 connect(this->manager, SIGNAL(bytesTransmittedToSpw(uint)), this, SIGNAL(BytesTransmittedToSpw(uint)));
                 connect(this->manager, SIGNAL(ccsdsPacketTransmittedToSpw()), this, SIGNAL(CCSDSPacketTransmittedToSpw()));
+                this->manager->start();
             }
             stardundeeSPW_USB::~stardundeeSPW_USB()
             {
                 this->manager->requestInterruption();
                 while(this->manager->isRunning());
             }
             void stardundeeSPW_USB::toggleBridgeConnection()
             {
                 if(this->plugin->isConnected())
                 {
                     this->disconnectBridge();
                 }
                 else
                 {
                     this->connectBridge();
                 }
             }
             bool stardundeeSPW_USB::connectBridge()
             {
                 if(this->manager->connectBridge())
                 {
                     this->timecodeFrequencyChanged(   ((StarDundeeGUI*)this->p_GUI)->getTimecodeFrequency());
                     this->startSendingTimecodes(      ((StarDundeeGUI*)this->p_GUI)->getStartSendingTimecodes());
                     ((StarDundeeGUI*)this->p_GUI)->lock(true);
                     emit setConnected(true);
                     return true;
                 }
                 return false;
             }
             bool stardundeeSPW_USB::disconnectBridge()
             {
                 if(this->manager->disconnectBridge())
                 {
                     ((StarDundeeGUI*)this->p_GUI)->lock(false);
                     emit setConnected(false);
                     return true;
                 }
                 return false;
             }
             int stardundeeSPW_USB::pushRMAPPacket(char *packet, int size)
             {
                 return this->manager->sendPacket(packet,size);
             }
             unsigned int stardundeeSPW_USB::Write(unsigned int *Value, unsigned int count, unsigned int address)
             {
                 char writeBuffer[RMAP_WRITE_PACKET_MIN_SZ((RMAP_MAX_XFER_SIZE*4))+1];
                 char *RMAPAckBuff;
                 writeBuffer[0]=this->manager->linkNumber;//Link number
                 int transactionID = 0;
                 int written=0;
                 SocExplorerEngine::message(this->plugin,"Enter Write function",2);
                 QProgressBar* progress=NULL;
                 SocExplorerAutoProgressBar autopb;
                 if(count>RMAP_MAX_XFER_SIZE)
                 {
                     progress= SocExplorerEngine::getProgressBar("Writing on SPW @0x"+QString::number(address,16)+" %v of "+QString::number(count)+" words ",count);
                     autopb.setProgressBar(progress);
                 }
                 //Quite stupide loop, I guess that I always get the number of byte I asked for!
                 while(count>=RMAP_MAX_XFER_SIZE)
                 {
                     for(int i=0;i<(RMAP_MAX_XFER_SIZE);i++)
                     {
                         writeBuffer[RMAP_WRITE_HEADER_MIN_SZ+(i*4)+1] = (char)(((unsigned int)Value[i+written]>>24)&0xFF);
                         writeBuffer[RMAP_WRITE_HEADER_MIN_SZ+(i*4)+2] = (char)(((unsigned int)Value[i+written]>>16)&0xFF);
                         writeBuffer[RMAP_WRITE_HEADER_MIN_SZ+(i*4)+3] = (char)(((unsigned int)Value[i+written]>>8)&0xFF);
                         writeBuffer[RMAP_WRITE_HEADER_MIN_SZ+(i*4)+4] = (char)(((unsigned int)Value[i+written])&0xFF);
                     }
                     transactionID=manager->getRMAPtransactionID();
                     SocExplorerEngine::message(this->plugin,QString("Sending Write request with ID=%1").arg(transactionID),2);
                     RMAP_build_tx_request_header(
                                 this->manager->destinationLogicalAddress,
                                 this->manager->destinationKey,
                                 this->manager->sourceLogicalAddress,
                                 transactionID,
                                 address+(written*4),
                                 RMAP_MAX_XFER_SIZE*4,
                                 writeBuffer+1);
                     manager->sendPacket(writeBuffer,RMAP_WRITE_PACKET_MIN_SZ(RMAP_MAX_XFER_SIZE*4)+1);
                     manager->getRMAPanswer(transactionID,&RMAPAckBuff);
                     free(RMAPAckBuff);
                     written+=RMAP_MAX_XFER_SIZE;
                     count-=RMAP_MAX_XFER_SIZE;
                     progress->setValue(written);
                     qApp->processEvents();
                 }
                 if(count>0)
                 {
                     for(int i=0;i<((int)count);i++)
                     {
                         writeBuffer[RMAP_WRITE_HEADER_MIN_SZ+(i*4)+1] = (char)(((unsigned int)Value[i+written]>>24)&0xFF);
                         writeBuffer[RMAP_WRITE_HEADER_MIN_SZ+(i*4)+2] = (char)(((unsigned int)Value[i+written]>>16)&0xFF);
                         writeBuffer[RMAP_WRITE_HEADER_MIN_SZ+(i*4)+3] = (char)(((unsigned int)Value[i+written]>>8)&0xFF);
                         writeBuffer[RMAP_WRITE_HEADER_MIN_SZ+(i*4)+4] = (char)(((unsigned int)Value[i+written])&0xFF);
                     }
                     transactionID=manager->getRMAPtransactionID();
                     SocExplorerEngine::message(this->plugin,QString("Sending Write request with ID=%1").arg(transactionID),2);
                     RMAP_build_tx_request_header(
                                 this->manager->destinationLogicalAddress,
                                 this->manager->destinationKey,
                                 this->manager->sourceLogicalAddress,
                                 transactionID,
                                 address+(written*4),
                                 count*4,
                                 writeBuffer+1);
                     manager->sendPacket(writeBuffer,RMAP_WRITE_PACKET_MIN_SZ(count*4) +1);
                     manager->getRMAPanswer(transactionID,&RMAPAckBuff);
                     free(RMAPAckBuff);
                     written+=count;
                     if(progress!=NULL)
                     {
                         progress->setValue(written);
                         qApp->processEvents();
                     }
                 }
                 return written;
             }
             unsigned int stardundeeSPW_USB::Read(unsigned int *Value, unsigned int count, unsigned int address)
             {
                 char requestBuffer[RMAP_READ_HEADER_MIN_SZ+1];
                 char* RMAP_AnswerBuffer;
                 requestBuffer[0]=this->manager->linkNumber;//Link number
                 int transactionID = 0;
                 int read=0;
                 QProgressBar* progress=NULL;
                 SocExplorerAutoProgressBar autopb;
                 if(count>RMAP_MAX_XFER_SIZE)
                 {
                     progress= SocExplorerEngine::getProgressBar("Reading on SPW @0x"+QString::number(address,16)+" %v of "+QString::number(count)+" words ",count);
                     autopb.setProgressBar(progress);
                 }
                 SocExplorerEngine::message(this->plugin,QString("Enter read function, count=%1, RMAP_MAX_XFER_SIZE=%2").arg(count).arg(RMAP_MAX_XFER_SIZE),2);
                 //Quite stupide loop, I guess that I always get the number of byte I asked for!
                 while((int)count>=(int)RMAP_MAX_XFER_SIZE)
                 {
                     transactionID = manager->getRMAPtransactionID();
                     SocExplorerEngine::message(this->plugin,QString("New transactionID:%1").arg(transactionID),2);
                     RMAP_build_rx_request_header(
                                 this->manager->destinationLogicalAddress,
                                 this->manager->destinationKey,
                                 this->manager->sourceLogicalAddress,
                                 transactionID,
                                 address+(read*4),
                                 RMAP_MAX_XFER_SIZE*4,
                                 requestBuffer+1);
                     manager->sendPacket(requestBuffer,RMAP_READ_HEADER_MIN_SZ+1);
                     int len=manager->getRMAPanswer(transactionID,&RMAP_AnswerBuffer);
                     if(len==-1)
                     {
                         this->toggleBridgeConnection();
                         return 0;
                     }
                     for(int i=0;i<((len-13)/4);i++)
                     {
                         Value[read+i] =   0x0FF & ((unsigned int)RMAP_AnswerBuffer[(4*i)+12]);
                         Value[read+i] =  (Value[read+i]<<8) + (0x0FF & ((unsigned int)RMAP_AnswerBuffer[(4*i)+13]));
                         Value[read+i] =  (Value[read+i]<<8) + (0x0FF & ((unsigned int)RMAP_AnswerBuffer[(4*i)+14]));
                         Value[read+i] =  (Value[read+i]<<8) + (0x0FF & ((unsigned int)RMAP_AnswerBuffer[(4*i)+15]));
                     }
                     free(RMAP_AnswerBuffer);
                     read+=RMAP_MAX_XFER_SIZE;
                     count-=RMAP_MAX_XFER_SIZE;
                     progress->setValue(read);
                     qApp->processEvents();
                 }
                 if((int)count>0)
                 {
                     transactionID = manager->getRMAPtransactionID();
                     SocExplorerEngine::message(this->plugin,QString("New transactionID: %1").arg(transactionID),2);
                     SocExplorerEngine::message(this->plugin,QString("Building request with:"),2);
                     SocExplorerEngine::message(this->plugin,QString("Address = %1").arg(address+(read*4),8,16),2);
                     SocExplorerEngine::message(this->plugin,QString("Size = %1").arg(count*4),2);
                     SocExplorerEngine::message(this->plugin,QString("Size + 13 = %1").arg((count*4)+13),2);
                     RMAP_build_rx_request_header(
                                 this->manager->destinationLogicalAddress,
                                 this->manager->destinationKey,
                                 this->manager->sourceLogicalAddress,
                                 transactionID,
                                 address+(read*4),
                                 count*4,
                                 requestBuffer+1);
                     manager->sendPacket(requestBuffer,RMAP_READ_HEADER_MIN_SZ+1);
                     int len=manager->getRMAPanswer(transactionID,&RMAP_AnswerBuffer);
                     if(len==-1)
                     {
                         this->toggleBridgeConnection();
                         return 0;
                     }
                     for(int i=0;i<((len-13)/4);i++)
                     {
                         Value[read+i] =   0x0FF & ((unsigned int)RMAP_AnswerBuffer[(4*i)+12]);
                         Value[read+i] =  (Value[read+i]<<8) + (0x0FF & ((unsigned int)RMAP_AnswerBuffer[(4*i)+13]));
                         Value[read+i] =  (Value[read+i]<<8) + (0x0FF & ((unsigned int)RMAP_AnswerBuffer[(4*i)+14]));
                         Value[read+i] =  (Value[read+i]<<8) + (0x0FF & ((unsigned int)RMAP_AnswerBuffer[(4*i)+15]));
                     }
                     free(RMAP_AnswerBuffer);
                     read+=count;
                     if(progress!=NULL)
                     {
                         progress->setValue(read);
                         qApp->processEvents();
                     }
                 }
                 return read;
             }
             void stardundeeSPW_USB::brickSelectionChanged(int brickIndex)
             {
                 this->manager->selectedBrick = brickIndex-1;
                 SocExplorerEngine::message(plugin,QString("Changing brick index: %1").arg(manager->selectedBrick),1);
             }
             void stardundeeSPW_USB::linkNumberSelectionChanged(int linkIndex)
             {
                 this->manager->linkNumber = linkIndex + 1;
                 SocExplorerEngine::message(plugin,QString("Changing Link Number: %1").arg(manager->linkNumber),1);
             }
             void stardundeeSPW_USB::linkSpeedSelectionChanged(const QString &linkSpeed)
             {
                 this->manager->linkSpeed = linkSpeed.toInt();
                 SocExplorerEngine::message(plugin,QString("Changing Link Speed: %1").arg(manager->linkSpeed),1);
             }
             void stardundeeSPW_USB::sourceLogicalAddressChanged(const QString &sourceAddress)
             {
                 this->manager->sourceLogicalAddress = sourceAddress.toInt();
                 SocExplorerEngine::message(plugin,QString("Changing Destination Key: %1").arg(manager->sourceLogicalAddress),1);
             }
             void stardundeeSPW_USB::destinationAddressChanged(const QString &rmapaddress)
             {
                 this->manager->destinationLogicalAddress = rmapaddress.toInt();
                 SocExplorerEngine::message(plugin,QString("Changing RMAP address: %1").arg(manager->destinationLogicalAddress),1);
             }
             void stardundeeSPW_USB::destinationKeyChanged(const QString &key)
             {
                 this->manager->destinationKey = key.toInt();
                 SocExplorerEngine::message(plugin,QString("Changing RMAP Key: %1").arg(manager->destinationKey),1);
             }
             void stardundeeSPW_USB::brickModeChanged( bool interfaceMode )
             {
                 this->manager->interfaceMode = interfaceMode;
             }
             void stardundeeSPW_USB::timecodeFrequencyChanged(const QString &frequency)
             {
                 this->manager->timecodeFrequency = frequency.toDouble();
                 this->manager->setTimecodeFrequency( this->manager->timecodeFrequency);
                 SocExplorerEngine::message(plugin,QString("Changing timecode frequency: %1").arg(manager->timecodeFrequency),1);
             }
             void stardundeeSPW_USB::startSendingTimecodes(bool onOff )
             {
                 this->manager->sendTimecodePeriodically( onOff );
             }
             void stardundeeSPW_USB::rmapTimeoutChanged(const QString &timeout)
             {
                 int tim=timeout.toInt();
                 if(tim<50)
                 {
                     tim = 50;
                     ((StarDundeeGUI*)this->p_GUI)->setRmapTimeout(QString("%1").arg(tim));
                 }
                 this->manager->RMAPtimeout = tim;
                 SocExplorerEngine::message(plugin,QString("Changing RMAP Timeout: %1").arg(manager->RMAPtimeout),1);
             }
             void stardundeeSPW_USB::makeGUI(socexplorerplugin *parent)
             {
                 Q_UNUSED(parent)
                 this->p_GUI = new StarDundeeGUI();
                 //    this->mainLayout = new QGridLayout(this->p_GUI);
                 connect(((StarDundeeGUI*)this->p_GUI),SIGNAL(connectClicked()),this,SLOT(toggleBridgeConnection()));
                 connect(this->manager,SIGNAL(updateAvailableBrickCount(int)),((StarDundeeGUI*)this->p_GUI),SLOT(updateAvailableBrickCount(int)));
                 connect(((StarDundeeGUI*)this->p_GUI),SIGNAL(brickSelectionChanged(int)),this,SLOT(brickSelectionChanged(int)));
                 connect(((StarDundeeGUI*)this->p_GUI),SIGNAL(linkNumberSelectionChanged(int)),this,SLOT(linkNumberSelectionChanged(int)));
                 connect(((StarDundeeGUI*)this->p_GUI),SIGNAL(linkSpeedSelectionChanged(QString)),this,SLOT(linkSpeedSelectionChanged(QString)));
                 connect(((StarDundeeGUI*)this->p_GUI),SIGNAL(sourceLogicalAddressChanged(QString)),this,SLOT(sourceLogicalAddressChanged(QString)));
                 connect(((StarDundeeGUI*)this->p_GUI),SIGNAL(rmapAddressChanged(QString)),this,SLOT(destinationAddressChanged(QString)));
                 connect(((StarDundeeGUI*)this->p_GUI),SIGNAL(destinationKeyChanged(QString)),this,SLOT(destinationKeyChanged(QString)));
                 connect(((StarDundeeGUI*)this->p_GUI),SIGNAL(rmapTimeoutChanged(QString)),this,SLOT(rmapTimeoutChanged(QString)));
                 connect(((StarDundeeGUI*)this->p_GUI),SIGNAL(brickModeChanged(bool)), this, SLOT(brickModeChanged(bool)));
                 connect(((StarDundeeGUI*)this->p_GUI),SIGNAL(timecodeFrequencyChange(QString)), this, SLOT(timecodeFrequencyChanged(QString)));
                 connect(((StarDundeeGUI*)this->p_GUI),SIGNAL(startSendingTimecode(bool)), this, SLOT(startSendingTimecodes(bool)));
                 this->brickSelectionChanged(      ((StarDundeeGUI*)this->p_GUI)->getBrickSelection());
                 this->linkNumberSelectionChanged( ((StarDundeeGUI*)this->p_GUI)->getLinkNumberSelection());
                 this->linkSpeedSelectionChanged(  ((StarDundeeGUI*)this->p_GUI)->getLinkSpeedSelection());
                 this->sourceLogicalAddressChanged(((StarDundeeGUI*)this->p_GUI)->getSourceAddress());
                 this->destinationAddressChanged(  ((StarDundeeGUI*)this->p_GUI)->getDestinationAddress());
                 this->destinationKeyChanged(      ((StarDundeeGUI*)this->p_GUI)->getDestinationKey());
                 this->rmapTimeoutChanged(         ((StarDundeeGUI*)this->p_GUI)->getRmapTimeout());
                 this->brickModeChanged(           ((StarDundeeGUI*)this->p_GUI)->isBrickSetAsAnInterface());
                 connect(this,SIGNAL(SelectBrick(int)),              ((StarDundeeGUI*)this->p_GUI),SLOT(selectBrick(int)));
                 connect(this,SIGNAL(SelectLinkNumber(int)),         ((StarDundeeGUI*)this->p_GUI),SLOT(selectLinkNumber(int)));
                 connect(this,SIGNAL(SelectLinkSpeed(int)),          ((StarDundeeGUI*)this->p_GUI),SLOT(selectLinkSpeed(int)));
                 connect(this,SIGNAL(SetDestinationKey(QString)),    ((StarDundeeGUI*)this->p_GUI),SLOT(setDestinationKey(QString)));
                 connect(this,SIGNAL(SetDestinationAddress(QString)),((StarDundeeGUI*)this->p_GUI),SLOT(setDestinationAddress(QString)));
                 connect(this,SIGNAL(SetSourceAddress(QString)),     ((StarDundeeGUI*)this->p_GUI),SLOT(setSourceAddress(QString)));
                 connect(this,SIGNAL(SetRmapTimeout(QString)),       ((StarDundeeGUI*)this->p_GUI),SLOT(setRmapTimeout(QString)));
                 connect(this,SIGNAL(GetAvailableBrickCount()),      ((StarDundeeGUI*)this->p_GUI),SLOT(getAvailableBrickCount()));
                 connect(this,SIGNAL(GetNbPacketsTransmittedToSpw()),((StarDundeeGUI*)this->p_GUI),SLOT(getNbPacketsTransmittedToSpw()));
                 connect(this,SIGNAL(GetNbCCSDSPacketsTransmittedToSpw()),
                         ((StarDundeeGUI*)this->p_GUI),SLOT(getNbCCSDSPacketsTransmittedToSpw()));
                 connect(this,SIGNAL(SetBrickAsAnInterface(bool)),   ((StarDundeeGUI*)this->p_GUI),SLOT(setBrickAsAnInterface(bool)));
                 connect(this,SIGNAL(SetBrickAsARouter(bool)),       ((StarDundeeGUI*)this->p_GUI),SLOT(setBrickAsARouter(bool)));
                 connect(this,SIGNAL(BytesReceivedFromSpw(uint)),    ((StarDundeeGUI*)this->p_GUI),SLOT(updateNbReceivedBytesFromSpw(uint)));
                 connect(this,SIGNAL(BytesTransmittedToSpw(uint)),   ((StarDundeeGUI*)this->p_GUI),SLOT(updateNbTransmittedBytesToSpw(uint)));
                 connect(this,SIGNAL(CCSDSPacketTransmittedToSpw()), ((StarDundeeGUI*)this->p_GUI),SLOT(updateCCSDSPacketTransmittedToSpw()));
                 connect(this,SIGNAL(SetTimecodeFrequency(double)),  ((StarDundeeGUI*)this->p_GUI),SLOT(setTimecodeFrequency(double)));
                 connect(this,SIGNAL(StartSendingTimecodes(bool)),   ((StarDundeeGUI*)this->p_GUI),SLOT(setStartSendingTimecodes(bool)));
                 connect(this,SIGNAL(SendOneTimecode(unsigned char)),this->manager, SLOT(sendOneTimecode(unsigned char)));
                 connect(this,SIGNAL(GetLinkNumber()),               this->manager, SLOT(getLinkNumber()));
             }
             void stardundeeSPW_USB::sendPacketComingFromTCPServer(char *packet, int size)
             {
                 char* data;
                 int i;
                 data = (char *) malloc( size + 5 );
                 data[0] = this->manager->linkNumber;
                 data[1] = this->manager->destinationLogicalAddress; // target logical address
                 data[2] = SPW_PROTO_ID_CCSDS;                       // protocol identifier
                 data[3] = 0x00;                                     // reserved
                 data[4] = 0x00;                                     // user application
                 for ( i=0; i<size; i++ )
                 {
                     data[i+5] = packet[i];
                 }
                 this->manager->sendPacket( data, size + 5);
                 free(data);
                 free(packet);
             }
             stardundeeSPW_USB_Manager::stardundeeSPW_USB_Manager(socexplorerplugin *plugin, QObject *parent)
-                :QThread((QObject*)parent)
+                :abstractSpwManager(plugin, parent)
             {
-                this->RMAPtimeout = 2000;
-                this->handleMutex = new QMutex(QMutex::NonRecursive);
-            //    this->handleMutex = new QMutex(QMutex::Recursive);
-                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;
                 // TODO remove this crap!
                 this->initDialog();
             //    this->moveToThread(this);
             }
             stardundeeSPW_USB_Manager::~stardundeeSPW_USB_Manager()
             {
-                this->terminate();
-                while (!this->isFinished()) {
-                    this->usleep(1000);
             }
             void stardundeeSPW_USB_Manager::run()
             {
                 USB_SPACEWIRE_PACKET_PROPERTIES properties;
                 USB_SPACEWIRE_ID pIdentifier=NULL;
                 USB_SPACEWIRE_STATUS stat;
                 SocExplorerEngine::message(this->plugin,"Starting Startdundee USB pooling thread",1);
                 char buffer[(RMAP_MAX_XFER_SIZE*4)+50];
                 while (!this->isInterruptionRequested())
                 {
                     if(this->connected)
                     {
                         this->handleMutex->lock();
                         SocExplorerEngine::message(this->plugin,"Looking for new RMAP packets",4);
                         if(USBSpaceWire_WaitOnReadPacketAvailable(hDevice,0.01))
                         {
                             SocExplorerEngine::message(this->plugin,"Got packet",2);
                             stat = USBSpaceWire_ReadPackets(hDevice, buffer, (RMAP_MAX_XFER_SIZE*4)+50,1, 1, &properties, &pIdentifier);
                             if (stat == TRANSFER_SUCCESS)
                             {
                                 if(USBSpaceWire_GetReadTrafficType(&properties, 0) ==SPACEWIRE_TRAFFIC_PACKET)
                                 {
                                     SocExplorerEngine::message(this->plugin,"It's a SPW packet",2);
                                     if(USBSpaceWire_GetReadEOPStatus(&properties, 0)== SPACEWIRE_USB_EOP)
                                     {
                                         SocExplorerEngine::message(this->plugin,"Got end of packet",2);
                                         emit bytesReceivedFromSpw( properties.len );
                                         if(buffer[1]==(char)SPW_PROTO_ID_RMAP) //RMAP packet
                                         {
                                             RMAP_Answer* packet;
                                             SocExplorerEngine::message(this->plugin,"Got RMAP packet",2);
                                             SocExplorerEngine::message(this->plugin,QString("Rmap packet size %1").arg(properties.len),2);
                                             char* packetbuffer = (char*)malloc(properties.len);
                                             memcpy(packetbuffer,buffer,properties.len);
                                             USBSpaceWire_FreeRead(hDevice, pIdentifier);
                                             pIdentifier = NULL;
                                             this->handleMutex->unlock();
                                             if(properties.len==8)
                                             {
                                                 packet=new RMAP_Answer(RMAP_get_transactionID(buffer),packetbuffer,properties.len);
                                             }
                                             else
                                             {
                                                 packet=new RMAP_Answer(RMAP_get_transactionID(buffer+1),packetbuffer,properties.len);
                                             }
                                             RMAP_AnswersMtx->lock();
                                             RMAP_Answers.append(packet);
                                             RMAP_AnswersMtx->unlock();
                                             RMAP_AnswersSem->release();
                                         }
                                         else //any non-rmap packet will be pushed to the network
                                         {
                                             char* packetbuffer = (char*)malloc(properties.len);
                                             memcpy(packetbuffer,buffer,properties.len);
                                             emit emitPacket(packetbuffer,properties.len);
                                             USBSpaceWire_FreeRead(hDevice, pIdentifier);
                                             this->handleMutex->unlock();
                                             SocExplorerEngine::message(this->plugin,"Got SPW packet",2);
                                         }
                                     }
                                     else
                                     {
                                         SocExplorerEngine::message(this->plugin,"No EOP received",2);
                                         this->handleMutex->unlock();
                                     }
                                 }
                             }
                             else
                             {
                                 USBSpaceWire_FreeRead(hDevice, pIdentifier);
                                 this->handleMutex->unlock();
                             }
                         }
                         else
                         {
                             USBSpaceWire_FreeRead(hDevice, pIdentifier);
                             this->handleMutex->unlock();
                         }
                     }
                     else
                     {
                         //do some sanity checks!
                         int list = USBSpaceWire_ListDevices();
                         if(this->brickList!=list)
                         {
                             this->brickList = list;
                             emit updateAvailableBrickCount(this->brickList);
                         }
                         usleep(RMAPtimeout/2);
                     }
                     usleep(1000);
                 }
                 SocExplorerEngine::message(this->plugin,"Exiting Startdundee USB pooling thread",1);
             }
             bool stardundeeSPW_USB_Manager::connectBridge()
             {
                 bool ret;
                 if (this->interfaceMode == BRICK_IS_SET_AS_AN_INTERFACE)
                 {
                     ret = connectBridgeAsInterface();
                 }
                 else if (this->interfaceMode == BRICK_IS_SET_AS_A_ROUTER)
                 {
                     ret = connectBridgeAsRouter();
                 }
                 else
                 {
                     ret = false;
                 }
                 return ret;
             }
             bool stardundeeSPW_USB_Manager::connectBridgeAsInterface()
             {
                 this->handleMutex->lock();
                 int status;
                 U32 statusControl;
                 this->connected = false;
                 if (!USBSpaceWire_Open(&hDevice, this->selectedBrick)) // Open the USB device
                 {
                     SocExplorerEngine::message(this->plugin,"stardundee *** Open *** ERROR: USBSpaceWire_Open(&hDevice, 0))",0);
                     this->handleMutex->unlock();
                     return false;
                 }
                 SocExplorerEngine::message(this->plugin,"stardundee *** Open *** USBSpaceWire_Open successful",0);
                 USBSpaceWire_EnableNetworkMode(hDevice, 0); // deactivate the network mode
                 CFGSpaceWire_EnableRMAP(1);                 // Enable the use of RMAP for the StarDundee brick configuration
                 CFGSpaceWire_SetRMAPDestinationKey(0x20);   // Set the destination key expected by STAR-Dundee devices
                 // Set the path and return path to the device
                 CFGSpaceWire_StackClear();
                 CFGSpaceWire_AddrStackPush(0);
                 CFGSpaceWire_AddrStackPush(254);
                 CFGSpaceWire_RetAddrStackPush(254);
                 // set the base transmit rate to 100 MHz
                 status = CFGSpaceWire_SetBrickBaseTransmitRate( hDevice, CFG_BRK_CLK_100_MHZ, CFG_BRK_DVDR_1, 0xff);
                 if (status != CFG_TRANSFER_SUCCESS)
                 {
                     SocExplorerEngine::message(this->plugin,"ERROR CFGSpaceWire_SetBrickBaseTransmitRate",1);
                     this->handleMutex->unlock();
                     return false;
                 }
                 else
                 {
                     SocExplorerEngine::message(this->plugin,"OK CFGSpaceWire_SetBrickBaseTransmitRate, base rate = 100 MHz",1);
                 }
                 // read the link status
                 if (CFGSpaceWire_GetLinkStatusControl(hDevice, this->linkNumber, &statusControl) != CFG_TRANSFER_SUCCESS)
                 {
                     SocExplorerEngine::message(this->plugin,"Could not read link status control for link " + QString::number(this->linkNumber),1);
                     this->handleMutex->unlock();
                     return false;
                 }
                 else
                 {
                     SocExplorerEngine::message(this->plugin,"OK CFGSpaceWire_GetLinkStatusControl of link " + QString::number(this->linkNumber),1);
                     // Set the link status control register properties
                     CFGSpaceWire_LSEnableAutoStart(&statusControl, 1);
                     CFGSpaceWire_LSEnableStart(&statusControl, 1);
                     CFGSpaceWire_LSEnableDisabled(&statusControl, 0);
                     CFGSpaceWire_LSEnableTristate(&statusControl, 0);
                     CFGSpaceWire_LSSetOperatingSpeed(&statusControl, 9);    // sets the link speed to ( 100 MHz / (9+1) ) = 10 MHz
                     // Set the link status control register
                     if (CFGSpaceWire_SetLinkStatusControl(hDevice, this->linkNumber, statusControl) != CFG_TRANSFER_SUCCESS)
                     {
                         SocExplorerEngine::message(this->plugin,"Could not set the link status control for link " + QString::number(this->linkNumber),1);
                         this->handleMutex->unlock();
                         return false;
                     }
                     else
                     {
                         SocExplorerEngine::message(this->plugin,"Set the link status control for link " + QString::number(this->linkNumber),1);
                     }
                 }
                 if (CFGSpaceWire_SetAsInterface(hDevice, 1, 0) != CFG_TRANSFER_SUCCESS)
                 {
                     SocExplorerEngine::message(this->plugin,"Could not set the device to be an interface",1);
                     this->handleMutex->unlock();
                     return false;
                 }
                 else
                 {
                     SocExplorerEngine::message(this->plugin,"Device set to be an interface",1);
                 }
                 USBSpaceWire_RegisterReceiveOnAllPorts(hDevice);    // Register to receive on all ports
                 USBSpaceWire_ClearEndpoints(hDevice);               // clear the USB endpoints
                 USBSpaceWire_SetTimeout(hDevice,1.0);
                 this->handleMutex->unlock();
                 SocExplorerEngine::message(this->plugin,"The driver's current send buffer size is " + QString::number(USBSpaceWire_GetDriverSendBufferSize(hDevice)) + " bytes",1);
                 SocExplorerEngine::message(this->plugin,"The driver's current read buffer size is " + QString::number(USBSpaceWire_GetDriverReadBufferSize(hDevice)) + " bytes",1);
                 SocExplorerEngine::message(this->plugin,"USBSpaceWire_IsReadThrottling is " + QString::number(USBSpaceWire_IsReadThrottling(hDevice)),1);
                 this->connected = true;
                 return true;
             }
             bool stardundeeSPW_USB_Manager::connectBridgeAsRouter()
             {
             //    QMutexLocker mlock(&this->handleMutex);
                 this->handleMutex->lock();
                 int status;
                 U32 statusControl;
                 unsigned int linkStatus1;
                 unsigned int linkStatus2;
                 unsigned char linkNumber;
                 unsigned char deviceIsAnInterface;
                 if (!USBSpaceWire_Open(&hDevice, this->selectedBrick)) // Open the USB device
                 {
                     SocExplorerEngine::message(this->plugin,"stardundee *** Open *** ERROR: USBSpaceWire_Open(&hDevice, 0))");
                     this->handleMutex->unlock();
                     return false;
                 }
                 SocExplorerEngine::message(this->plugin,"stardundee *** Open *** USBSpaceWire_Open successful, device number: "
                                  + QString::number(this->selectedBrick));
                 USBSpaceWire_EnableNetworkMode(hDevice, 0); // deactivate the network mode
                 CFGSpaceWire_EnableRMAP(1);                 // Enable the use of RMAP for the StarDundee brick configuration
                 CFGSpaceWire_SetRMAPDestinationKey(0x20);   // Set the destination key expected by STAR-Dundee devices
                 // Set the path and return path to the device
                 // This affects just the operations performed by the Configuration Library and does not affect the packets
                 // sent and received using the driver API.
                 CFGSpaceWire_StackClear();
                 CFGSpaceWire_AddrStackPush(0);
                 CFGSpaceWire_AddrStackPush(254);
                 CFGSpaceWire_RetAddrStackPush(254);
                 // set the base transmit rate to 100 MHz
                 status = CFGSpaceWire_SetBrickBaseTransmitRate( hDevice, CFG_BRK_CLK_100_MHZ, CFG_BRK_DVDR_1, 0xff);
                 if (status != CFG_TRANSFER_SUCCESS)
                 {
                     SocExplorerEngine::message(this->plugin,"ERROR CFGSpaceWire_SetBrickBaseTransmitRate");
                 }
                 else SocExplorerEngine::message(this->plugin,"OK CFGSpaceWire_SetBrickBaseTransmitRate, base rate = 100 MHz");
                 //*********************
                 // LINK 1 CONFIGURATION
                 linkNumber = 1;
                 if (CFGSpaceWire_GetLinkStatusControl(hDevice, linkNumber, &statusControl) != CFG_TRANSFER_SUCCESS)
                     SocExplorerEngine::message(this->plugin,"Could not read link status control for link " + QString::number(linkNumber));
                 else
                 {
                     SocExplorerEngine::message(this->plugin,"OK CFGSpaceWire_GetLinkStatusControl of link " + QString::number(linkNumber));
                     // Set the link status control register properties
                     CFGSpaceWire_LSEnableAutoStart(&statusControl, 1);
                     CFGSpaceWire_LSEnableStart(&statusControl, 1);
                     CFGSpaceWire_LSEnableDisabled(&statusControl, 0);
                     CFGSpaceWire_LSEnableTristate(&statusControl, 0);
                     CFGSpaceWire_LSSetOperatingSpeed(&statusControl, 9);    // sets the link speed to ( 100 MHz / (9+1) ) = 10 MHz
                     // Set the link status control register
                     if (CFGSpaceWire_SetLinkStatusControl(hDevice, linkNumber, statusControl) != CFG_TRANSFER_SUCCESS)
                         SocExplorerEngine::message(this->plugin,"Could not set the link status control for link " + QString::number(linkNumber));
                     else
                         SocExplorerEngine::message(this->plugin,"link status control for link " + QString::number(0x01) + " is set");
                 }
                 //*********************
                 // LINK 2 CONFIGURATION
                 linkNumber = 2;
                 if (CFGSpaceWire_GetLinkStatusControl(hDevice, linkNumber, &statusControl) != CFG_TRANSFER_SUCCESS)
                     SocExplorerEngine::message(this->plugin,"Could not read link status control for link " + QString::number(linkNumber));
                 else
                 {
                     SocExplorerEngine::message(this->plugin,"OK CFGSpaceWire_GetLinkStatusControl of link " + QString::number(linkNumber));
                     // Set the link status control register properties
                     CFGSpaceWire_LSEnableAutoStart(&statusControl, 1);
                     CFGSpaceWire_LSEnableStart(&statusControl, 1);
                     CFGSpaceWire_LSEnableDisabled(&statusControl, 0);
                     CFGSpaceWire_LSEnableTristate(&statusControl, 0);
                     CFGSpaceWire_LSSetOperatingSpeed(&statusControl, 9);    // sets the link speed to ( 100 MHz / (9+1) ) = 10 MHz
                     // Set the link status control register
                     if (CFGSpaceWire_SetLinkStatusControl(hDevice, linkNumber, statusControl) != CFG_TRANSFER_SUCCESS)
                         SocExplorerEngine::message(this->plugin,"Could not set the link status control for link " + QString::number(linkNumber));
                     else
                         SocExplorerEngine::message(this->plugin,"link status control for link " + QString::number(linkNumber) + " is set");
                 }
                 //***************************
                 // SET THE DEVICE AS A ROUTER
                 deviceIsAnInterface = 0;    // 0 = router, 1 = interface
                 if (CFGSpaceWire_SetAsInterface(hDevice, deviceIsAnInterface, 0) != CFG_TRANSFER_SUCCESS)
                     SocExplorerEngine::message(this->plugin,"Could not set the device to be an interface");
                 else
                     SocExplorerEngine::message(this->plugin,"Device is an interface: " + QString::number(deviceIsAnInterface) + " (1 => true, 0 => false)");
                 setRoutingTableEntry(0xfe, 0x02, 0); // [0010] => route 0xfe on port 1
                 setRoutingTableEntry(32  , 0x08, 0); // [1000] => route 32   on port 3
                 USBSpaceWire_RegisterReceiveOnAllPorts(hDevice);  // Register to receive on port 1 only
                 USBSpaceWire_ClearEndpoints(hDevice);               // clear the USB endpoints
                 SocExplorerEngine::message(this->plugin,"The driver's current send buffer size is " + QString::number(USBSpaceWire_GetDriverSendBufferSize(hDevice)) + " bytes");
                 SocExplorerEngine::message(this->plugin,"The driver's current read buffer size is " + QString::number(USBSpaceWire_GetDriverReadBufferSize(hDevice)) + " bytes");
                 SocExplorerEngine::message(this->plugin,"USBSpaceWire_IsReadThrottling is " + QString::number(USBSpaceWire_IsReadThrottling(hDevice)));
                 //************
                 // test Link 1 and Link 2
                 linkStatus1 = getLinkStatus(0x01);
                 linkStatus2 = getLinkStatus(0x02);
                 this->handleMutex->unlock();
                 if ((linkStatus1==1) || (linkStatus2==1))
                 {
                     initializeTimecodeGeneration();
                     this->connected=true;
                     return true;
                 }
                 else
                 {
                     statusLink1->setText("Link 1 status code: " + QString::number(linkStatus1));
                     statusLink2->setText("Link 2 status code: " + QString::number(linkStatus2));
                     starDundeeStatusQueryDialog->exec();
                     this->connected = false;
                     return false;
                 }
             }
             void stardundeeSPW_USB_Manager::initDialog( void )
             {
                 // STAR DUNDEE STATUS QUERY DIALOG
                 starDundeeStatusQueryDialog         = new QDialog;
                 starDundeeStatusQueryDialogLayout   = new QGridLayout;
                 starDundeeStatusQueryDialogLabel    = new QLabel(tr("SpaceWire links state"));
                 starDundeeStatusQueryContinueButton = new QPushButton(tr("Continue"));
                 starDundeeStatusQueryRetryButton    = new QPushButton(tr("Retry"));
                 starDundeeStatusQueryAbortButton    = new QPushButton(tr("Abort"));
                 statusLink1 = new QLabel(tr("Link 1 status code: -"));
                 statusLink2 = new QLabel(tr("Link 2 status code: -"));
                 starDundeeStatusQueryDialogLayout->addWidget(starDundeeStatusQueryDialogLabel, 0, 0, 1, 2);
                 starDundeeStatusQueryDialogLayout->addWidget(starDundeeStatusQueryContinueButton, 1, 0, 0);
                 starDundeeStatusQueryDialogLayout->addWidget(starDundeeStatusQueryRetryButton, 1, 1, 0);
                 starDundeeStatusQueryDialogLayout->addWidget(starDundeeStatusQueryAbortButton, 1, 2, 0);
                 starDundeeStatusQueryDialogLayout->addWidget(statusLink1, 2, 0, 0);
                 starDundeeStatusQueryDialogLayout->addWidget(statusLink2, 3, 0, 0);
                 starDundeeStatusQueryDialog->setLayout(starDundeeStatusQueryDialogLayout);
             }
             unsigned char stardundeeSPW_USB_Manager::setRoutingTableEntry(int tableEntry, U32 dwOutputPorts, char bDelHead)
             {
                 U32 routingTableEntry;
                 // SET THE ROUTING TABLE ENTRY FOR LOGICAL ADDRESSING, TARGET entryNumber
                 if (CFGSpaceWire_ClearRoutingTableEntry(hDevice, tableEntry) != CFG_TRANSFER_SUCCESS)
                 {
                     SocExplorerEngine::message(this->plugin,"Could not clear routing table entry " + QString::number(tableEntry));
                 }
                 // Build the routing table entry
                 CFGSpaceWire_RTBuildRoutingTableEntry(&routingTableEntry,
                                                       dwOutputPorts,        // route out of port dwOutputPorts
                                                       bDelHead,             // header deletion is enabled [1] or disabled [0]
 );                   // priority normal
                 // Set the routing table entry for logical address tableEntry
                 if (CFGSpaceWire_SetRoutingTableEntry(hDevice, tableEntry, routingTableEntry) != CFG_TRANSFER_SUCCESS)
                 {
                     SocExplorerEngine::message(this->plugin,"Could not set routing table entry [" + QString::number(tableEntry) + "]");
                 }
                 else SocExplorerEngine::message(this->plugin,"Routing table entry [" + QString::number(tableEntry) + "] set" );
                 return 1;
             }
             unsigned int stardundeeSPW_USB_Manager::getRoutingTableEntry(int tableEntry)
             {
                 U32 routingTableEntry, outputPorts;
                 char enabled, delHead, priority;
                 int portNum;
                 SocExplorerEngine::message(this->plugin,"GetRoutingTableEntry [" + QString::number(tableEntry) + "]");
                 // Read the routing table entry
                 if (CFGSpaceWire_GetRoutingTableEntry(hDevice, tableEntry, &routingTableEntry) != CFG_TRANSFER_SUCCESS)
                 {
                     SocExplorerEngine::message(this->plugin,"Could not read routing table entry [" + QString::number(tableEntry) + "]");
                 }
                 else
                 {
                     // Display the routing table entry properties
                     CFGSpaceWire_RTIsEnabled(routingTableEntry, &enabled);
                     CFGSpaceWire_RTIsDelHead(routingTableEntry, &delHead);
                     CFGSpaceWire_RTIsPriority(routingTableEntry, &priority);
                     CFGSpaceWire_RTGetOutputPorts(routingTableEntry, &outputPorts);
                     SocExplorerEngine::message(this->plugin,"CFGSpaceWire_RTIsEnabled      : " + QString::number(enabled));
                     SocExplorerEngine::message(this->plugin,"CFGSpaceWire_RTIsDelHead      : " + QString::number(delHead));
                     SocExplorerEngine::message(this->plugin,"CFGSpaceWire_RTIsPriority     : " + QString::number(priority));
                     SocExplorerEngine::message(this->plugin,"CFGSpaceWire_RTGetOutputPorts : ");
                     for (portNum = 0; portNum < 32; portNum++)
                     {
                         if (outputPorts & (1 << portNum))
                         {
                             SocExplorerEngine::message(this->plugin,QString::number(portNum));
                         }
                     }
                 }
                 return 1;
             }
             void stardundeeSPW_USB_Manager::initializeTimecodeGeneration()
             {
                 U32 dwTickEnableStatus;
                 U32 rtr_clk_freq;
                 // (1) RESET
                 if (!USBSpaceWire_TC_Reset(hDevice))
                     SocExplorerEngine::message(this->plugin,"ERR *** in Open *** Could not reset timecodes\n");
                 // (2) Clear the tick enable register
                 if (CFGSpaceWire_SetTickEnableStatus(hDevice, 6) != CFG_TRANSFER_SUCCESS)
                     SocExplorerEngine::message(this->plugin,"Could not clear the tick enable register");
                 else
                     SocExplorerEngine::message(this->plugin,"Cleared the tick enable register");
                 // (3) get the tick status
                 CFGSpaceWire_GetTickEnableStatus(hDevice, &dwTickEnableStatus);
                 SocExplorerEngine::message(this->plugin,"OK *** in Open *** CFGSpaceWire_GetTickEnableStatus, code is " + QString::number(dwTickEnableStatus, 2));
                 // (4) enable external timecode selection
                 if(!USBSpaceWire_TC_EnableExternalTimecodeSelection(hDevice,0))
                     SocExplorerEngine::message(this->plugin,"ERR *** disable external timecode selection");
                 rtr_clk_freq = USBSpaceWire_TC_GetClockFrequency(hDevice);
                 SocExplorerEngine::message(this->plugin,"clock frequency = " + QString::number(rtr_clk_freq) );
                 //**************************************************
                 // auto _ tick _ freq = rtr _ clk _ freq / freqCount
                 if (!USBSpaceWire_TC_SetAutoTickInFrequency(hDevice, rtr_clk_freq) )
                     SocExplorerEngine::message(this->plugin,"Could not set the tick-in frequency");
             }
             unsigned int stardundeeSPW_USB_Manager::getLinkStatus(unsigned char link)
             {
                 U32 statusControl, errorStatus, portType;
                 U32 linkStatus, operatingSpeed, outputPortConnection;
                 char isLinkRunning, isAutoStart, isStart, isDisabled, isTristate;
                 // Read the link status control register
                 if (CFGSpaceWire_GetLinkStatusControl(hDevice, link, &statusControl) != CFG_TRANSFER_SUCCESS)
                 {
                     SocExplorerEngine::message(this->plugin,"Could not read link status control for link" + QString::number(link));
                 }
                 else
                 {
                     // Display the link status control register properties
                     CFGSpaceWire_LSPortType(statusControl, &portType);
                     if (portType == CFG_CONFIGURATION_PORT)
                     {
                         CFGSpaceWire_LSConfigErrorStatus(statusControl, &errorStatus);
                     }
                     else if (portType == CFG_SPACEWIRE_EXTERNAL_PORT)
                     {
                         CFGSpaceWire_LSExternalErrorStatus(statusControl, &errorStatus);
                     }
                     else
                     {
                         CFGSpaceWire_LSErrorStatus(statusControl, &errorStatus);
                     }
                     CFGSpaceWire_LSLinkState(statusControl, &linkStatus);
                     CFGSpaceWire_LSIsLinkRunning(statusControl, &isLinkRunning);
                     CFGSpaceWire_LSIsAutoStart(statusControl, &isAutoStart);
                     CFGSpaceWire_LSIsStart(statusControl, &isStart);
                     CFGSpaceWire_LSIsDisabled(statusControl, &isDisabled);
                     CFGSpaceWire_LSIsTristate(statusControl, &isTristate);
                     CFGSpaceWire_LSOperatingSpeed(statusControl, &operatingSpeed);
                     CFGSpaceWire_LSOutputPortConnection(statusControl, &outputPortConnection);
                 }
                 SocExplorerEngine::message(this->plugin,"status of link " + QString::number(link)
                                            +" is " + dwLinkStatusQString[linkStatus]);
                 if (linkStatus == 5)
                 {
                     return 1;
                 }
                 else return 0;
             }
             bool stardundeeSPW_USB_Manager::disconnectBridge()
             {
                 this->handleMutex->lock();
                 USBSpaceWire_Close(hDevice); // Close the device
                 SocExplorerEngine::message(this->plugin,"stardundee *** Close *** USBSpaceWire_Close, device: " + QString::number(0),0);
                 USBSpaceWire_UnregisterReceiveOnAllPorts(hDevice);  // Stop receiving on all ports
                 this->handleMutex->unlock();
                 this->RMAP_pending_transaction_IDsMtx->lock();
                 this->RMAP_pending_transaction_IDs.clear();
                 this->RMAP_pending_transaction_IDsMtx->unlock();
                 this->RMAP_AnswersMtx->lock();
                 this->RMAP_Answers.clear();
                 this->RMAP_AnswersMtx->unlock();
                 this->RMAP_AnswersSem->acquire(this->RMAP_AnswersSem->available());
                 return true;
             }
-            int stardundeeSPW_USB_Manager::getRMAPtransactionID()
-                this->RMAP_pending_transaction_IDsMtx->lock();
-                int  ID=0;
-                bool found=true;
-                while(ID<511)
-                    for(int i=0;i<RMAP_pending_transaction_IDs.count();i++)
-                        if(RMAP_pending_transaction_IDs[i]==ID)found=false;
-                    if(found==true)break;
-                    ID++;
-                    found = true;
-                if(found)
-                    RMAP_pending_transaction_IDs.append(ID);
-                this->RMAP_pending_transaction_IDsMtx->unlock();
-                return ID;
-            int stardundeeSPW_USB_Manager::getRMAPanswer(int transactionID, char **buffer)
-                QTime timeout;
-                *buffer=NULL;
-                int count=0;
-                SocExplorerEngine::message(this->plugin,"Looking for RMAP answer",2);
-                timeout.start();
-                while (*buffer==NULL)
-                    this->RMAP_AnswersMtx->lock();
-                    SocExplorerEngine::message(this->plugin,"Got exclusive access on RMAP_Answers stack",2);
-                    SocExplorerEngine::message(this->plugin,QString("%1 packet(s) available in RMAP_Answers stack").arg(RMAP_Answers.count()),2);
-                    for(int i=0;i<RMAP_Answers.count();i++)
-                        SocExplorerEngine::message(this->plugin,QString("Packet %1 ID=%2").arg(i).arg(RMAP_Answers[i]->transactionID),2);
-                        if(RMAP_Answers[i]->transactionID==transactionID)
-                            this->RMAP_pending_transaction_IDsMtx->lock();
-                            SocExplorerEngine::message(this->plugin,"Got exclusive access on RMAP_pending_transaction_ID stack",2);
-                            for(int j=0;j<RMAP_pending_transaction_IDs.count();j++)
-                                if(RMAP_pending_transaction_IDs[j]==transactionID)
-                                    RMAP_pending_transaction_IDs.removeAt(j);
-                            this->RMAP_pending_transaction_IDsMtx->unlock();
-                            *buffer = RMAP_Answers[i]->data;
-                            count = RMAP_Answers[i]->len;
-                            RMAP_Answer* tmp=RMAP_Answers[i];
-                            RMAP_Answers.removeAt(i);
-                            delete tmp;
-                    this->RMAP_AnswersMtx->unlock();
-                    //if no answer found in the stack wait until a new packet is pushed
-                    SocExplorerEngine::message(this->plugin,"waiting until a new packet is pushed",2);
-                    if(*buffer==NULL)
-                        while (0==this->RMAP_AnswersSem->available())
-                            SocExplorerEngine::message(this->plugin,QString("this->RMAP_AnswersSem->available() = %1").arg(this->RMAP_AnswersSem->available()),2);
-                            if(timeout.elapsed()>=RMAPtimeout)
-                                SocExplorerEngine::message(this->plugin,"Timeout reached giving up!",2);
-                                return -1;
-                            usleep(1000);
-                        this->RMAP_AnswersSem->acquire();
-                return count;
             bool stardundeeSPW_USB_Manager::sendPacket(char *packet, int size)
             {
                 char protocoleIdentifier;
                 USB_SPACEWIRE_STATUS result=TRANSFER_ERROR_NOT_FOUND;
                 USB_SPACEWIRE_ID pIdentifier;
                 SocExplorerEngine::message(this->plugin,"Sending SPW packet",2);
                 this->handleMutex->lock();
                 result = USBSpaceWire_SendPacket(hDevice,packet,size,1, &pIdentifier);
                 USBSpaceWire_FreeSend(hDevice, pIdentifier);
                 this->handleMutex->unlock();
                 if (result != TRANSFER_SUCCESS)
                 {
                     SocExplorerEngine::message(this->plugin,"ERR sending the READ command ",2);
                     return false;
                 }
                 else
                 {
                     emit bytesTransmittedToSpw( size-1 ); // -1 is for removing the first bytes added to the packet to route to the right link
                     // read the protocole identifier
                     protocoleIdentifier = packet[2];
                     if (protocoleIdentifier == SPW_PROTO_ID_CCSDS)
                             emit ccsdsPacketTransmittedToSpw();
                     SocExplorerEngine::message(this->plugin,"Packet sent",2);
                 }
                 return true;
             }
-            void stardundeeSPW_USB_Manager::pushRmapPacket(char *packet, int len)
-                char* packetbuffer = (char*)malloc(len);
-                memcpy(packetbuffer,packet,len);
-                RMAP_Answer* RMPAPpacket=new RMAP_Answer(RMAP_get_transactionID(packetbuffer+1),packetbuffer,len);
-                RMAP_AnswersMtx->lock();
-                RMAP_Answers.append(RMPAPpacket);
-                RMAP_AnswersMtx->unlock();
             void stardundeeSPW_USB_Manager::sendTimecodePeriodically( bool onOff )
             {
                 this->handleMutex->lock();
                 if (onOff == true)
                 {
                     if (!USBSpaceWire_TC_EnableAutoTickIn(hDevice, 1, 1))
                         SocExplorerEngine::message(this->plugin,"Could not enable auto tick-in");
                 }
                 else
                 {
                     if (!USBSpaceWire_TC_EnableAutoTickIn(hDevice, 0, 0))
                         SocExplorerEngine::message(this->plugin,"Could not disable auto tick-in");
                 }
                 this->handleMutex->unlock();
             }
             int stardundeeSPW_USB_Manager::getLinkNumber( void )
             {
                 return this->linkNumber;
             }
             void stardundeeSPW_USB_Manager::setTimecodeFrequency(double requestedFrequency)
             {
                 U32 rtr_clk_freq=0;
                 U32 freqCount=0;
                 double freqCountInDouble=0.0;
                 double currentFrequency=0.0;
                 this->handleMutex->lock();
                 rtr_clk_freq = USBSpaceWire_TC_GetClockFrequency(hDevice);
                 freqCountInDouble = ((double) rtr_clk_freq) / requestedFrequency;
                 freqCount = (unsigned int) freqCountInDouble;
                 currentFrequency = ((double) rtr_clk_freq) / ((double) freqCount);
                 //**************************************************
                 // auto _ tick _ freq = rtr _ clk _ freq / freqCount
                 if (!USBSpaceWire_TC_SetAutoTickInFrequency(hDevice, freqCount) )
                     SocExplorerEngine::message(this->plugin,"Could not set the tick-in frequency");
                 else
                     SocExplorerEngine::message(this->plugin,"tick frequency set to " + QString::number(currentFrequency) +" Hz"
                                                + " (freqCount set to " + QString::number(freqCount) + ")" );
                 this->handleMutex->unlock();
             }
             void stardundeeSPW_USB_Manager::sendOneTimecode( unsigned char nTimein )
             {
                 this->handleMutex->lock();
                 // enable external timecode selection
                 if(!USBSpaceWire_TC_EnableExternalTimecodeSelection(hDevice,1))
                     SocExplorerEngine::message(this->plugin,"sendOneTimecode *** ERR *** enable external timecode selection");
                 if (!USBSpaceWire_TC_PerformTickIn( hDevice, nTimein) )
                     SocExplorerEngine::message( this->plugin,"sendOneTimecode *** ERR *** Could not send the requested timecode: " + QString::number(nTimein) );
                 else
                     SocExplorerEngine::message( this->plugin,"sendOneTimecode *** OK *** timecode sent " + QString::number(nTimein) );
                 // disable external timecode selection
                 if(!USBSpaceWire_TC_EnableExternalTimecodeSelection(hDevice,0))
                     SocExplorerEngine::message(this->plugin,"sendOneTimecode *** ERR *** disable external timecode selection");
                 this->handleMutex->unlock();
             }

spwplugin/StarDundee/stardundeespw_usb.h +1 -15

             /*------------------------------------------------------------------------------
             --  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
             ----------------------------------------------------------------------------*/
             #ifndef STARDUNDEESPW_USB_H
             #define STARDUNDEESPW_USB_H
             #include <QObject>
             //#include <spw_usb_api.h>
             //#include <spw_config_library.h>
             #include "fakestardundeespwusb_lib.h"
             #include <socexplorerplugin.h>
             #include <abstractspwbridge.h>
             #include <QThread>
             #include <QMutex>
             #include <QSemaphore>
             #include <QGridLayout>
             #include <QPushButton>
             #include <QComboBox>
             #include <QLabel>
             #include "stardundeegui.h"
             #define BRICK_IS_SET_AS_AN_INTERFACE true
             #define BRICK_IS_SET_AS_A_ROUTER false
-            class stardundeeSPW_USB_Manager: public QThread
+            class stardundeeSPW_USB_Manager: public abstractSpwManager
             {
                 Q_OBJECT
             public:
                 explicit stardundeeSPW_USB_Manager(socexplorerplugin *plugin = 0,QObject* parent=0);
                 ~stardundeeSPW_USB_Manager();
                 void run();
                 bool connectBridge();
                 bool connectBridgeAsInterface();
                 bool connectBridgeAsRouter();
                 void initDialog( void );
                 unsigned char setRoutingTableEntry(int tableEntry, U32 dwOutputPorts, char bDelHead);
                 unsigned int getRoutingTableEntry(int tableEntry);
                 void initializeTimecodeGeneration();
                 void setTimecodeFrequency(double requestedFrequency);
                 unsigned int getLinkStatus(unsigned char link);
                 bool disconnectBridge();
-                int getRMAPtransactionID();
-                int getRMAPanswer(int transactionID,char** buffer);
                 bool sendPacket(char* packet,int size);
             signals:
                 void updateAvailableBrickCount(int count);
                 void emitPacket(char* packet,int size);
                 void bytesReceivedFromSpw( unsigned int );
                 void bytesTransmittedToSpw( unsigned int);
                 void ccsdsPacketTransmittedToSpw( void );
             public slots:
                 void sendTimecodePeriodically( bool onOff );
                 void sendOneTimecode(unsigned char nTimein);
                 int getLinkNumber( void );
             private:
-                QMutex *handleMutex,*RMAP_AnswersMtx,*RMAP_pending_transaction_IDsMtx;
                 QSemaphore* RMAP_AnswersSem;
-                void pushRmapPacket(char* packet,int len);
                 star_device_handle hDevice;
-                socexplorerplugin* plugin;
-                bool connected;
-                char* SPWPacketBuff;
-                QList<RMAP_Answer*> RMAP_Answers;
-                QList<int> RMAP_pending_transaction_IDs;
                 QLabel *starDundeeStatusQueryDialogLabel;
                 QPushButton *starDundeeStatusQueryRetryButton;
                 QPushButton *starDundeeStatusQueryAbortButton;
                 QLabel *statusLink1;
                 QLabel *statusLink2;
                 QPushButton *starDundeeStatusQueryContinueButton;
                 QDialog *starDundeeStatusQueryDialog;
                 QGridLayout *starDundeeStatusQueryDialogLayout;
             public:
                 int selectedBrick;
-                int linkNumber;
                 int brickList;
                 int linkSpeed;
-                int sourceLogicalAddress;
-                int destinationLogicalAddress;
-                int destinationKey;
-                int RMAPtimeout;
                 double timecodeFrequency;
                 bool interfaceMode; // 1 => interface mode, 0 => router mode
             };
             class stardundeeSPW_USB : public abstractSpwBridge
             {
                 Q_OBJECT
             public:
                 explicit stardundeeSPW_USB(socexplorerplugin *parent = 0);
                 ~stardundeeSPW_USB();
             signals:
                 void setRmapTimeout(const QString & timeout);
                 void SelectBrick(int brickIndex);
                 void SelectLinkNumber(int linkIndex);
                 void SelectLinkSpeed(int linkSpeed);
                 void SetDestinationKey(const QString & destKey);
                 void SetSourceAddress(const QString & address);
                 void SetDestinationAddress(const QString & address);
                 void SetRmapTimeout(const QString & timeout);
                 void SetTimecodeFrequency( double );
                 void SetBrickAsAnInterface( bool );
                 void SetBrickAsARouter( bool );
                 int GetAvailableBrickCount( void );
                 unsigned int GetNbPacketsTransmittedToSpw( void );
                 unsigned int GetNbCCSDSPacketsTransmittedToSpw( void );
                 void BytesReceivedFromSpw( unsigned int );
                 void BytesTransmittedToSpw( unsigned int );
                 void CCSDSPacketTransmittedToSpw( void );
                 void StartSendingTimecodes( bool );
                 void SendOneTimecode( unsigned char );
                 int GetLinkNumber();
             public slots:
                 void toggleBridgeConnection();
                 bool connectBridge();
                 bool disconnectBridge();
                 int  pushRMAPPacket(char* packet,int size);
                 unsigned int Write(unsigned int *Value,unsigned int count, unsigned int address=0);
                 unsigned int Read(unsigned int *Value,unsigned int count, unsigned int address=0);
                 void brickSelectionChanged(int brickIndex);
                 void linkNumberSelectionChanged(int linkIndex);
                 void linkSpeedSelectionChanged(const QString & linkSpeed);
                 void sourceLogicalAddressChanged(const QString & destKey);
                 void destinationAddressChanged(const QString & rmapaddress);
                 void brickModeChanged( bool interfaceMode );
                 void destinationKeyChanged(const QString & key);
                 void rmapTimeoutChanged(const QString & timeout);
                 void sendPacketComingFromTCPServer(char *packet, int size);
                 void timecodeFrequencyChanged(const QString &frequency);
                 void startSendingTimecodes( bool onOff );
             private:
                 void makeGUI(socexplorerplugin *parent);
                 stardundeeSPW_USB_Manager* manager;
             };
             #endif // STARDUNDEESPW_USB_H

spwplugin/abstractspwbridge.cpp +120 0

@@ -1,56 +1,176
1	/*------------------------------------------------------------------------------	1	/*------------------------------------------------------------------------------
2	-- This file is a part of the SocExplorer Software	2	-- This file is a part of the SocExplorer Software
3	-- Copyright (C) 2014, Plasma Physics Laboratory - CNRS	3	-- Copyright (C) 2014, Plasma Physics Laboratory - CNRS
4	--	4	--
5	-- This program is free software; you can redistribute it and/or modify	5	-- This program is free software; you can redistribute it and/or modify
6	-- it under the terms of the GNU General Public License as published by	6	-- it under the terms of the GNU General Public License as published by
7	-- the Free Software Foundation; either version 3 of the License, or	7	-- the Free Software Foundation; either version 3 of the License, or
8	-- (at your option) any later version.	8	-- (at your option) any later version.
9	--	9	--
10	-- This program is distributed in the hope that it will be useful,	10	-- This program is distributed in the hope that it will be useful,
11	-- but WITHOUT ANY WARRANTY; without even the implied warranty of	11	-- but WITHOUT ANY WARRANTY; without even the implied warranty of
12	-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	12	-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13	-- GNU General Public License for more details.	13	-- GNU General Public License for more details.
14	--	14	--
15	-- You should have received a copy of the GNU General Public License	15	-- You should have received a copy of the GNU General Public License
16	-- along with this program; if not, write to the Free Software	16	-- along with this program; if not, write to the Free Software
17	-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA	17	-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18	-------------------------------------------------------------------------------*/	18	-------------------------------------------------------------------------------*/
19	/*-- Author : Alexis Jeandet	19	/*-- Author : Alexis Jeandet
20	-- Mail : alexis.jeandet@member.fsf.org	20	-- Mail : alexis.jeandet@member.fsf.org
21	----------------------------------------------------------------------------*/	21	----------------------------------------------------------------------------*/
22	#include "abstractspwbridge.h"	22	#include "abstractspwbridge.h"
		23	#include <QTime>
		24	#include <socexplorerengine.h>
23		25
24	abstractSpwBridge::abstractSpwBridge(socexplorerplugin *parent)	26	abstractSpwBridge::abstractSpwBridge(socexplorerplugin *parent)
25	:QObject((QObject*)parent)	27	:QObject((QObject*)parent)
26	{	28	{
27	this->plugin = parent;	29	this->plugin = parent;
28	this->p_GUI=NULL;	30	this->p_GUI=NULL;
29	}	31	}
30		32
31	abstractSpwBridge::~abstractSpwBridge()	33	abstractSpwBridge::~abstractSpwBridge()
32	{	34	{
33	// delete this->p_GUI;	35	// delete this->p_GUI;
34	}	36	}
35		37
36	QWidget *abstractSpwBridge::getGUI()	38	QWidget *abstractSpwBridge::getGUI()
37	{	39	{
38	return this->p_GUI;	40	return this->p_GUI;
39	}	41	}
40		42
41	bool abstractSpwBridge::connectBridge()	43	bool abstractSpwBridge::connectBridge()
42	{	44	{
43	return false;	45	return false;
44	}	46	}
45		47
46	bool abstractSpwBridge::disconnectBridge()	48	bool abstractSpwBridge::disconnectBridge()
47	{	49	{
48	return false;	50	return false;
49	}	51	}
50		52
51		53
52		54
53		55
54		56
55		57
56		58
		59
		60
		61	abstractSpwManager::abstractSpwManager(socexplorerplugin plugin, QObject parent)
		62	:QThread((QObject*)parent)
		63	{
		64	this->RMAPtimeout = 2000;
		65	this->handleMutex = new QMutex(QMutex::NonRecursive);
		66	this->RMAP_AnswersSem = new QSemaphore(0);
		67	this->RMAP_AnswersMtx=new QMutex(QMutex::Recursive);
		68	this->RMAP_pending_transaction_IDsMtx=new QMutex(QMutex::Recursive);
		69	this->plugin = plugin;
		70	connected = false;
		71	}
		72
		73	abstractSpwManager::~abstractSpwManager()
		74	{
		75	this->terminate();
		76	while (!this->isFinished())
		77	{
		78	this->usleep(1000);
		79	}
		80	}
		81
		82	int abstractSpwManager::getRMAPtransactionID()
		83	{
		84	this->RMAP_pending_transaction_IDsMtx->lock();
		85	int ID=0;
		86	bool found=true;
		87	while(ID<511)
		88	{
		89	for(int i=0;i<RMAP_pending_transaction_IDs.count();i++)
		90	{
		91	if(RMAP_pending_transaction_IDs[i]==ID)found=false;
		92	}
		93	if(found==true)break;
		94	ID++;
		95	found = true;
		96	}
		97	if(found)
		98	{
		99	RMAP_pending_transaction_IDs.append(ID);
		100	}
		101	this->RMAP_pending_transaction_IDsMtx->unlock();
		102	return ID;
		103	}
		104
		105	int abstractSpwManager::getRMAPanswer(int transactionID, char **buffer)
		106	{
		107
		108	QTime timeout;
		109	*buffer=NULL;
		110	int count=0;
		111	SocExplorerEngine::message(this->plugin,"Looking for RMAP answer",2);
		112	timeout.start();
		113	while (*buffer==NULL)
		114	{
		115	this->RMAP_AnswersMtx->lock();
		116	SocExplorerEngine::message(this->plugin,"Got exclusive access on RMAP_Answers stack",2);
		117	SocExplorerEngine::message(this->plugin,QString("%1 packet(s) available in RMAP_Answers stack").arg(RMAP_Answers.count()),2);
		118	for(int i=0;i<RMAP_Answers.count();i++)
		119	{
		120	SocExplorerEngine::message(this->plugin,QString("Packet %1 ID=%2").arg(i).arg(RMAP_Answers[i]->transactionID),2);
		121	if(RMAP_Answers[i]->transactionID==transactionID)
		122	{
		123	this->RMAP_pending_transaction_IDsMtx->lock();
		124	SocExplorerEngine::message(this->plugin,"Got exclusive access on RMAP_pending_transaction_ID stack",2);
		125	for(int j=0;j<RMAP_pending_transaction_IDs.count();j++)
		126	{
		127	if(RMAP_pending_transaction_IDs[j]==transactionID)
		128	{
		129	RMAP_pending_transaction_IDs.removeAt(j);
		130	}
		131	}
		132	this->RMAP_pending_transaction_IDsMtx->unlock();
		133	*buffer = RMAP_Answers[i]->data;
		134	count = RMAP_Answers[i]->len;
		135	RMAP_Answer* tmp=RMAP_Answers[i];
		136	RMAP_Answers.removeAt(i);
		137	delete tmp;
		138	}
		139	}
		140	this->RMAP_AnswersMtx->unlock();
		141	//if no answer found in the stack wait until a new packet is pushed
		142	SocExplorerEngine::message(this->plugin,"waiting until a new packet is pushed",2);
		143	if(*buffer==NULL)
		144	{
		145	while (0==this->RMAP_AnswersSem->available())
		146	{
		147	SocExplorerEngine::message(this->plugin,QString("this->RMAP_AnswersSem->available() = %1").arg(this->RMAP_AnswersSem->available()),2);
		148	if(timeout.elapsed()>=RMAPtimeout)
		149	{
		150	SocExplorerEngine::message(this->plugin,"Timeout reached giving up!",2);
		151	return -1;
		152	}
		153	usleep(1000);
		154	}
		155	this->RMAP_AnswersSem->acquire();
		156	}
		157	}
		158	return count;
		159	}
		160
		161	int abstractSpwManager::getLinkNumber()
		162	{
		163	return this->linkNumber;
		164	}
		165
		166	void abstractSpwManager::pushRmapPacket(char *packet, int len)
		167	{
		168	char* packetbuffer = (char*)malloc(len);
		169	memcpy(packetbuffer,packet,len);
		170	RMAP_Answer* RMPAPpacket=new RMAP_Answer(RMAP_get_transactionID(packetbuffer+1),packetbuffer,len);
		171	RMAP_AnswersMtx->lock();
		172	RMAP_Answers.append(RMPAPpacket);
		173	RMAP_AnswersMtx->unlock();
		174	}
		175
		176

spwplugin/abstractspwbridge.h +42 0

             /*------------------------------------------------------------------------------
             --  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
             ----------------------------------------------------------------------------*/
             #ifndef ABSTRACTSPWBRIDGE_H
             #define ABSTRACTSPWBRIDGE_H
             #include <QObject>
+            #include <QThread>
+            #include <QMutex>
+            #include <QSemaphore>
             #include <socexplorerplugin.h>
             #define RMAP_MAX_XFER_SIZE 4000 //slightly less than 16kBytes
             #include <spw.h>
             class RMAP_Answer
             {
               public:
                 RMAP_Answer(int ID,char* data,int len)
                 {
                     transactionID = ID;
                     this->data = data;
                     this->len = len;
                 }
                 int transactionID;
                 char* data;
                 int len;
             };
             class abstractSpwBridge : public QObject
             {
                 Q_OBJECT
             public:
                 explicit abstractSpwBridge(socexplorerplugin *parent);
                 ~abstractSpwBridge();
                 QWidget *getGUI();
             public slots:
                 virtual bool connectBridge();
                 virtual bool disconnectBridge();
                 virtual unsigned int Write(unsigned int *Value,unsigned int count, unsigned int address=0)=0;
                 virtual unsigned int Read(unsigned int *Value,unsigned int count, unsigned int address=0)=0;
                 virtual int pushRMAPPacket(char* packet,int size)=0;
             signals:
                 void setConnected(bool connected);
                 void pushPacketOverTCP(char* packet,int size);
             protected:
                 socexplorerplugin* plugin;
                 QWidget* p_GUI;
             private:
             };
+            class abstractSpwManager: public QThread
+            {
+                Q_OBJECT
+            public:
+                explicit abstractSpwManager(socexplorerplugin *plugin = 0,QObject* parent=0);
+                ~abstractSpwManager();
+                virtual void run(){}
+                virtual bool connectBridge()=0;
+                virtual bool disconnectBridge()=0;
+                int getRMAPtransactionID();
+                int getRMAPanswer(int transactionID,char** buffer);
+                virtual bool sendPacket(char* packet,int size)=0;
+                int RMAPtimeout;
+                int linkNumber;
+                int sourceLogicalAddress;
+                int destinationLogicalAddress;
+                int destinationKey;
+            signals:
+                void emitPacket(char* packet,int size);
+                void bytesReceivedFromSpw( unsigned int );
+                void bytesTransmittedToSpw( unsigned int);
+                void ccsdsPacketTransmittedToSpw( void );
+            public slots:
+                int getLinkNumber();
+            protected:
+                QList<RMAP_Answer*> RMAP_Answers;
+                QList<int> RMAP_pending_transaction_IDs;
+                QMutex *handleMutex,*RMAP_AnswersMtx,*RMAP_pending_transaction_IDsMtx;
+                QSemaphore* RMAP_AnswersSem;
+                socexplorerplugin* plugin;
+                bool connected;
+                void pushRmapPacket(char* packet,int len);
+            };
             #endif // ABSTRACTSPWBRIDGE_H

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages