HG_REPOSITORIES/LPP/INSTRUMENTATION/SocExplorerPlugins Commit - r14:f4bd616a53e5

Added stop function to dsu3plugin...

jeandet -

r14:f4bd616a53e5 default

parent child

Context file:

r14:f4bd616a53e5

Collapse all files

spwplugin/spwpywrapper.cpp created 644 +27 0

@@ -0,0 +1,27
	1	/*------------------------------------------------------------------------------
	2	-- This file is a part of the SocExplorer Software
	3	-- Copyright (C) 2014, Plasma Physics Laboratory - CNRS
	4	--
	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
	7	-- the Free Software Foundation; either version 3 of the License, or
	8	-- (at your option) any later version.
	9	--
	10	-- This program is distributed in the hope that it will be useful,
	11	-- but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	-- GNU General Public License for more details.
	14	--
	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
	17	-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	18	-------------------------------------------------------------------------------*/
	19	/*-- Author : Alexis Jeandet
	20	-- Mail : alexis.jeandet@member.fsf.org
	21	----------------------------------------------------------------------------*/
	22	#include "spwpywrapper.h"
	23
	24	spwPyWrapper::spwPyWrapper(socexplorerplugin *parent) :
	25	genericPySysdriver(parent)
	26	{
	27	}

spwplugin/spwpywrapper.h created 644 +25 0

@@ -0,0 +1,25
	1	#ifndef SPWPYWRAPPER_H
	2	#define SPWPYWRAPPER_H
	3	#include <genericPySysdriver.h>
	4
	5	class spwPyWrapper : public genericPySysdriver
	6	{
	7	Q_OBJECT
	8	public:
	9	explicit spwPyWrapper(socexplorerplugin *parent = 0);
	10
	11	signals:
	12	bool connectBridge();
	13	bool disconnectBridge();
	14	void StarDundeeSelectBrick(int brickIndex);
	15	void StarDundeeSelectLinkNumber(int linkIndex);
	16	void StarDundeeSelectLinkSpeed(int linkSpeed);
	17	void StarDundeeSetDestinationKey(const QString & destKey);
	18	void StarDundeeSetRmapAddress(const QString & address);
	19	void StarDundeeSetRmapKey(const QString & key);
	20	void StarDundeeSetRmapTimeout(const QString & timeout);
	21	public slots:
	22
	23	};
	24
	25	#endif // SPWPYWRAPPER_H

.hgignore +1 0

             syntax: glob
             *.pro.user
             *.o
             moc_*
             *.so*
             ui_*.h
             Makefile
+            qrc_*.cpp

APBUARTPLUGIN/APBUARTPLUGIN.pro +1 -1

             #
             # Project created by QtCreator 2011-09-20T08:15:30
             #
             #-------------------------------------------------
             CONFIG += socexplorerplugin
             win32:CONFIG += dll
             win32:CONFIG -= static
             CONFIG(debug, debug|release) {
               DEBUG_EXT = _d
             } else {
               DEBUG_EXT =
             }
             TARGET = ApbUartPlugin$${DEBUG_EXT}
             DEFINES += PLUGIN=ApbUartPlugin
             DEFINES += PLUGINHEADER="\"\\\"APBUARTPLUGIN.h"\\\"\"
-            DEFINES += driver_Name="\"\\\"APB UART PLUGIN"\\\"\"
+            DEFINES += driver_Name="\"\\\"APB_UART_PLUGIN"\\\"\"
             DEFINES += driver_Author="\"\\\"Alexis Jeandet alexis.jeandet@member.fsf.org"\\\"\"
             DEFINES += driver_Version="\"\\\"0.0.1"\\\"\"
             DEFINES += driver_Description="\"\\\"This plugin provides a terminal widget connected to Gaisler\'s APBUART with or without loop-back mode."\\\"\"
             DEFINES += driver_can_be_root=0
             DEFINES += driver_can_be_child=1
             DEFINES += driver_VID=1
             DEFINES += driver_PID=0x0c
             INCLUDEPATH += \
                     $${PWD}
             HEADERS += \
                 APBUARTPLUGIN.h \
                 apbuartpluginui.h \
                 apbuartcfg.h \
                 apbuartterminal.h
             SOURCES += \
                 APBUARTPLUGIN.cpp \
                 apbuartpluginui.cpp \
                 apbuartcfg.cpp \
                 apbuartterminal.cpp

