HG_REPOSITORIES/LPP/INSTRUMENTATION/SocExplorerPlugins Commit - r8:aeda472c02a8

Space wire plugin GUI Work In Progress.

Jeandet Alexis -

r8:aeda472c02a8 default

parent child

Context file:

r8:aeda472c02a8

Collapse all files

spwplugin/abstractspwbridge.cpp +22 0

+            /*------------------------------------------------------------------------------
+            --  This file is a part of the SocExplorer Software
+            --  Copyright (C) 2014, Laboratory of Plasmas Physic - 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 "abstractspwbridge.h"
             abstractSpwBridge::abstractSpwBridge(socexplorerplugin *parent)
                 :QObject((QObject*)parent)
             {
                 this->plugin = parent;
+                this->p_GUI=NULL;
             }
             QWidget *abstractSpwBridge::getGUI()
             {
                 return this->p_GUI;
             }
             bool abstractSpwBridge::connectBridge()
             {
                 return false;
             }
             bool abstractSpwBridge::disconnectBridge()
             {
                 return false;
             }

spwplugin/abstractspwbridge.h +21 0

+            /*------------------------------------------------------------------------------
+            --  This file is a part of the SocExplorer Software
+            --  Copyright (C) 2014, Laboratory of Plasmas Physic - 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 <socexplorerplugin.h>
             #define RMAP_MAX_XFER_SIZE 4000 //slightly less than 16kBytes
             #include <spw.h>
             class abstractSpwBridge : public QObject
             {
                 Q_OBJECT
             public:
                 explicit abstractSpwBridge(socexplorerplugin *parent);
                 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;
             protected:
                 socexplorerplugin* plugin;
                 QWidget* p_GUI;
             private:
             };
             #endif // ABSTRACTSPWBRIDGE_H

spwplugin/spw.h +21 0

+            /*------------------------------------------------------------------------------
+            --  This file is a part of the SocExplorer Software
+            --  Copyright (C) 2014, Laboratory of Plasmas Physic - 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 SPW_H
             #define SPW_H
             #include <stdint.h>
             /*
             ███████╗██████╗ ██╗    ██╗     ██████╗ ██████╗ ███╗   ███╗███╗   ███╗ ██████╗ ███╗   ██╗
             ██╔════╝██╔══██╗██║    ██║    ██╔════╝██╔═══██╗████╗ ████║████╗ ████║██╔═══██╗████╗  ██║
             ███████╗██████╔╝██║ █╗ ██║    ██║     ██║   ██║██╔████╔██║██╔████╔██║██║   ██║██╔██╗ ██║
             ╚════██║██╔═══╝ ██║███╗██║    ██║     ██║   ██║██║╚██╔╝██║██║╚██╔╝██║██║   ██║██║╚██╗██║
             ███████║██║     ╚███╔███╔╝    ╚██████╗╚██████╔╝██║ ╚═╝ ██║██║ ╚═╝ ██║╚██████╔╝██║ ╚████║
             ╚══════╝╚═╝      ╚══╝╚══╝      ╚═════╝ ╚═════╝ ╚═╝     ╚═╝╚═╝     ╚═╝ ╚═════╝ ╚═╝  ╚═══╝
             */
             enum SPW_PROTOCOL_IDs{
                 SPW_PROTO_ID_EXTEND =0,
                 SPW_PROTO_ID_RMAP = 1,
                 SPW_PROTO_ID_CCSDS = 2,
                 SPW_PROTO_ID_GOES_R = 238,
                 SPW_PROTO_ID_STUP = 239
             };
             static const unsigned char SPW_CRCTable[] = {
 x00, 0x91, 0xe3, 0x72, 0x07, 0x96, 0xe4, 0x75,
 x0e, 0x9f, 0xed, 0x7c, 0x09, 0x98, 0xea, 0x7b,
 x1c, 0x8d, 0xff, 0x6e, 0x1b, 0x8a, 0xf8, 0x69,
 x12, 0x83, 0xf1, 0x60, 0x15, 0x84, 0xf6, 0x67,
 x38, 0xa9, 0xdb, 0x4a, 0x3f, 0xae, 0xdc, 0x4d,
 x36, 0xa7, 0xd5, 0x44, 0x31, 0xa0, 0xd2, 0x43,
 x24, 0xb5, 0xc7, 0x56, 0x23, 0xb2, 0xc0, 0x51,
 x2a, 0xbb, 0xc9, 0x58, 0x2d, 0xbc, 0xce, 0x5f,
 x70, 0xe1, 0x93, 0x02, 0x77, 0xe6, 0x94, 0x05,
 x7e, 0xef, 0x9d, 0x0c, 0x79, 0xe8, 0x9a, 0x0b,
 x6c, 0xfd, 0x8f, 0x1e, 0x6b, 0xfa, 0x88, 0x19,
 x62, 0xf3, 0x81, 0x10, 0x65, 0xf4, 0x86, 0x17,
 x48, 0xd9, 0xab, 0x3a, 0x4f, 0xde, 0xac, 0x3d,
 x46, 0xd7, 0xa5, 0x34, 0x41, 0xd0, 0xa2, 0x33,
 x54, 0xc5, 0xb7, 0x26, 0x53, 0xc2, 0xb0, 0x21,
 x5a, 0xcb, 0xb9, 0x28, 0x5d, 0xcc, 0xbe, 0x2f,
 xe0, 0x71, 0x03, 0x92, 0xe7, 0x76, 0x04, 0x95,
 xee, 0x7f, 0x0d, 0x9c, 0xe9, 0x78, 0x0a, 0x9b,
 xfc, 0x6d, 0x1f, 0x8e, 0xfb, 0x6a, 0x18, 0x89,
 xf2, 0x63, 0x11, 0x80, 0xf5, 0x64, 0x16, 0x87,
 xd8, 0x49, 0x3b, 0xaa, 0xdf, 0x4e, 0x3c, 0xad,
 xd6, 0x47, 0x35, 0xa4, 0xd1, 0x40, 0x32, 0xa3,
 xc4, 0x55, 0x27, 0xb6, 0xc3, 0x52, 0x20, 0xb1,
 xca, 0x5b, 0x29, 0xb8, 0xcd, 0x5c, 0x2e, 0xbf,
 x90, 0x01, 0x73, 0xe2, 0x97, 0x06, 0x74, 0xe5,
 x9e, 0x0f, 0x7d, 0xec, 0x99, 0x08, 0x7a, 0xeb,
 x8c, 0x1d, 0x6f, 0xfe, 0x8b, 0x1a, 0x68, 0xf9,
 x82, 0x13, 0x61, 0xf0, 0x85, 0x14, 0x66, 0xf7,
 xa8, 0x39, 0x4b, 0xda, 0xaf, 0x3e, 0x4c, 0xdd,
 xa6, 0x37, 0x45, 0xd4, 0xa1, 0x30, 0x42, 0xd3,
 xb4, 0x25, 0x57, 0xc6, 0xb3, 0x22, 0x50, 0xc1,
 xba, 0x2b, 0x59, 0xc8, 0xbd, 0x2c, 0x5e, 0xcf
             };
             inline unsigned char _spw_CRC_(unsigned char INCR, unsigned char INBYTE)
             {
                 return SPW_CRCTable[INCR ^ INBYTE];
             }
             inline  char spw_CRC(char* buffer, int size)
             {
                 unsigned char CRC = 0;
                 for(int i=0;i<size;i++)
                 {
                     CRC = _spw_CRC_(CRC,(unsigned char)buffer[i]);
                 }
                 return CRC;
             }
             /*
             ██████╗ ███╗   ███╗ █████╗ ██████╗     ██████╗ ██████╗  ██████╗ ████████╗ ██████╗  ██████╗ ██████╗ ██╗
             ██╔══██╗████╗ ████║██╔══██╗██╔══██╗    ██╔══██╗██╔══██╗██╔═══██╗╚══██╔══╝██╔═══██╗██╔════╝██╔═══██╗██║
             ██████╔╝██╔████╔██║███████║██████╔╝    ██████╔╝██████╔╝██║   ██║   ██║   ██║   ██║██║     ██║   ██║██║
             ██╔══██╗██║╚██╔╝██║██╔══██║██╔═══╝     ██╔═══╝ ██╔══██╗██║   ██║   ██║   ██║   ██║██║     ██║   ██║██║
             ██║  ██║██║ ╚═╝ ██║██║  ██║██║         ██║     ██║  ██║╚██████╔╝   ██║   ╚██████╔╝╚██████╗╚██████╔╝███████╗
             ╚═╝  ╚═╝╚═╝     ╚═╝╚═╝  ╚═╝╚═╝         ╚═╝     ╚═╝  ╚═╝ ╚═════╝    ╚═╝    ╚═════╝  ╚═════╝ ╚═════╝ ╚══════╝
             */
             enum RMAP_CMD_CODE{
                 RMAP_CMD_CODE_invalid0,                   //0000
                 RMAP_CMD_CODE_invalid1,                   //0001
                 RMAP_CMD_CODE_read_Single,                //0010
                 RMAP_CMD_CODE_read_Inc,                   //0011
                 RMAP_CMD_CODE_invalid2,                   //0100
                 RMAP_CMD_CODE_invalid3,                   //0101
                 RMAP_CMD_CODE_invalid4,                   //0110
                 RMAP_CMD_CODE_readModWri_Inc,             //0111
                 RMAP_CMD_CODE_writeSingle_noVer_noRep,    //1000
                 RMAP_CMD_CODE_writeInc_noVer_noRep,       //1001
                 RMAP_CMD_CODE_writeSingle_noVer_Rep,      //1010
                 RMAP_CMD_CODE_writeInc_noVer_Rep,         //1011
                 RMAP_CMD_CODE_writeSingle_ver_noRep,      //1100
                 RMAP_CMD_CODE_writeInc_ver_noRep,         //1101
                 RMAP_CMD_CODE_writeSingle_ver_rep,        //1110
                 RMAP_CMD_CODE_writeInc_ver_rep            //1111
             };
             /*
              *   Rmap read command header:
              *
              *  | Destination Logical Address | Protocol identifier    | Packet type            | Destination key        |
              *  |-----------------------------|------------------------|------------------------|------------------------|
              *  | Source Logical Address      | Transaction identifier | Transaction identifier | Extended read address  |
              *  |-----------------------------|------------------------|------------------------|------------------------|
              *  | Read  address MSB           | Read  address          | Read  address          | Read  address LSB      |
              *  |-----------------------------|------------------------|------------------------|------------------------|
              *  | Data length MSB             | Data length            | Data length LSB        | CRC                    |
              *  |-----------------------------|------------------------|------------------------|------------------------|
              *
              * Packet type field:
              *
              *  | msb
              *  | reserved = 0 | Comand = 1| Read = 0 | Read = 0 | Read = 1    | Increment/      | Source Path    | Source Path    |
              *                                                   | (Ack/NoAck) | No Inc. address | Address Length | Address Length |
              *
             */
             #define RMAP_READ_HEADER_MIN_SZ 16
             inline void RMAP_build_rx_request_header(char destinationLogicalAddress, char destKey,char sourceLogicalAddress,uint16_t transactionID,int readAddress,int length,char *buffer)
             {
                 buffer[0] = destinationLogicalAddress;
                 buffer[1] = SPW_PROTO_ID_RMAP;
                 buffer[2] = 0b01001100;
                 buffer[3] = destKey;
                 buffer[4] = sourceLogicalAddress;
                 buffer[5] = (char)(transactionID >> 8);
                 buffer[6] = (char)(transactionID);
                 buffer[7] = 0;
                 buffer[8] = (char)(readAddress >> 24);
                 buffer[9] = (char)(readAddress >> 16);
                 buffer[10] = (char)(readAddress >> 8);
                 buffer[11] = (char)(readAddress);
                 buffer[12] = (char)(length >> 16);
                 buffer[13] = (char)(length >> 8);
                 buffer[14] = (char)(length);
                 buffer[15] = (char)spw_CRC(buffer,15);
             }
             inline int RMAP_get_transactionID(char *packet)
             {
                 return ((((unsigned int)packet[5])<<8) + ((unsigned int)packet[6]));
             }
             /*
              *   Rmap Write command header:
              *
              *  | Destination Logical Address | Protocol identifier    | Packet type            | Destination key        |
              *  |-----------------------------|------------------------|------------------------|------------------------|
              *  | Source Logical Address      | Transaction identifier | Transaction identifier | Extended write address |
              *  |-----------------------------|------------------------|------------------------|------------------------|
              *  | Write address MSB           | Write  address         | Write  address         | Write  address LSB     |
              *  |-----------------------------|------------------------|------------------------|------------------------|
              *  | Data length MSB             | Data length            | Data length LSB        | Header CRC             |
              *  |-----------------------------|------------------------|------------------------|------------------------|
              *  | Data                        | (...)                  | Last data byte         | Data CRC               |
              *  |-----------------------------|------------------------|------------------------|------------------------|
              *
              * Packet type field:
              *
              *  | msb
              *  | reserved = 0 | Comand = 1| Write = 1 |       Verify data = 1 |   Ack  = 1  | Increment/      | Source Path    | Source Path    |
              *                                         | Don't Verify data = 0 | No Ack = 0  | No Inc. address | Address Length | Address Length |
              *
             */
             #define RMAP_WRITE_HEADER_MIN_SZ 16
             #define RMAP_WRITE_PACKET_MIN_SZ(bytesCnt) (RMAP_WRITE_HEADER_MIN_SZ+bytesCnt+1) //header=16 + data + data CRC=1
             inline void RMAP_build_tx_request_header(char destinationLogicalAddress, char destKey,char sourceLogicalAddress,uint16_t transactionID,int readAddress,int length,char *buffer)
             {
                 buffer[0] = destinationLogicalAddress;
                 buffer[1] = SPW_PROTO_ID_RMAP;
                 buffer[2] = 0b01101100;
                 buffer[3] = destKey;
                 buffer[4] = sourceLogicalAddress;
                 buffer[5] = (char)(transactionID >> 8);
                 buffer[6] = (char)(transactionID);
                 buffer[7] = 0;
                 buffer[8] = (char)(readAddress >> 24);
                 buffer[9] = (char)(readAddress >> 16);
                 buffer[10] = (char)(readAddress >> 8);
                 buffer[11] = (char)(readAddress);
                 buffer[12] = (char)(length >> 16);
                 buffer[13] = (char)(length >> 8);
                 buffer[14] = (char)(length);
                 buffer[15] = (char)spw_CRC(buffer,15);
                 buffer[16+length] = (char)spw_CRC(buffer+16,length);
             }
             #endif // SPW_H