dsu3plugin/dsu3plugin.cpp +23 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2011, 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@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #include "dsu3plugin.h"
             #include <QFileDialog>
             #include <QDir>
             #include "dsu3pluginpywrapper.h"
             #include <socexplorerengine.h>
             dsu3plugin::dsu3plugin(QWidget *parent):socexplorerplugin(parent,false)
             {
                 this->UI = new dsu3pluginui();
                 this->setWidget((QWidget*)this->UI);
                 this->elfparserInst = new elfparser();
                 this->pyObject = new dsu3pluginPywrapper(this);
                 QObject::connect(((dsu3pluginPywrapper*)this->pyObject),SIGNAL(openFile(QString)),this,SLOT(openFile(QString)));
                 QObject::connect(((dsu3pluginPywrapper*)this->pyObject),SIGNAL(loadFile()),this,SLOT(flashTarget()));
                 QObject::connect(((dsu3pluginPywrapper*)this->pyObject),SIGNAL(run()),this,SLOT(run()));
+                QObject::connect(((dsu3pluginPywrapper*)this->pyObject),SIGNAL(stop()),this,SLOT(stop()));
                 connect(this->UI,SIGNAL(openFile()),this,SLOT(openFile()));
                 connect(this->UI,SIGNAL(flashTarget()),this,SLOT(flashTarget()));
-                connect(this->UI,SIGNAL(run()),this,SLOT(run()));
+                connect(this->UI,SIGNAL(run()),this,SLOT(toggleRun()));
                 connect(this,SIGNAL(updateInfo(elfparser*)),this->UI,SIGNAL(updateInfo(elfparser*)));
+                this->running = false;
             }
             dsu3plugin::~dsu3plugin()
             {
             }
             void dsu3plugin::openFile()
             {
                 QString filename = QFileDialog::getOpenFileName(this,tr("Open elf File"), QDir::homePath(), tr("Elf Files (*)"));
                 if(filename!="")
                 {
                     this->openFile(filename);
                 }
             }
             void dsu3plugin::openFile(QString fileName)
             {
                 this->elfparserInst->setFilename(fileName);
                 emit this->updateInfo(this->elfparserInst);
             }
             bool dsu3plugin::configureTarget()
             {
                 if(parent==NULL)
                     return false;
                 unsigned int DSUBASEADDRESS = SocExplorerEngine::self()->getEnumDeviceBaseAddress(this,0x01 , 0x004,0);
                 if(DSUBASEADDRESS == (unsigned int)-1)
                     DSUBASEADDRESS = 0x90000000;
                 unsigned int MCTRLBASEADDRESS = SocExplorerEngine::self()->getEnumDeviceBaseAddress(this,0x04 , 0x00F,0);
                 if(MCTRLBASEADDRESS == (unsigned int)-1)
                     return false;
                 //Force a debug break
                 WriteRegs(uIntlist()<<0x0000002f,(unsigned int)DSUBASEADDRESS);
                 WriteRegs(uIntlist()<<0x0000ffff,(unsigned int)DSUBASEADDRESS+0x20);
                 //Clear time tag counter
                 WriteRegs(uIntlist()<<0,(unsigned int)DSUBASEADDRESS+0x8);
                 //Clear ASR registers
                 WriteRegs(uIntlist()<<0<<0<<0,(unsigned int)DSUBASEADDRESS+0x400040);
                 WriteRegs(uIntlist()<<0x2,(unsigned int)DSUBASEADDRESS+0x400024);
                 WriteRegs(uIntlist()<<0<<0<<0<<0<<0<<0<<0<<0,(unsigned int)DSUBASEADDRESS+0x400060);
                 WriteRegs(uIntlist()<<0,(unsigned int)DSUBASEADDRESS+0x48);
                 WriteRegs(uIntlist()<<0,(unsigned int)DSUBASEADDRESS+0x000004C);
                 WriteRegs(uIntlist()<<0,(unsigned int)DSUBASEADDRESS+0x400040);
                 WriteRegs(uIntlist()<<0x2FF<<0xE60<<0,(unsigned int)MCTRLBASEADDRESS);
                 WriteRegs(uIntlist()<<0<<0<<0<<0,(unsigned int)DSUBASEADDRESS+0x400060);
                 WriteRegs(uIntlist()<<0x0000FFFF,(unsigned int)DSUBASEADDRESS+0x24);
                 unsigned int buff=0;
             //    for(int i=0;i<1567;i++)
             //    {
             //        parent->Write(&buff,(unsigned int)1,DSUBASEADDRESS+0x300000+(4*i));
             //    }
                 memSet(DSUBASEADDRESS+0x300000,0,1567);
                 WriteRegs(uIntlist()<<0<<0xF30000E0<<0x00000002<<0x40000000<<0x40000000<<0x40000004<<0x1000000,(unsigned int)DSUBASEADDRESS+0x400000);
                 WriteRegs(uIntlist()<<0<<0<<0<<0<<0<<0<<0x403ffff0<<0<<0<<0<<0<<0<<0<<0<<0<<0<<0<<0<<0<<0<<0<<0<<0<<0,(unsigned int)DSUBASEADDRESS+0x300020);
                 WriteRegs(uIntlist()<<0x000002EF,(unsigned int)DSUBASEADDRESS);
                 //Disable interrupts
                 unsigned int APBIRQCTRLRBASEADD = (unsigned int)SocExplorerEngine::self()->getEnumDeviceBaseAddress(this,1,0x0d,0);
                 if(APBIRQCTRLRBASEADD == (unsigned int)-1)
                     return false;
                 WriteRegs(uIntlist()<<0x00000000,APBIRQCTRLRBASEADD+0x040);
                 WriteRegs(uIntlist()<<0xFFFE0000,APBIRQCTRLRBASEADD+0x080);
                 WriteRegs(uIntlist()<<0<<0,APBIRQCTRLRBASEADD);
                 //Set up timer
                 unsigned int APBTIMERBASEADD = (unsigned int)SocExplorerEngine::self()->getEnumDeviceBaseAddress(this,1,0x11,0);
                 if(APBTIMERBASEADD == (unsigned int)-1)
                     return false;
                 WriteRegs(uIntlist()<<0xffffffff,APBTIMERBASEADD+0x014);
                 WriteRegs(uIntlist()<<0x00000018,APBTIMERBASEADD+0x04);
                 WriteRegs(uIntlist()<<0x00000007,APBTIMERBASEADD+0x018);
                 return true;
             }
             bool dsu3plugin::flashTarget()
             {
                 configureTarget();
                 /*Write .text*/
                 this->writeSection(".text");
                 /*Write .data*/
                 this->writeSection(".data");
                 return true;
             }
             void dsu3plugin::run()
             {
                 unsigned int DSUBASEADDRESS = SocExplorerEngine::self()->getEnumDeviceBaseAddress(this,0x01 , 0x004,0);
                 if(DSUBASEADDRESS == (unsigned int)-1)
                     DSUBASEADDRESS = 0x90000000;
                 WriteRegs(uIntlist()<<0,DSUBASEADDRESS+0x020);
+                this->running = true;
+                this->UI->setRunning(true);
+            }
+            void dsu3plugin::stop()
+            {
+                unsigned int DSUBASEADDRESS = SocExplorerEngine::self()->getEnumDeviceBaseAddress(this,0x01 , 0x004,0);
+                if(DSUBASEADDRESS == (unsigned int)-1)
+                    DSUBASEADDRESS = 0x90000000;
+                WriteRegs(uIntlist()<<0xFFFF,DSUBASEADDRESS+0x020);
+                this->running = false;
+                this->UI->setRunning(false);
+            }
+            void dsu3plugin::toggleRun()
+            {
+                if(this->running)
+                    this->stop();
+                else
+                    this->run();
             }
             void dsu3plugin::WriteRegs(uIntlist Values, unsigned int address)
             {
                 unsigned int* buff;
                 buff = (unsigned int*)malloc(Values.count()*sizeof(unsigned int));
                 for(int i=0;i<Values.count();i++)
                 {
                     buff[i]=Values.at(i);
                 }
                 parent->Write(buff,(unsigned int)Values.count(),address);
                 free(buff);
             }
             void dsu3plugin::writeSection(int index)
             {
                 char* buffch=NULL;
                 unsigned int* buff;
                 int size = this->elfparserInst->getSectionDatasz(index);
                 int sizeInt = size/4;
                 if(parent==NULL)
                     return;
                 this->elfparserInst->getSectionData(index,&buffch);
                 buff = (unsigned int*)malloc(((size/4)+1)*sizeof(unsigned int));
                 for(int i=0;i<sizeInt;i++)
                 {
                     buff[i] = 0x0FF & ((unsigned int)buffch[4*i]);
                     buff[i] =  (buff[i]<<8) + (0x0FF & ((unsigned int)buffch[(4*i)+1]));
                     buff[i] =  (buff[i]<<8) + (0x0FF & ((unsigned int)buffch[(4*i)+2]));
                     buff[i] =  (buff[i]<<8) + (0x0FF & ((unsigned int)buffch[(4*i)+3]));
                 }
                 if(size%4)
                 {
                     buff[sizeInt]=0;
                     for(int i=(size%4);i>0;i--)
                     {
                         buff[sizeInt] =  (buff[sizeInt]<<8) + (0x0FF & ((unsigned int)buffch[size-i]));
                     }
                     sizeInt++;
                 }
                 parent->Write(buff,(unsigned int)sizeInt,(unsigned int)this->elfparserInst->getSectionPaddr(index));
                 free(buff);
             }
             void dsu3plugin::writeSection(const QString &name)
             {
                 for(int i=0;i<this->elfparserInst->getSectioncount();i++)
                 {
                     if(!this->elfparserInst->getSectionName(i).compare(name))
                     {
                         printf("about to write section %s @ 0x%x size = %d\n",elfparserInst->getSectionName(i).toStdString().c_str(),elfparserInst->getSectionPaddr(i),elfparserInst->getSectionMemsz(i));
                         writeSection(i);
                     }
                 }
             }
             unsigned int dsu3plugin::Write(unsigned int *Value,unsigned int count,unsigned  int address)
             {
                 if(parent!=NULL)
                     return parent->Write(Value,count,address);
                 return 0;
             }
             bool dsu3plugin::memSet(unsigned int address,int value, unsigned int count)
             {
                 unsigned int* buffer = (unsigned int*)malloc(count*sizeof(unsigned int));
                 if(buffer!=NULL)
                 {
                     memset((void*)buffer,value,count*sizeof(unsigned int));
                     parent->Write(buffer,count,address);
                     free(buffer );
                     return true;
                 }
                 return false;
             }
             unsigned int dsu3plugin::Read(unsigned int *Value,unsigned int count, unsigned int address)
             {
                 if(parent!=NULL)
                     return parent->Read(Value,count,address);
                 return 0;
             }

dsu3plugin/dsu3plugin.h +3 0

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2012, 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@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #ifndef DSU3PLUGIN_H
             #define DSU3PLUGIN_H
             #include "dsu3pluginui.h"
             #include <QMenuBar>
             #include <QMenu>
             #include <QAction>
             #include <QMainWindow>
             #include <QList>
             #include "elfparser.h"
             #include <socexplorerplugin.h>
             #include <socexplorerengine.h>
             typedef QList<unsigned int> uIntlist;
             class dsu3plugin : public socexplorerplugin
             {
                 Q_OBJECT
             public:
                 explicit dsu3plugin(QWidget *parent = 0);
                 ~dsu3plugin();
                 bool memSet(unsigned int address, int value, unsigned int count);
             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 openFile();
                 void openFile(QString fileName);
                 bool configureTarget();
                 bool flashTarget();
                 void run();
+                void stop();
+                void toggleRun();
             signals:
                 void updateInfo(elfparser* parser);
             private:
                 void WriteRegs(uIntlist Values, unsigned int address);
                 void writeSection(int index);
                 void writeSection(const QString& name);
                 dsu3pluginui* UI;
                 elfparser* elfparserInst;
+                bool running;
             };
             #endif // DSU3PLUGIN_H

dsu3plugin/dsu3pluginpywrapper.h +1 0

             #ifndef DSU3PLUGINPYWRAPPER_H
             #define DSU3PLUGINPYWRAPPER_H
             #include <genericPySysdriver.h>
             class dsu3pluginPywrapper : public genericPySysdriver
             {
                 Q_OBJECT
             public:
                 explicit dsu3pluginPywrapper(socexplorerplugin *parent = 0);
             signals:
                 bool openFile(QString fileName);
                 bool loadFile();
                 bool run();
+                bool stop();
             public slots:
             };
             #endif // DSU3PLUGINPYWRAPPER_H

dsu3plugin/dsu3pluginui.cpp +8 0

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2013, 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@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #include <dsu3pluginui.h>
             dsu3pluginui::dsu3pluginui(QWidget *parent)
                 :QWidget(parent)
             {
                 this->openFileQpb = new QPushButton(tr("Open File"));
                 this->flashTargetQpb = new QPushButton(tr("Flash Target"));
                 this->runQpb = new QPushButton(tr("Run"));
                 this->mainLayout = new QGridLayout();
                 this->elfInfoWdgtInst = new elfInfoWdgt;
                 this->mainLayout->addWidget(this->openFileQpb,0,0,1,1);
                 this->mainLayout->addWidget(this->flashTargetQpb,0,1,1,1);
                 this->mainLayout->addWidget(this->runQpb,0,2,1,1);
                 this->mainLayout->addWidget(this->elfInfoWdgtInst,1,0,1,-1);
                 this->setLayout(this->mainLayout);
                 connect(this->openFileQpb,SIGNAL(clicked()),this,SIGNAL(openFile()));
                 connect(this->flashTargetQpb,SIGNAL(clicked()),this,SIGNAL(flashTarget()));
                 connect(this->runQpb,SIGNAL(clicked()),this,SIGNAL(run()));
                 connect(this,SIGNAL(updateInfo(elfparser*)),this->elfInfoWdgtInst,SLOT(updateInfo(elfparser*)));
             }
+            void dsu3pluginui::setRunning(bool running)
+            {
+                if(running)
+                    this->runQpb->setText("Stop");
+                else
+                    this->runQpb->setText("Run");
+            }