spwplugin/spwplugin.cpp +53 -6

             /*------------------------------------------------------------------------------
+            --  This file is a part of the SocExplorer Software
+            --  Copyright (C) 2014, Laboratory of Plasmas Physic - 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 "spwplugin.h"
             #include "stardundeespw_usb.h"
             #include <socexplorerproxy.h>
             spwplugin::spwplugin(QWidget *parent):socexplorerplugin(parent,true)
             {
                 Q_UNUSED(parent)
-                this->bridge = new stardundeeSPW_USB(this);
+                this->bridge = NULL;
                 this->scanDone = false;
-                if(this->bridge->connectBridge())
+                this->mainGroupBox = new QGroupBox("SpaceWire Plugin Configuration",this);
+                this->bridgeSelector = new QComboBox(this);
-                    this->Connected = true;
+                this->mainLayout = new QGridLayout(this);
-                    emit this->activateSig(true);
+                this->mainLayout->addWidget(new QLabel("Select SpaceWire bridge",this),0,0,1,1,Qt::AlignCenter);
+                this->mainLayout->addWidget(this->bridgeSelector,0,1,1,1);
+                this->mainGroupBox->setLayout(this->mainLayout);
+                this->setWidget(this->mainGroupBox);
+                this->bridgeSelector->addItem("none");
+                this->bridgeSelector->addItem("STAR-Dundee Spw USB Brick");
+                connect(this->bridgeSelector,SIGNAL(currentIndexChanged(QString)),this,SLOT(bridgeSelectionChanged(QString)));
             }
             spwplugin::~spwplugin()
             {
             }
             unsigned int spwplugin::Read(unsigned int *Value,unsigned int count,unsigned int address)
             {
                 if(Connected)
                 {
                     return  bridge->Read(Value,count,address);
                 }
                 return 0;
             }
+            void spwplugin::bridgeSelectionChanged(const QString &text)
+            {
+                printf("test");
+                if(text=="none")
+                {
+                    if(this->bridge!=NULL)
+                    {
+                        this->mainLayout->removeWidget(this->bridge->getGUI());
+                        delete this->bridge;
+                        this->bridge= NULL;
+                    }
+                }
+                if(text=="STAR-Dundee Spw USB Brick")
+                {
+                    if(this->bridge!=NULL)
+                    {
+                        this->mainLayout->removeWidget(this->bridge->getGUI());
+                        delete this->bridge;
+                    }
+                    this->bridge = new stardundeeSPW_USB(this);
+                    this->mainLayout->addWidget(this->bridge->getGUI(),1,0,1,2);
+                }
+            }
             unsigned int spwplugin::Write(unsigned int *Value,unsigned int count, unsigned int address)
             {
                 if(Connected)
                 {
                     return  bridge->Write(Value,count,address);
                 }
                 return 0;
             }

spwplugin/spwplugin.h +24 -1

             /*------------------------------------------------------------------------------
+            --  This file is a part of the SocExplorer Software
+            --  Copyright (C) 2014, Laboratory of Plasmas Physic - 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 spwplugin_H
             #define spwplugin_H
             #include <QMenuBar>
             #include <QMenu>
             #include <QAction>
             #include <QLayout>
+            #include <QGroupBox>
+            #include <QComboBox>
+            #include <QLabel>
             #include <abstractspwbridge.h>
             #include <socexplorerplugin.h>
             class spwplugin : public socexplorerplugin
             {
                 Q_OBJECT
             public:
                 explicit spwplugin(QWidget *parent = 0);
                 ~spwplugin();
                 /* You can implement the folowing function if you want to overwrite
                  *  their default behavior
                 */
                 /*
                 int registermenu(QMainWindow *menuHolder);
                 int isConnected();
                 int connect();
                 int VID(){return driver_VID;}
                 int PID(){return driver_PID;}
                 */
             public slots:
                 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	bridgeSelectionChanged( const QString & text );
             signals:
             private:
                 abstractSpwBridge* bridge;
                 bool scanDone;