dsu3plugin/dsu3pluginui.h +1 -2

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2012, 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@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #ifndef DSU3PLUGINUI_H
             #define DSU3PLUGINUI_H
             #include <QWidget>
             #include <QHBoxLayout>
             #include <QPushButton>
             #include <qhexedit.h>
             #include <QSplitter>
             #include <QVBoxLayout>
             #include <QGridLayout>
             #include "elfinfowdgt.h"
             class dsu3pluginui : public QWidget
             {
                 Q_OBJECT
             public:
                 explicit dsu3pluginui(QWidget *parent = 0);
             public slots:
+                void setRunning(bool running);
             signals:
                 void openFile();
                 void updateInfo(elfparser* parser);
                 bool flashTarget();
                 void run();
             private:
                 QGridLayout* mainLayout;
                 QPushButton* openFileQpb;
                 QPushButton* flashTargetQpb;
                 QPushButton* runQpb;
                 elfInfoWdgt* elfInfoWdgtInst;
             };
             #endif // DSU3PLUGINUI_H

spwplugin/SpwTcpPacketServer/spwtcppacketserver.cpp +21 0

@@ -1,14 +1,35
		1	/*------------------------------------------------------------------------------
		2	-- This file is a part of the SocExplorer Software
		3	-- Copyright (C) 2014, Plasma Physics Laboratory - CNRS
		4	--
		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
		7	-- the Free Software Foundation; either version 3 of the License, or
		8	-- (at your option) any later version.
		9	--
		10	-- This program is distributed in the hope that it will be useful,
		11	-- but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	-- GNU General Public License for more details.
		14	--
		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
		17	-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
		18	-------------------------------------------------------------------------------*/
		19	/*-- Author : Alexis Jeandet
		20	-- Mail : alexis.jeandet@member.fsf.org
		21	----------------------------------------------------------------------------*/
1	#include "spwtcppacketserver.h"	22	#include "spwtcppacketserver.h"
2	#include "ui_spwtcppacketserver.h"	23	#include "ui_spwtcppacketserver.h"
3		24
4	SpwTcpPacketServer::SpwTcpPacketServer(QWidget *parent) :	25	SpwTcpPacketServer::SpwTcpPacketServer(QWidget *parent) :
5	QWidget(parent),	26	QWidget(parent),
6	ui(new Ui::SpwTcpPacketServer)	27	ui(new Ui::SpwTcpPacketServer)
7	{	28	{
8	ui->setupUi(this);	29	ui->setupUi(this);
9	}	30	}
10		31
11	SpwTcpPacketServer::~SpwTcpPacketServer()	32	SpwTcpPacketServer::~SpwTcpPacketServer()
12	{	33	{
13	delete ui;	34	delete ui;
14	}	35	}

spwplugin/SpwTcpPacketServer/spwtcppacketserver.h +21 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 SPWTCPPACKETSERVER_H
             #define SPWTCPPACKETSERVER_H
             #include <QWidget>
             namespace Ui {
             class SpwTcpPacketServer;
             }
             class SpwTcpPacketServer : public QWidget
             {
                 Q_OBJECT
             public:
                 explicit SpwTcpPacketServer(QWidget *parent = 0);
                 ~SpwTcpPacketServer();
             private:
                 Ui::SpwTcpPacketServer *ui;
             };
             #endif // SPWTCPPACKETSERVER_H

spwplugin/spwplugin.cpp +17 -2

             /*------------------------------------------------------------------------------
             --  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 "spwplugin.h"
             #include "stardundeespw_usb.h"
             #include <socexplorerproxy.h>
+            #include "spwpywrapper.h"
-            spwplugin::spwplugin(QWidget *parent):socexplorerplugin(parent,true)
+            spwplugin::spwplugin(QWidget *parent):socexplorerplugin(parent,false)
             {
                 Q_UNUSED(parent)
                 this->bridge = NULL;
                 this->scanDone = false;
+                this->pyObject = new spwPyWrapper(this);
                 this->mainGroupBox = new QGroupBox("SpaceWire Plugin Configuration",this);
                 this->bridgeSelector = new QComboBox(this);
                 this->mainLayout = new QGridLayout(this);
                 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());
                         this->disconnect(this,SLOT(setConnected(bool)));
                         delete this->bridge;
                         this->bridge= NULL;
                     }
                 }
                 if(text=="STAR-Dundee Spw USB Brick")
                 {
                     if(this->bridge!=NULL)
                     {
                         this->mainLayout->removeWidget(this->bridge->getGUI());
                         this->disconnect(this,SLOT(setConnected(bool)));
                         delete this->bridge;
                     }
                     this->bridge = new stardundeeSPW_USB(this);
                     this->mainLayout->addWidget(this->bridge->getGUI(),1,0,1,2);
                     connect(this->bridge,SIGNAL(setConnected(bool)),this,SLOT(setConnected(bool)));
+                    connect(((spwPyWrapper*)this->pyObject),SIGNAL(StarDundeeSelectBrick(int)),((stardundeeSPW_USB*)bridge),SIGNAL(SelectBrick(int)));
+                    connect(((spwPyWrapper*)this->pyObject),SIGNAL(StarDundeeSelectLinkNumber(int)),((stardundeeSPW_USB*)bridge),SIGNAL(SelectLinkNumber(int)));
+                    connect(((spwPyWrapper*)this->pyObject),SIGNAL(StarDundeeSelectLinkSpeed(int)),((stardundeeSPW_USB*)bridge),SIGNAL(SelectLinkSpeed(int)));
+                    connect(((spwPyWrapper*)this->pyObject),SIGNAL(StarDundeeSetDestinationKey(QString)),((stardundeeSPW_USB*)bridge),SIGNAL(SetDestinationKey(QString)));
+                    connect(((spwPyWrapper*)this->pyObject),SIGNAL(StarDundeeSetRmapAddress(QString)),((stardundeeSPW_USB*)bridge),SIGNAL(SetRmapAddress(QString)));
+                    connect(((spwPyWrapper*)this->pyObject),SIGNAL(StarDundeeSetRmapKey(QString)),((stardundeeSPW_USB*)bridge),SIGNAL(SetRmapKey(QString)));
+                    connect(((spwPyWrapper*)this->pyObject),SIGNAL(StarDundeeSetRmapTimeout(QString)),((stardundeeSPW_USB*)bridge),SIGNAL(SetRmapTimeout(QString)));
+                    connect(((spwPyWrapper*)this->pyObject),SIGNAL(connectBridge()),((stardundeeSPW_USB*)bridge),SLOT(connectBridge()));
+                    connect(((spwPyWrapper*)this->pyObject),SIGNAL(disconnectBridge()),((stardundeeSPW_USB*)bridge),SLOT(disconnectBridge()));
                 }
             }
             void spwplugin::setConnected(bool connected)
             {
                 this->bridgeSelector->setDisabled(connected);
                 this->Connected = connected;
                 emit activateSig(connected);
+                if(!this->scanDone)
+                {
+                    socexplorerproxy::loadChildSysDriver(this,"AMBA_PLUGIN");
+                    this->scanDone=true;
+                }
             }
             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.pro +4 -2

             #
             # Project created by QtCreator 2011-09-20T08:15:30
             #
             #-------------------------------------------------
             CONFIG += socexplorerplugin
             win32:CONFIG += dll
             win32:CONFIG -= static
             CONFIG(debug, debug|release) {
               DEBUG_EXT = _d
             } else {
               DEBUG_EXT =
             }
             TARGET = spwplugin$${DEBUG_EXT}
             DEFINES += PLUGIN=spwplugin
             DEFINES += PLUGINHEADER="\"\\\"spwplugin.h"\\\"\"
             DEFINES += driver_Name="\"\\\"SpwPlugin"\\\"\"
             DEFINES += driver_Author="\"\\\"Alexis Jeandet alexis.jeandet@member.fsf.org"\\\"\"
             DEFINES += driver_Version="\"\\\"0.0.1"\\\"\"
             DEFINES += driver_Description="\"\\\"Driver description"\\\"\"
             DEFINES += driver_can_be_root=1
             DEFINES += driver_can_be_child=0
             DEFINES += driver_VID=0
             DEFINES += driver_PID=0
             STARTDUNDEEPATH=/home/spacewire/usb/spw_usb_driver_v2.68/
             LIBS += $$STARTDUNDEEPATH/lib/x86_64/libSpaceWireUSBAPI.so \
                 $$STARTDUNDEEPATH/lib/x86_64/libConfigLibraryUSB.so
             INCLUDEPATH += \
                     $${PWD} \
                     $$STARTDUNDEEPATH/inc \
             HEADERS += \
                 spwplugin.h \
                 stardundeespw_usb.h \
                 abstractspwbridge.h \
                 spw.h \
                 stardundeegui.h \
-                SpwTcpPacketServer/spwtcppacketserver.h
+                SpwTcpPacketServer/spwtcppacketserver.h \
+                spwpywrapper.h
             SOURCES += \
                 spwplugin.cpp \
                 stardundeespw_usb.cpp \
                 abstractspwbridge.cpp \
                 stardundeegui.cpp \
-                SpwTcpPacketServer/spwtcppacketserver.cpp
+                SpwTcpPacketServer/spwtcppacketserver.cpp \
+                spwpywrapper.cpp
             FORMS += \
                 stardundeeGUI.ui \
                 SpwTcpPacketServer/spwtcppacketserver.ui
             RESOURCES += \
                 spwRessources.qrc

spwplugin/stardundeeGUI.ui +29 -3

             <?xml version="1.0" encoding="UTF-8"?>
             <ui version="4.0">
              <class>StarDundeeUI</class>
              <widget class="QWidget" name="StarDundeeUI">
               <property name="geometry">
                <rect>
                 <x>0</x>
                 <y>0</y>
-                <width>778</width>
+                <width>397</width>
-                <height>271</height>
+                <height>243</height>
                </rect>
               </property>
               <property name="windowTitle">
                <string>Form</string>
               </property>
               <layout class="QFormLayout" name="formLayout">
                <item row="0" column="0">
                 <widget class="QLabel" name="selectBrickLbl">
                  <property name="text">
                   <string>Select Brick</string>
                  </property>
                 </widget>
                </item>
                <item row="0" column="1">
                 <widget class="QComboBox" name="selectBrickCmbx">
                  <property name="toolTip">
                   <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Select the brick you want to use.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
                  </property>
                  <property name="whatsThis">
                   <string/>
                  </property>
                  <item>
                   <property name="text">
                    <string>None</string>
                   </property>
                  </item>
                 </widget>
                </item>
                <item row="1" column="0">
                 <widget class="QLabel" name="selectLinkLbl">
                  <property name="text">
                   <string>Select link number</string>
                  </property>
                 </widget>
                </item>
                <item row="1" column="1">
                 <widget class="QComboBox" name="selectLinkCmbx">
                  <property name="toolTip">
                   <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Select the link number you want to use.&lt;/p&gt;&lt;p&gt;The link number correspond to the numbers on the brick:&lt;/p&gt;&lt;p&gt;&lt;img src=&quot;:/imgs/stardundee.tif&quot;/&gt;&lt;/p&gt;&lt;p&gt;&lt;br/&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
                  </property>
                  <item>
                   <property name="text">
                    <string>1</string>
                   </property>
                  </item>
                  <item>
                   <property name="text">
                    <string>2</string>
                   </property>
                  </item>
                 </widget>
                </item>
                <item row="2" column="0">
                 <widget class="QLabel" name="selectLinkSpeedLbl">
                  <property name="text">
                   <string>Link Speed</string>
                  </property>
                 </widget>
                </item>
                <item row="2" column="1">
                 <widget class="QComboBox" name="setLinkSpeedCmbx">
                  <property name="toolTip">
                   <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Select the Space Wire link speed you want to use.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
                  </property>
                  <item>
                   <property name="text">
                    <string>10MHz</string>
                   </property>
                  </item>
                 </widget>
                </item>
                <item row="3" column="0">
                 <widget class="QLabel" name="setDestKeyLbl">
                  <property name="text">
                   <string>Destination key</string>
                  </property>
                 </widget>
                </item>
                <item row="3" column="1">
                 <widget class="QLineEdit" name="destKeyLineEdit">
                  <property name="toolTip">
                   <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Set the Space Wire Brick destination Key, the default value is 32 (0x20).&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
                  </property>
                  <property name="inputMask">
                   <string comment="ddD"/>
                  </property>
                  <property name="text">
                   <string>32</string>
                  </property>
                  <property name="maxLength">
                   <number>3</number>
                  </property>
                 </widget>
                </item>
                <item row="4" column="0">
                 <widget class="QLabel" name="RMAPaddressLbl">
                  <property name="text">
                   <string>RMAP Target address</string>
                  </property>
                 </widget>
                </item>
                <item row="4" column="1">
                 <widget class="QLineEdit" name="RMAPAddresslineEdit">
                  <property name="toolTip">
                   <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Set the RMAP target address, this address will be used as destination address for all the RMAP transfers.&lt;/p&gt;&lt;p&gt;This is you SOC spw address.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
                  </property>
                  <property name="inputMask">
                   <string comment="ddD"/>
                  </property>
                  <property name="text">
                   <string>254</string>
                  </property>
                  <property name="maxLength">
                   <number>3</number>
                  </property>
                 </widget>
                </item>
                <item row="5" column="0">
                 <widget class="QLabel" name="RMAPKeyLbl">
                  <property name="text">
                   <string>RMAP Target key</string>
                  </property>
                 </widget>
                </item>
                <item row="5" column="1">
                 <widget class="QLineEdit" name="RMAPKeylineEdit">
                  <property name="toolTip">
                   <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Set the RMAP target key, this key will be used for all the RMAP transfers.&lt;/p&gt;&lt;p&gt;This is you SOC spw key.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
                  </property>
                  <property name="inputMask">
                   <string comment="ddD"/>
                  </property>
                  <property name="text">
                   <string comment="ddD">2</string>
                  </property>
                  <property name="maxLength">
                   <number>3</number>
                  </property>
                 </widget>
                </item>
-               <item row="6" column="1">
+               <item row="7" column="1">
                 <widget class="QPushButton" name="connectQpb">
                  <property name="text">
                   <string>Connect</string>
                  </property>
                 </widget>
                </item>
+               <item row="6" column="1">
+                <widget class="QLineEdit" name="RMAPTimeoutLineEdit">
+                 <property name="toolTip">
+                  <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Set the RMAP timeout, when waiting for a RMAP answer the driver will give up after this time if it doesn't get any answer.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+                 </property>
+                 <property name="inputMethodHints">
+                  <set>Qt::ImhDigitsOnly</set>
+                 </property>
+                 <property name="inputMask">
+                  <string comment="DDdd;"/>
+                 </property>
+                 <property name="text">
+                  <string>500</string>
+                 </property>
+                 <property name="maxLength">
+                  <number>5</number>
+                 </property>
+                </widget>
+               </item>
+               <item row="6" column="0">
+                <widget class="QLabel" name="RMAPTimeoutLbl">
+                 <property name="text">
+                  <string>RMAP timeout(ms)</string>
+                 </property>
+                </widget>
+               </item>
               </layout>
              </widget>
              <resources/>
              <connections/>
             </ui>

spwplugin/stardundeegui.cpp +67 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
             ----------------------------------------------------------------------------*/
             #include "stardundeegui.h"
             #include "ui_stardundeeGUI.h"
             #include <spw_usb_api.h>
             #include <spw_config_library.h>
             StarDundeeGUI::StarDundeeGUI(QWidget *parent) :
                 QWidget(parent),ui(new Ui::StarDundeeUI)
             {
                 this->ui->setupUi(this);
                 connect(this->ui->selectBrickCmbx,SIGNAL(currentIndexChanged(int)),this,SIGNAL(brickSelectionChanged(int)));
                 connect(this->ui->selectLinkCmbx,SIGNAL(currentIndexChanged(int)),this,SIGNAL(linkNumberSelectionChanged(int)));
                 connect(this->ui->setLinkSpeedCmbx,SIGNAL(currentIndexChanged(QString)),this,SIGNAL(linkSpeedSelectionChanged(QString)));
                 connect(this->ui->destKeyLineEdit,SIGNAL(textChanged(QString)),this,SIGNAL(destinationKeyChanged(QString)));
                 connect(this->ui->RMAPAddresslineEdit,SIGNAL(textChanged(QString)),this,SIGNAL(rmapAddressChanged(QString)));
                 connect(this->ui->RMAPKeylineEdit,SIGNAL(textChanged(QString)),this,SIGNAL(rmapKeyChanged(QString)));
+                connect(this->ui->RMAPTimeoutLineEdit,SIGNAL(textChanged(QString)),this,SIGNAL(rmapTimeoutChanged(QString)));
                 connect(this->ui->connectQpb,SIGNAL(clicked()),this,SIGNAL(connectClicked()));
             }
             int StarDundeeGUI::getBrickSelection()
             {
                 return ui->selectBrickCmbx->currentIndex();
             }
             int StarDundeeGUI::getLinkNumberSelection()
             {
                 return ui->selectLinkCmbx->currentIndex();
             }
             QString StarDundeeGUI::getLinkSpeedSelection()
             {
                 return ui->setLinkSpeedCmbx->currentText();
             }
             QString StarDundeeGUI::getDestinationKey()
             {
                 return ui->destKeyLineEdit->text();
             }
             QString StarDundeeGUI::getRmapAddress()
             {
                 return ui->RMAPAddresslineEdit->text();
             }
             QString StarDundeeGUI::getRmapKey()
             {
                 return ui->RMAPKeylineEdit->text();
             }