+                QGroupBox* mainGroupBox;
+                QComboBox* bridgeSelector;
+                QGridLayout* mainLayout;
             };
             #endif // spwplugin_H

spwplugin/stardundeespw_usb.cpp +55 -3

+            /*------------------------------------------------------------------------------
+            --  This file is a part of the SocExplorer Software
+            --  Copyright (C) 2014, Laboratory of Plasmas Physic - 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 <socexplorerengine.h>
             #include <qhexedit.h>
             stardundeeSPW_USB::stardundeeSPW_USB(socexplorerplugin *parent) :
                 abstractSpwBridge(parent)
             {
                 Q_UNUSED(parent)
-                this->manager = new stardundeeSPW_USB_Manager(parent);
+                this->p_GUI = new QWidget(parent);
+                this->mainLayout = new QGridLayout(this->p_GUI);
+                this->p_GUI->setLayout(mainLayout);
+                this->connectBridgeButton = new QPushButton("Connect");
+                this->mainLayout->addWidget(this->connectBridgeButton,1,0,1,1);
+                connect(this->connectBridgeButton,SIGNAL(clicked()),this,SLOT(toggleBridgeConnection()));
+                this->manager = new stardundeeSPW_USB_Manager(parent,this);
                 this->manager->start();
             }
+            stardundeeSPW_USB::~stardundeeSPW_USB()
+            {
+                this->manager->requestInterruption();
+                delete this->p_GUI;
+            }
+            void stardundeeSPW_USB::toggleBridgeConnection()
+            {
+                if(this->plugin->isConnected())
+                {
+                    if(this->disconnectBridge())
+                    {
+                        this->connectBridgeButton->setText("Connect");
+                    }
+                }
+                else
+                {
+                    if(this->connectBridge())
+                    {
+                        this->connectBridgeButton->setText("Disconnect");
+                    }
+                }
+            }
             bool stardundeeSPW_USB::connectBridge()
             {
                 return this->manager->connectBridge();
             }
             bool stardundeeSPW_USB::disconnectBridge()
             {
                 return this->manager->disconnectBridge();
             }
             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];
                 writeBuffer[0]=1;//Link number
                 int transactionID = 0;
                 int written=0;
                 SocExplorerEngine::message(this->plugin,"Enter Write function");
                 QProgressBar* progress=NULL;
                 if(count>RMAP_MAX_XFER_SIZE)
                     progress= SocExplorerEngine::getProgressBar("Writing on SPW @0x"+QString::number(address,16)+" %v of "+QString::number(count)+" words ",count);
                 //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);
                     }
                     RMAP_build_tx_request_header(254,2,1,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);
                     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);
                     }
                     RMAP_build_tx_request_header(254,2,1,transactionID,address+(written*4),count*4,writeBuffer+1);
                     manager->sendPacket(writeBuffer,RMAP_WRITE_PACKET_MIN_SZ(count*4) +1);
                     written+=count;
                     if(progress!=NULL)
                     {
                         progress->setValue(written);
                         qApp->processEvents();
                     }
                 }
                 if(progress!=NULL)
                 {
                     SocExplorerEngine::deleteProgressBar(progress);
                 }
                 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]=1;//Link number
                 int transactionID = 0;
                 int read=0;
                 QProgressBar* progress=NULL;
                 if(count>RMAP_MAX_XFER_SIZE)
                     progress= SocExplorerEngine::getProgressBar("Reading on SPW @0x"+QString::number(address,16)+" %v of "+QString::number(count)+" words ",count);
                 SocExplorerEngine::message(this->plugin,QString("Enter read function, count=%1, RMAP_MAX_XFER_SIZE=%2").arg(count).arg(RMAP_MAX_XFER_SIZE));
                 //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));
                     RMAP_build_rx_request_header(254,2,1,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);
                     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));
                     SocExplorerEngine::message(this->plugin,QString("Building request with:"));
                     SocExplorerEngine::message(this->plugin,QString("Address = %1").arg(address+(read*4),8,16));
                     SocExplorerEngine::message(this->plugin,QString("Size = %1").arg(count*4));
                     SocExplorerEngine::message(this->plugin,QString("Size + 13 = %1").arg((count*4)+13));
                     RMAP_build_rx_request_header(254,2,1,transactionID,address+(read*4),count*4,requestBuffer+1);
                     manager->sendPacket(requestBuffer,RMAP_READ_HEADER_MIN_SZ+1);
                     int len=manager->getRMAPanswer(transactionID,&RMAP_AnswerBuffer);
                     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();
                     }
                 }
                 if(progress!=NULL)
                 {
                     SocExplorerEngine::deleteProgressBar(progress);
                 }
                 return read;
             }
-            stardundeeSPW_USB_Manager::stardundeeSPW_USB_Manager(socexplorerplugin *parent)
+            stardundeeSPW_USB_Manager::stardundeeSPW_USB_Manager(socexplorerplugin *plugin, QObject *parent)
                 :QThread((QObject*)parent)
             {
                 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 = parent;
+                this->plugin = plugin;
                 connected = false;
             }
             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");
                 char buffer[(RMAP_MAX_XFER_SIZE*4)+50];
                 while (!this->isInterruptionRequested())
                 {
                     if(this->connected)
                     {
                         handleMutex->lock();
                         //SocExplorerEngine::message(this->plugin,"Looking for new RMAP packets");
                         if(USBSpaceWire_WaitOnReadPacketAvailable(hDevice,0.01))
                         {
                             SocExplorerEngine::message(this->plugin,"Got packet");
                             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");
                                     if(USBSpaceWire_GetReadEOPStatus(&properties, 0)== SPACEWIRE_USB_EOP)
                                     {
                                         SocExplorerEngine::message(this->plugin,"Got end of packet");
                                         if(buffer[1]==(char)SPW_PROTO_ID_RMAP) //RMAP packet
                                         {
                                             SocExplorerEngine::message(this->plugin,"Got RMAP packet");
                                             SocExplorerEngine::message(this->plugin,QString("Rmap packet size %1").arg(properties.len));
                                             if(properties.len>8)
                                             {
                                                 char* packetbuffer = (char*)malloc(properties.len);
                                                 memcpy(packetbuffer,buffer,properties.len);
                                                 USBSpaceWire_FreeRead(hDevice, pIdentifier);
                                                 pIdentifier = NULL;
                                                 handleMutex->unlock();
                                                 RMAP_Answer* 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 //it's a RMAP write response
                                             {
                                                 USBSpaceWire_FreeRead(hDevice, pIdentifier);
                                                 pIdentifier = NULL;
                                                 handleMutex->unlock();
                                             }
                                         }
                                         else //any non-rmap packet will be pushed to the network
                                         {
                                             USBSpaceWire_FreeRead(hDevice, pIdentifier);
                                             handleMutex->unlock();
                                             SocExplorerEngine::message(this->plugin,"Got SPW packet");
                                         }
                                     }
                                     else
                                     {
                                         SocExplorerEngine::message(this->plugin,"No EOP received");
                                     }
                                 }
                             }
                             else
                             {
                                 USBSpaceWire_FreeRead(hDevice, pIdentifier);
                                 handleMutex->unlock();
                             }
                         }
                         else
                         {
                             USBSpaceWire_FreeRead(hDevice, pIdentifier);
                             handleMutex->unlock();
                         }
                     }
                     else
                     {
                         sleep(1);
                         SocExplorerEngine::message(this->plugin,"Bridge not connected");
                     }
                     usleep(1000);
                     //        sleep(2);
                 }
                 SocExplorerEngine::message(this->plugin,"Exiting Startdundee USB pooling thread");
             }
             bool stardundeeSPW_USB_Manager::connectBridge()
             {
                 this->handleMutex->lock();
                 int status;
                 U32 statusControl;
                 int brickNumber=0;
                 int linkNumber=1;
                 this->connected = false;
                 if (!USBSpaceWire_Open(&hDevice, brickNumber)) // 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");
                 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");
                     return false;
                 }
                 else
                 {
                     SocExplorerEngine::message(this->plugin,"OK CFGSpaceWire_SetBrickBaseTransmitRate, base rate = 100 MHz");
                 }
                 // read the link status
                 if (CFGSpaceWire_GetLinkStatusControl(hDevice, linkNumber, &statusControl) != CFG_TRANSFER_SUCCESS)
                 {
                     SocExplorerEngine::message(this->plugin,"Could not read link status control for link " + QString::number(linkNumber));
                     return false;
                 }
                 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));
                         return false;
                     }
                     else
                     {
                         SocExplorerEngine::message(this->plugin,"Set the link status control for link " + QString::number(linkNumber));
                     }
                 }
                 if (CFGSpaceWire_SetAsInterface(hDevice, 1, 0) != CFG_TRANSFER_SUCCESS)
                 {
                     SocExplorerEngine::message(this->plugin,"Could not set the device to be an interface");
                     return false;
                 }
                 else
                 {
                     SocExplorerEngine::message(this->plugin,"Device set to be an interface");
                 }
                 USBSpaceWire_RegisterReceiveOnAllPorts(hDevice);    // Register to receive on all ports
                 USBSpaceWire_ClearEndpoints(hDevice);               // clear the USB endpoints
                 USBSpaceWire_SetTimeout(hDevice,1.0);
                 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)));
                 this->connected = true;
                 this->handleMutex->unlock();
                 return true;
             }
             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));
                 USBSpaceWire_UnregisterReceiveOnAllPorts(hDevice);  // Stop receiving on all ports
                 this->handleMutex->unlock();
                 return true;
             }
             int stardundeeSPW_USB_Manager::getRMAPtransactionID()
             {
                 this->RMAP_pending_transaction_IDsMtx->lock();
                 int  ID=0;
                 bool found=true;
                 while(ID<65536)
                 {
                     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)
             {
                 *buffer=NULL;
                 int count=0;
                 while (*buffer==NULL)
                 {
                     this->RMAP_AnswersMtx->lock();
                     for(int i=0;i<RMAP_Answers.count();i++)
                     {
                         if(RMAP_Answers[i]->transactionID==transactionID)
                         {
                             this->RMAP_pending_transaction_IDsMtx->lock();
                             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
                     if(!buffer)
                     {
                         SocExplorerEngine::message(this->plugin,"waiting until a new packet is pushed");
                         this->RMAP_AnswersSem->acquire();
                     }
                 }
                 return count;
             }
             bool stardundeeSPW_USB_Manager::sendPacket(char *packet, int size)
             {
                 USB_SPACEWIRE_STATUS result;
                 USB_SPACEWIRE_ID pIdentifier;
                 SocExplorerEngine::message(this->plugin,"Sending SPW packet");
                 this->handleMutex->lock();
                 result = USBSpaceWire_SendPacket(hDevice,packet,size,1, &pIdentifier);
                 if (result != TRANSFER_SUCCESS)
                 {
                     SocExplorerEngine::message(this->plugin,"ERR sending the READ command ");
                     this->handleMutex->unlock();
                     return false;
                 }
                 else
                 {
                     SocExplorerEngine::message(this->plugin,"Packet sent");
                     USBSpaceWire_FreeSend(hDevice, pIdentifier);
                 }
                 this->handleMutex->unlock();
                 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();
             }

spwplugin/stardundeespw_usb.h +28 -2

+            /*------------------------------------------------------------------------------
+            --  This file is a part of the SocExplorer Software
+            --  Copyright (C) 2014, Laboratory of Plasmas Physic - 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 <socexplorerplugin.h>
             #include <abstractspwbridge.h>
             #include <QThread>
             #include <QMutex>
             #include <QSemaphore>
+            #include <QGridLayout>
+            #include <QPushButton>
             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 stardundeeSPW_USB_Manager: public QThread
             {
                 Q_OBJECT
             public:
-                explicit stardundeeSPW_USB_Manager(socexplorerplugin *parent = 0);
+                explicit stardundeeSPW_USB_Manager(socexplorerplugin *plugin = 0,QObject* parent=0);
                 ~stardundeeSPW_USB_Manager();
                 void run();
                 bool connectBridge();
                 bool disconnectBridge();
                 int getRMAPtransactionID();
                 int getRMAPanswer(int transactionID,char** buffer);
                 bool sendPacket(char* packet,int size);
             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;
             };
             class stardundeeSPW_USB : public abstractSpwBridge
             {
                 Q_OBJECT
             public:
                 explicit stardundeeSPW_USB(socexplorerplugin *parent = 0);
+                ~stardundeeSPW_USB();
             signals:
             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);
             private:
                 stardundeeSPW_USB_Manager* manager;
+                QGridLayout* mainLayout;
+                QPushButton* connectBridgeButton;
             };
             #endif // STARDUNDEESPW_USB_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