+            QString StarDundeeGUI::getRmapTimeout()
+            {
+                return ui->RMAPTimeoutLineEdit->text();
+            }
             void StarDundeeGUI::lock(bool lock)
             {
                 this->ui->selectBrickCmbx->setDisabled(lock);
                 this->ui->selectLinkCmbx->setDisabled(lock);
                 this->ui->setLinkSpeedCmbx->setDisabled(lock);
                 this->ui->destKeyLineEdit->setDisabled(lock);
                 this->ui->RMAPAddresslineEdit->setDisabled(lock);
                 this->ui->RMAPKeylineEdit->setDisabled(lock);
+                this->ui->RMAPTimeoutLineEdit->setDisabled(lock);
                 if(lock)
                     this->ui->connectQpb->setText("Disconnect");
                 else
                     this->ui->connectQpb->setText("Connect");
             }
             void StarDundeeGUI::updateAvailableBrickCount(int count)
             {
                 this->ui->selectBrickCmbx->clear();
                 this->ui->selectBrickCmbx->addItem("none");
                 for(int i =0;i<32;i++)
                 {
                     if((count&1)==1)
                     {
                         star_device_handle hDevice;
                         char serial[11]="";
                         if (USBSpaceWire_Open(&hDevice, 0))
                         {
                             USBSpaceWire_GetSerialNumber(hDevice,(U8*) serial);
                             USBSpaceWire_Close(hDevice);
                         }
                         this->ui->selectBrickCmbx->addItem("STAR-Dundee USB brick "+QString::number(i)+" sn:" + serial);
                     }
                     count>>=1;
                 }
             }
+            void StarDundeeGUI::setRmapTimeout(const QString &timeout)
+            {
+                this->ui->RMAPTimeoutLineEdit->setText(timeout);
+            }
+            void StarDundeeGUI::selectBrick(int brickIndex)
+            {
+                if(brickIndex>=0&& brickIndex<this->ui->selectBrickCmbx->count())
+                {
+                    this->ui->selectBrickCmbx->setCurrentIndex(brickIndex);
+                }
+            }
+            void StarDundeeGUI::selectLinkNumber(int linkNumber)
+            {
+                if(linkNumber==1 || linkNumber==2)
+                {
+                    this->ui->selectLinkCmbx->setCurrentIndex(linkNumber-1);
+                }
+            }
+            void StarDundeeGUI::selectLinkSpeed(int linkSpeed)
+            {
+            #define MHz *(1000*1000)
+                if(linkSpeed==10 MHz)
+                {
+                    this->ui->selectLinkCmbx->setCurrentIndex(0);
+                }
+            }
+            void StarDundeeGUI::setDestinationKey(const QString &destKey)
+            {
+                bool ok;
+                int Key=destKey.toInt(&ok,10);
+                if(ok)
+                {
+                    this->ui->destKeyLineEdit->setText(destKey);
+                }
+            }
+            void StarDundeeGUI::setRmapAddress(const QString &address)
+            {
+                bool ok;
+                int tmp=address.toInt(&ok,10);
+                if(ok)
+                {
+                    this->ui->RMAPAddresslineEdit->setText(address);
+                }
+            }
+            void StarDundeeGUI::setRmapKey(const QString &key)
+            {
+                bool ok;
+                int tmp=key.toInt(&ok,10);
+                if(ok)
+                {
+                    this->ui->RMAPKeylineEdit->setText(key);
+                }
+            }

spwplugin/stardundeegui.h +9 -1

             /*------------------------------------------------------------------------------
             --  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 STARDUNDEEGUI_H
             #define STARDUNDEEGUI_H
             #include <QWidget>
             namespace Ui {
                 class StarDundeeUI;
             }
             class StarDundeeGUI : public QWidget
             {
                 Q_OBJECT
             public:
                 explicit StarDundeeGUI(QWidget *parent = 0);
                 int getBrickSelection();
                 int getLinkNumberSelection();
                 QString getLinkSpeedSelection();
                 QString getDestinationKey();
                 QString getRmapAddress();
                 QString getRmapKey();
+                QString getRmapTimeout();
             signals:
                 void brickSelectionChanged(int brickIndex);
                 void linkNumberSelectionChanged(int linkIndex);
                 void linkSpeedSelectionChanged(const QString & linkSpeed);
                 void destinationKeyChanged(const QString & destKey);
                 void rmapAddressChanged(const QString & address);
                 void rmapKeyChanged(const QString & key);
+                void rmapTimeoutChanged(const QString & timeout);
                 void connectClicked();
             public slots:
                 void lock(bool lock);
                 void updateAvailableBrickCount(int count);
+                void selectBrick(int brickIndex);
+                void selectLinkNumber(int linkIndex);
+                void selectLinkSpeed(int linkSpeed);
+                void setDestinationKey(const QString & destKey);
+                void setRmapAddress(const QString & address);
+                void setRmapKey(const QString & key);
+                void setRmapTimeout(const QString & timeout);
             private:
                 Ui::StarDundeeUI *ui;
             };
             #endif // STARDUNDEEGUI_H

spwplugin/stardundeespw_usb.cpp +65 -28

             /*------------------------------------------------------------------------------
             --  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 <socexplorerengine.h>
             #include <qhexedit.h>
             stardundeeSPW_USB::stardundeeSPW_USB(socexplorerplugin *parent) :
                 abstractSpwBridge(parent)
             {
                 Q_UNUSED(parent)
                 this->manager = new stardundeeSPW_USB_Manager(parent,this);
                 makeGUI(parent);
                 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->disconnectBridge();
-                        ((StarDundeeGUI*)this->p_GUI)->lock(false);
-                        emit setConnected(false);
                 }
                 else
                 {
-                    if(this->connectBridge())
+                    this->connectBridge();
-                        ((StarDundeeGUI*)this->p_GUI)->lock(true);
-                        emit setConnected(true);
                 }
             }
             bool stardundeeSPW_USB::connectBridge()
             {
-                return this->manager->connectBridge();
+                if(this->manager->connectBridge())
+                {
+                    ((StarDundeeGUI*)this->p_GUI)->lock(true);
+                    emit setConnected(true);
+                    return true;
+                }
+                return false;
             }
             bool stardundeeSPW_USB::disconnectBridge()
             {
-                return this->manager->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];
                 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);
                     }
                     RMAP_build_tx_request_header(this->manager->rmapAddress,this->manager->rmapKey,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(this->manager->rmapAddress,this->manager->rmapKey,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)
+            //    if(progress!=NULL)
+            //    {
-                    SocExplorerEngine::deleteProgressBar(progress);
+            //        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]=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->rmapAddress,this->manager->rmapKey,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);
                     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->rmapAddress,this->manager->rmapKey,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);
                     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();
                     }
                 }
-                if(progress!=NULL)
+            //    if(progress!=NULL)
+            //    {
-                    SocExplorerEngine::deleteProgressBar(progress);
+            //        SocExplorerEngine::deleteProgressBar(progress);
+            //    }
                 return read;
             }
             void stardundeeSPW_USB::brickSelectionChanged(int brickIndex)
             {
                 this->manager->selectedBrick = brickIndex-1;
-                SocExplorerEngine::message(plugin,QString("Changing brick index: %1").arg(manager->selectedBrick));
+                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));
+                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));
+                SocExplorerEngine::message(plugin,QString("Changing Link Speed: %1").arg(manager->linkSpeed),1);
             }
             void stardundeeSPW_USB::destinationKeyChanged(const QString &destKey)
             {
                 this->manager->destinationKey = destKey.toInt();
-                SocExplorerEngine::message(plugin,QString("Changing Destination Key: %1").arg(manager->destinationKey));
+                SocExplorerEngine::message(plugin,QString("Changing Destination Key: %1").arg(manager->destinationKey),1);
             }
             void stardundeeSPW_USB::rmapAddressChanged(const QString &rmapaddress)
             {
                 this->manager->rmapAddress = rmapaddress.toInt();
-                SocExplorerEngine::message(plugin,QString("Changing RMAP address: %1").arg(manager->rmapAddress));
+                SocExplorerEngine::message(plugin,QString("Changing RMAP address: %1").arg(manager->rmapAddress),1);
             }
             void stardundeeSPW_USB::rmapKeyChanged(const QString &key)
             {
                 this->manager->rmapKey = key.toInt();
-                SocExplorerEngine::message(plugin,QString("Changing RMAP Key: %1").arg(manager->rmapKey));
+                SocExplorerEngine::message(plugin,QString("Changing RMAP Key: %1").arg(manager->rmapKey),1);
             }
+            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)
             {
                 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(destinationKeyChanged(QString)),this,SLOT(destinationKeyChanged(QString)));
                 connect(((StarDundeeGUI*)this->p_GUI),SIGNAL(rmapAddressChanged(QString)),this,SLOT(rmapAddressChanged(QString)));
                 connect(((StarDundeeGUI*)this->p_GUI),SIGNAL(rmapKeyChanged(QString)),this,SLOT(rmapKeyChanged(QString)));
+                connect(((StarDundeeGUI*)this->p_GUI),SIGNAL(rmapTimeoutChanged(QString)),this,SLOT(rmapTimeoutChanged(QString)));
                 this->brickSelectionChanged(((StarDundeeGUI*)this->p_GUI)->getBrickSelection());
                 this->linkNumberSelectionChanged(((StarDundeeGUI*)this->p_GUI)->getLinkNumberSelection());
                 this->linkSpeedSelectionChanged(((StarDundeeGUI*)this->p_GUI)->getLinkSpeedSelection());
                 this->destinationKeyChanged(((StarDundeeGUI*)this->p_GUI)->getDestinationKey());
                 this->rmapAddressChanged(((StarDundeeGUI*)this->p_GUI)->getRmapAddress());
                 this->rmapKeyChanged(((StarDundeeGUI*)this->p_GUI)->getRmapKey());
+                this->rmapTimeoutChanged(((StarDundeeGUI*)this->p_GUI)->getRmapTimeout());
+                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(SetRmapAddress(QString)),((StarDundeeGUI*)this->p_GUI),SLOT(setRmapAddress(QString)));
+                connect(this,SIGNAL(SetRmapKey(QString)),((StarDundeeGUI*)this->p_GUI),SLOT(setRmapKey(QString)));
+                connect(this,SIGNAL(SetRmapTimeout(QString)),((StarDundeeGUI*)this->p_GUI),SLOT(setRmapTimeout(QString)));
             }
             stardundeeSPW_USB_Manager::stardundeeSPW_USB_Manager(socexplorerplugin *plugin, QObject *parent)
                 :QThread((QObject*)parent)
             {
                 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);
             }
             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)
                     {
                         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");
+                                        SocExplorerEngine::message(this->plugin,"Got end of packet",2);
                                         if(buffer[1]==(char)SPW_PROTO_ID_RMAP) //RMAP packet
                                         {
                                             SocExplorerEngine::message(this->plugin,"Got RMAP packet",2);
                                             SocExplorerEngine::message(this->plugin,QString("Rmap packet size %1").arg(properties.len),2);
                                             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",2);
                                         }
                                     }
                                     else
                                     {
                                         SocExplorerEngine::message(this->plugin,"No EOP received",2);
                                     }
                                 }
                             }
                             else
                             {
                                 USBSpaceWire_FreeRead(hDevice, pIdentifier);
                                 handleMutex->unlock();
                             }
                         }
                         else
                         {
                             USBSpaceWire_FreeRead(hDevice, pIdentifier);
                             handleMutex->unlock();
                         }
                     }
                     else
                     {
                         //do some sanity checks!
                         int list = USBSpaceWire_ListDevices();
                         if(this->brickList!=list)
                         {
                             this->brickList = list;
                             emit updateAvailableBrickCount(this->brickList);
                         }
-                        sleep(1);
+                        usleep(RMAPtimeout/2);
                     }
                     usleep(1000);
                 }
                 SocExplorerEngine::message(this->plugin,"Exiting Startdundee USB pooling thread",1);
             }
             bool stardundeeSPW_USB_Manager::connectBridge()
             {
                 QMutexLocker mlock(this->handleMutex);
                 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);
                     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);
                     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);
                     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);
                         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);
                     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);
                 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::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("%2 packet(s) available in RMAP_Answers stack").arg(RMAP_Answers.count()),2);
                     for(int i=0;i<RMAP_Answers.count();i++)
                     {
                         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)
             {
                 USB_SPACEWIRE_STATUS result;
                 USB_SPACEWIRE_ID pIdentifier;
                 SocExplorerEngine::message(this->plugin,"Sending SPW packet",2);
                 this->handleMutex->lock();
                 result = USBSpaceWire_SendPacket(hDevice,packet,size,1, &pIdentifier);
                 if (result != TRANSFER_SUCCESS)
                 {
                     SocExplorerEngine::message(this->plugin,"ERR sending the READ command ",2);
                     this->handleMutex->unlock();
                     return false;
                 }
                 else
                 {
                     SocExplorerEngine::message(this->plugin,"Packet sent",2);
                     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 +10 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 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>
             #include <QComboBox>
             #include <QLabel>
             #include "stardundeegui.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 stardundeeSPW_USB_Manager: public QThread
             {
                 Q_OBJECT
             public:
                 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);
             signals:
                 void updateAvailableBrickCount(int count);
             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;
             public:
                 int selectedBrick;
                 int linkNumber;
                 int brickList;
                 int linkSpeed;
                 int destinationKey;
                 int rmapAddress;
                 int rmapKey;
                 int RMAPtimeout;
             };
             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 SetRmapAddress(const QString & address);
+                void SetRmapKey(const QString & key);
+                void SetRmapTimeout(const QString & timeout);
             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 destinationKeyChanged(const QString & destKey);
                 void rmapAddressChanged(const QString & rmapaddress);
                 void rmapKeyChanged(const QString & key);
+                void rmapTimeoutChanged(const QString & timeout);
             private:
                 void makeGUI(socexplorerplugin *parent);
                 stardundeeSPW_USB_Manager* manager;
             //    QGridLayout* mainLayout;
             };
             #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