HG_REPOSITORIES/LPP/INSTRUMENTATION/SocExplorerPlugins Commit - r11:27ed47eb6044

Added disconnection auto-detection to the spacewire plugin.

Jeandet Alexis -

r11:27ed47eb6044 default

parent child

Context file:

r11:27ed47eb6044

Expand all files

.hgignore +4 0

@@ -1,3 +1,7
1	syntax: glob	1	syntax: glob
2	*.pro.user	2	*.pro.user
3	*.o	3	*.o
		4	moc_*
		5	.so
		6	ui_*.h
		7	Makefile

APBUARTPLUGIN/APBUARTPLUGIN.cpp +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2013, Laboratory of Plasmas Physic - CNRS
+            --  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 2 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 "APBUARTPLUGIN.h"
             #include <socexplorerengine.h>
             ApbUartPlugin::ApbUartPlugin(QWidget *parent):socexplorerplugin(parent)
             {
                 this->UI = new ApbUartPluginUi();
                 this->setWidget((QWidget*)this->UI);
                 this->useLoopBack = false;
                 connect(this->UI,SIGNAL(loopbackChkBxStateChanged(int)),this,SLOT(loopbackChangeState(int)));
                 connect(this,SIGNAL(apbUartTextReceived(QString)),this->UI,SIGNAL(apbUartTextReceived(QString)));
                 connect(&this->loopBackTimer,SIGNAL(timeout()),this,SLOT(uartReadout()));
             }
             ApbUartPlugin::~ApbUartPlugin()
             {
             }
             void ApbUartPlugin::closeMe()
             {
                 emit this->closePlugin(this);
             }
             void ApbUartPlugin::postInstantiationTrigger()
             {
                 if(this->isEnabled())
                 {
                     this->setBaseAddress(SocExplorerEngine::self()->getEnumDeviceBaseAddress(this,this->VID(),this->PID(),0));
                     loopbackChangeState(Qt::Checked);
                 }
             }
             void ApbUartPlugin::loopbackChangeState(int state)
             {
                 if(state==Qt::Checked)
                 {
                     enableLoopback();
                 }
                 else
                 {
                     disableLoopback();
                 }
             }
             void ApbUartPlugin::uartReadout()
             {
             #ifdef WIN32
                 int readcnt=0;
             #endif
                 if(this->isEnabled() && parent!=NULL)
                 {
                     if(this->useLoopBack)
                     {
                         if(this->baseAddress()!=-1)
                         {
                             this->loopBackTimer.stop();
                             unsigned int status_reg,data;
                             char ch;
                             QString printdata="";
                             parent->Read(&status_reg,1,this->baseAddress()+APB_UART_STATUS_REG);
                             while ((status_reg&4)==0) {
                                 parent->Read(&data,1,this->baseAddress()+APB_UART_FIFO_DEBUG_REG);
                                 ch = (char)(0xff & data);
                                 printdata+=ch;
             #ifdef WIN32
                                 readcnt++;
                                 if(readcnt>=32)
                                 {
                                     qApp->processEvents();
                                     break;
                                 }
             #endif
                                 parent->Read(&status_reg,1,this->baseAddress()+APB_UART_STATUS_REG);
                             }
                             if(printdata!="")
                                 emit apbUartTextReceived(printdata);
                             this->loopBackTimer.start(200);
                         }
                         else
                         {
                             this->setBaseAddress(SocExplorerEngine::self()->getEnumDeviceBaseAddress(this,this->VID(),this->PID(),0));
                             this->enableLoopback();
                         }
                     }
                 }
             }
             void ApbUartPlugin::activate(bool flag)
             {
                 this->setEnabled(flag);
                 emit this->activateSig(flag);
                 if(this->isEnabled())
                 {this->setBaseAddress(SocExplorerEngine::self()->getEnumDeviceBaseAddress(this,this->VID(),this->PID(),0));
                     loopbackChangeState(Qt::Checked);
                 }
             }
             void ApbUartPlugin::activateScan(bool flag)
             {
                 if(flag)
                     this->loopBackTimer.start(200);
                 else
                     this->loopBackTimer.stop();
             }
             int ApbUartPlugin::enableLoopback()
             {
                 this->useLoopBack = true;
                 this->loopBackTimer.start(200);
                 SocExplorerEngine::message(this,"Set FiFo debug mode mode");
                 if(parent==NULL)
                 {
                     SocExplorerEngine::message(this,"Can't set FiFo debug mode no parent driver accessible");
                     return -1;
                 }
                 if(this->baseAddress()==-1)
                 {
                     this->setBaseAddress(SocExplorerEngine::self()->getEnumDeviceBaseAddress(this,this->VID(),this->PID(),0));
                     if(this->baseAddress()==-1)
                         return -1;
                 }
                 unsigned int ctrl_reg= 0x843;
                 parent->Write(&ctrl_reg,1,this->baseAddress()+APB_UART_CONTROL_REG);
                 return 0;
             }
             int ApbUartPlugin::disableLoopback()
             {
                 SocExplorerEngine::message(this,"Disable FiFo debug mode mode");
                 if(parent==NULL)
                 {
                     SocExplorerEngine::message(this,"Can't disable FiFo debug mode no parent driver accessible");
                     return -1;
                 }
                 if(this->baseAddress()==-1)
                 {
                     this->setBaseAddress(SocExplorerEngine::self()->getEnumDeviceBaseAddress(this,this->VID(),this->PID(),0));
                     if(this->baseAddress()==-1)
                         return -1;
                 }
                 unsigned int ctrl_reg;
                 this->loopBackTimer.stop();
                 /* Firts get Control reg value*/
                 parent->Read(&ctrl_reg,1,this->baseAddress()+APB_UART_CONTROL_REG);
                 ctrl_reg = ctrl_reg & (~(1<<11));
                 parent->Write(&ctrl_reg,1,this->baseAddress()+APB_UART_CONTROL_REG);
                 this->useLoopBack = false;
                 return 0;
             }
             unsigned int ApbUartPlugin::Read(unsigned int *Value,unsigned int count,unsigned int address)
             {
                 if(parent!=NULL)
                     return parent->Read(Value,count,address);
                 return 0;
             }
             unsigned int ApbUartPlugin::Write(unsigned int *Value,unsigned int count, unsigned int address)
             {
                 if(parent!=NULL)
                     return parent->Write(Value,count,address);
                 return 0;
             }

APBUARTPLUGIN/APBUARTPLUGIN.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2013, Laboratory of Plasmas Physic - CNRS
+            --  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@member.fsf.org
             ----------------------------------------------------------------------------*/
             #ifndef APBUARTPLUGIN_H
             #define APBUARTPLUGIN_H
             #include <QMenuBar>
             #include <QMenu>
             #include <QAction>
             #include <QLayout>
             #include <socexplorerplugin.h>
             #include <apbuartpluginui.h>
             #include <QTimer>
             #define  APB_UART_DATA_REG          0x0
             #define  APB_UART_STATUS_REG        0x4
             #define  APB_UART_CONTROL_REG       0x8
             #define  APB_UART_SCALE_REG         0xC
             #define  APB_UART_FIFO_DEBUG_REG    0x10
             class ApbUartPlugin : public socexplorerplugin
             {
                 Q_OBJECT
             public:
                 explicit ApbUartPlugin(QWidget *parent = 0);
                 ~ApbUartPlugin();
                 int VID(){return driver_VID;}
                 int PID(){return driver_PID;}
             public slots:
                 unsigned int Write(unsigned int *Value,unsigned int count, unsigned int address=0);
                 unsigned int Read(unsigned int *Value,unsigned int count, unsigned int address=0);
                 void closeMe();
                 void postInstantiationTrigger();
                 void loopbackChangeState( int state );
                 void uartReadout();
                 void activateScan(bool flag);
                 void activate(bool flag);
             signals:
                 void apbUartTextReceived(QString text);
             private:
                 ApbUartPluginUi* UI;
                 bool useLoopBack;
                 QTimer loopBackTimer;
                 int enableLoopback();
                 int disableLoopback();
             };
             #endif // APBUARTPLUGIN_H

APBUARTPLUGIN/apbuartcfg.cpp +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2013, Laboratory of Plasmas Physic - CNRS
+            --  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@member.fsf.org
             ----------------------------------------------------------------------------*/
             #include "apbuartcfg.h"
             ApbUartCfg::ApbUartCfg(QWidget *parent) :
                 QWidget(parent)
             {
                 this->mainLayout = new QGridLayout(this);
                 this->loopbackChkBx = new QCheckBox(tr("Enable loopback"),this);
                 this->loopbackChkBx->setChecked(true);
                 this->mainLayout->addWidget(this->loopbackChkBx);
                 this->setLayout(this->mainLayout);
                 connect(this->loopbackChkBx,SIGNAL(stateChanged(int)),this,SIGNAL(loopbackChkBxStateChanged(int)));
             }

APBUARTPLUGIN/apbuartcfg.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2013, Laboratory of Plasmas Physic - CNRS
+            --  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@member.fsf.org
             ----------------------------------------------------------------------------*/
             #ifndef APBUARTCFG_H
             #define APBUARTCFG_H
             #include <QWidget>
             #include <QCheckBox>
             #include <QLabel>
             #include <QGridLayout>
             class ApbUartCfg : public QWidget
             {
                 Q_OBJECT
             public:
                 explicit ApbUartCfg(QWidget *parent = 0);
             signals:
                 void loopbackChkBxStateChanged( int state );
             public slots:
             private:
                 QCheckBox* loopbackChkBx;
                 QGridLayout* mainLayout;
             };
             #endif // APBUARTCFG_H

APBUARTPLUGIN/apbuartpluginui.cpp +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2013, Laboratory of Plasmas Physic - CNRS
+            --  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@member.fsf.org
             ----------------------------------------------------------------------------*/
             #include "apbuartpluginui.h"
             ApbUartPluginUi::ApbUartPluginUi(QWidget *parent) :
                 QTabWidget(parent)
             {
                 this->terminal = new ApbUartTerminal(this);
                 this->cfg = new ApbUartCfg(this);
                 this->addTab(this->cfg,"Config");
                 this->addTab(this->terminal,"terminal");
                 connect(this->cfg,SIGNAL(loopbackChkBxStateChanged(int)),this,SIGNAL(loopbackChkBxStateChanged(int)));
                 connect(this,SIGNAL(apbUartTextReceived(QString)),this->terminal,SIGNAL(apbUartTextReceived(QString)));
             }

APBUARTPLUGIN/apbuartpluginui.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2013, Laboratory of Plasmas Physic - CNRS
+            --  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@member.fsf.org
             ----------------------------------------------------------------------------*/
             #ifndef APBUARTPLUGINUI_H
             #define APBUARTPLUGINUI_H
             #include "apbuartcfg.h"
             #include <QWidget>
             #include <QGridLayout>
             #include <QTabWidget>
             #include <QCheckBox>
             #include <QLabel>
             #include <QLineEdit>
             #include <QTextEdit>
             #include "apbuartterminal.h"
             class ApbUartPluginUi : public QTabWidget
             {
                 Q_OBJECT
             public:
                 explicit ApbUartPluginUi(QWidget *parent = 0);
             signals:
                 void loopbackChkBxStateChanged( int state );
                 void apbUartTextReceived(QString text);
             public slots:
             private:
                 ApbUartCfg* cfg;
                 ApbUartTerminal* terminal;
             };
             #endif // APBUARTPLUGINUI_H

APBUARTPLUGIN/apbuartterminal.cpp +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2013, Laboratory of Plasmas Physic - CNRS
+            --  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@member.fsf.org
             ----------------------------------------------------------------------------*/
             #include "apbuartterminal.h"
             ApbUartTerminal::ApbUartTerminal(QWidget *parent) :
                 QTextEdit(parent)
             {
                 connect(this,SIGNAL(apbUartTextReceived(QString)),this,SLOT(append(QString)));
             }

APBUARTPLUGIN/apbuartterminal.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2013, Laboratory of Plasmas Physic - CNRS
+            --  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@member.fsf.org
             ----------------------------------------------------------------------------*/
             #ifndef APBUARTTERMINAL_H
             #define APBUARTTERMINAL_H
             #include <QWidget>
             #include <QTextEdit>
             class ApbUartTerminal : public QTextEdit
             {
                 Q_OBJECT
             public:
                 explicit ApbUartTerminal(QWidget *parent = 0);
             signals:
                 void apbUartTextReceived(QString text);
             public slots:
             };
             #endif // APBUARTTERMINAL_H

ahbuartplugin/ahbuartplugin.cpp +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2011, Laboratory of Plasmas Physic - CNRS
+            --  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 <socexplorerengine.h>
             #include "ahbuartplugin.h"
             #include <unistd.h>
             #include <errno.h>
             #include <QApplication>
             #include <QProgressBar>
             #include <stdio.h>
             #include <QThread>
             #include "ahbuartpywrapper.h"
             #include <QCompleter>
             #include <QStringList>
             #include <QLineEdit>
             #include <socexplorerproxy.h>
             ahbuartplugin::ahbuartplugin(QWidget *parent):socexplorerplugin(parent,false)
             {
                 this->port =(rs232port_t)NULL;
                 this->portMutex = new QMutex(QMutex::Recursive);
                 this->UI = new ahbUartPluginUI();
                 this->setWidget((QWidget*)this->UI);
                 QObject::connect(this,SIGNAL(activateSig(bool)),this->UI,SLOT(setConnected(bool)));
                 QObject::connect(this->UI,SIGNAL(connectPortsig(QString,int)),this,SLOT(togglePort(QString,int)));
                 this->pyObject = new ahbuartPywrapper(this);
                 QObject::connect(((ahbuartPywrapper*)this->pyObject),SIGNAL(open(QString,int)),this,SLOT(open(QString,int)));
                 QObject::connect(((ahbuartPywrapper*)this->pyObject),SIGNAL(close()),this,SLOT(close()));
                 QObject::connect(((ahbuartPywrapper*)this->pyObject),SIGNAL(ReadBytes(uint,uint)),this,SLOT(ReadBytes(uint,uint)));
                 QObject::connect(((ahbuartPywrapper*)this->pyObject),SIGNAL(WriteBytes(uint,QList<QVariant>)),this,SLOT(WriteBytes(uint,QList<QVariant>)));
                 QObject::connect(this->UI,SIGNAL(rescanPorts()),this,SLOT(updatePortList()));
                 this->portListcompleter = NULL;
                 this->scanDone = false;
                 updatePortList();
             }
             ahbuartplugin::~ahbuartplugin()
             {
                 if(this->port!=(rs232port_t)NULL)
                 {
                     rs232close(this->port);
                     this->port = (rs232port_t)NULL;
                 }
                 this->UI->close();
                 this->UI->~ahbUartPluginUI();
             }
             void ahbuartplugin::closeMe()
             {
                 if(this->port!=(rs232port_t)NULL)
                 {
                     rs232close(this->port);
                     this->port = (rs232port_t)NULL;
                 }
                 emit this->closePlugin(this);
             }
             int ahbuartplugin::registermenu(QMainWindow *menuHolder)
             {
                 this->menu = menuHolder->menuBar()->addMenu(tr("&AHB UART"));
                 this->closeAction = this->menu->addAction(tr("Close plugin"));
                 QObject::connect(this->closeAction,SIGNAL(triggered()),this,SLOT(closeMe()));
                 return 1;
             }
             bool ahbuartplugin::checkConnection()
             {
                 QTime timeout;
                 char test[5] ={(char)0x80,(char)0x80,(char)0,(char)0,(char)0};
                 char test2[1024];
                 int writen =0;
                 int read = 0;
                 timeout.start();
                 SocExplorerEngine::message(this,"Check connection",2);
                 while(writen!=5)
                 {
                     writen+=rs232write(this->port,test+writen,5-writen);
                     if(timeout.elapsed()>1000)
                     {
                         SocExplorerEngine::message(this,"Can't write any data on serial port",2);
                         return false;
                     }
                 }
             #ifdef WIN32
                         usleep(1000);
             #endif
                 timeout.restart();
                 while(read!=4)
                 {
                     read += rs232read(this->port,test2,4-read);
                     if(timeout.elapsed()>1000) break;
                 }
                 if(read>0)
                 {
                     SocExplorerEngine::message(this,"Connection Ok",2);
                     return true;
                 }
                 else
                 {
                     SocExplorerEngine::message(this,"Connection Error",2);
                     return false;
                 }
             }
             void ahbuartplugin::connectPort(QString PortName, int baudrate)
             {
                 QTime timeout;
                 SocExplorerEngine::message(this,"Try to connect to port "+PortName,2);
                 timeout.start();
                 if(this->port==(rs232port_t)NULL)
                 {
                     SocExplorerEngine::message(this,"Open port "+PortName,2);
                     this->port=rs232open((char*)PortName.toStdString().c_str());
                 }
                 if(this->port!=badPortValue)
                 {
                     SocExplorerEngine::message(this,"Port opened "+PortName,2);
                     SocExplorerEngine::message(this,"Configure port "+PortName,2);
                     rs232setup(this->port,8,baudrate,rs232parityNo,rs232OneStop);
                     char test[7] ={(char)0x55,(char)0x51,(char)0x80,(char)0x80,(char)0x0,(char)0x0,(char)0x14};
                     char test2[1024];
                     SAFEWRITE(test,1,timeout,2000,return);
                     SAFEWRITE((test+1),1,timeout,2000,return);
                     APPENDTOLOG(QString("Flush port "));
                     rs232read(this->port,test2,512);
                     int read = 0;
                     for(int i=0;i<10;i++)
                     {
                         SocExplorerEngine::message(this,"Send test patern :0x55,0x55,0x80,0x80,0x0,0x0,0x14",2);
                         SAFEWRITE(test+2,5,timeout,2000,return);
                         SocExplorerEngine::message(this,"Read Result",2);
                         read=rs232read(this->port,test2+read,16);
                         SocExplorerEngine::message(this,QString("Get ") + QString::number(read) + " bytes",2);
                         if(read>0)
                         {
                             SocExplorerEngine::message(this,"Flush port ",2);
                             while(rs232read(this->port,test2,1)>0);
                             this->Connected = true;
                             SocExplorerEngine::message(this,QString("Connection success on ")+PortName,2);
                             emit this->activate(true);
                             if(this->scanDone==false)
                             {
                                 socexplorerproxy::loadChildSysDriver(this,"AMBA_PLUGIN");
                                 this->scanDone=true;
                             }
                             break;
                         }
                     }
                 }
                 else
                 {
                     SocExplorerEngine::message(this,QString("Port not opened ")+PortName,2);
                     this->port = (rs232port_t)NULL;
                     this->Connected = false;
                     emit this->activateSig(false);
                     return;
                 }
                 if(this->Connected == false)
                 {
                     SocExplorerEngine::message(this,QString("Port not opened ")+PortName,2);
                     rs232close(this->port);
                     this->port = (rs232port_t)NULL;
                     emit this->activateSig(false);
                 }
             }
             bool ahbuartplugin::open(QString PortName,int baudrate)
             {
                 if(this->port!=(rs232port_t)NULL)
                     this->close();
                 this->UI->setconfig(PortName,baudrate);
                 this->connectPort(PortName,baudrate);
                 return (this->port!=(rs232port_t)NULL);
             }
             void ahbuartplugin::close()
             {
                 if(this->port!=(rs232port_t)NULL)
                 {
                     rs232close(this->port);
                     this->port = (rs232port_t)NULL;
                     this->Connected = false;
                     emit this->activateSig(false);
                 }
             }
             void ahbuartplugin::togglePort(QString PortName,int baudrate)
             {
                 if(this->port!=(rs232port_t)NULL)
                 {
                     this->close();
                 }
                 else
                 {
                     this->connectPort(PortName,baudrate);
                 }
             }
             unsigned int ahbuartplugin::Read(unsigned int *Value,unsigned int count,unsigned int address)
             {
                 QTime timeout;
                 timeout.start();
                 unsigned int read=0;
                 unsigned int cnt=count;
                 unsigned int nextUpdateTrig=0,updateStep=512;
                 SocExplorerEngine::message(this,QString("Read ")+ QString::number(count) + QString(" words @0x")+ QString::number(address,16),2);
                 if((this->port!= badPortValue)||(this->port!=(rs232port_t)NULL))
                 {
                     if(!this->portMutex->tryLock())
                         return 0;
                     if(!this->checkConnection())
                     {
                         this->Connected = false;
                         emit this->activateSig(false);
                         this->portMutex->unlock();
                         return 0;
                     }
                     QProgressBar* progress=NULL;
                     if(cnt>128)
                         progress= SocExplorerEngine::getProgressBar("Reading on uart @0x"+QString::number(address,16)+" %v of "+QString::number(count)+" words ",count);
                     char CMD[5];
                     char* result = (char*)malloc(count*4);
                     while(count>32)
                     {
                         CMD[0] = 0x80 |  (32-1);
                         CMD[1] = (char)((address>>24)&0xFF);
                         CMD[2] = (char)((address>>16)&0xFF);
                         CMD[3] = (char)((address>>8)&0xFF);
                         CMD[4] = (char)((address)&0xFF);
             //            APENDTABLETOLOG(CMD,5,logmessage,"Write CMD : ");
                         SAFEWRITE(CMD,5,timeout,1000,return 0);
             #ifdef WIN32
                         usleep(1000);
             #endif
                         SAFEREAD(result+((cnt-count)*4),32*4,timeout,1000,return 0);
             //            APENDTABLETOLOG((result+((cnt-count)*4)),32*4,logmessage, QString("Get ") + QString::number(32*4) + " Bytes : ");
                         count-=32;
                         address+=32*4;
                         if(cnt>128)
                         {
                             if((cnt-count)>=nextUpdateTrig)
                             {
                                 progress->setValue(cnt-count);
                                 qApp->processEvents();
                                 nextUpdateTrig+=updateStep;
                             }
                         }
                     }
                     if(count>0)
                     {
                         CMD[0] = 0x80 |  (count-1);
                         CMD[1] = (char)((address>>24)&0xFF);
                         CMD[2] = (char)((address>>16)&0xFF);
                         CMD[3] = (char)((address>>8)&0xFF);
                         CMD[4] = (char)((address)&0xFF);
                         SAFEWRITE(CMD,5,timeout,1000,return 0);
             #ifdef WIN32
                         usleep(1000);
             #endif
                         SAFEREAD(result+((cnt-count)*4),(count*4),timeout,1000,return 0);
             //            APENDTABLETOLOG((result+((cnt-count)*4)),(count*4),logmessage, QString("Get ") + QString::number(32*4) + " Bytes : ");
                     }
                     if(cnt>128)
                     {
                         progress->setValue(cnt-count);
                         qApp->processEvents();
                     }
                     for(int i=0;(unsigned int)i<cnt;i++)
                     {
                         for(int j =0;j<4;j++)
                         {
                             Value[i]= ((unsigned char)(result[i*4+j])) + Value[i]*256;
                         }
                         read = cnt*4;
                     }
                     if(cnt>128)
                         SocExplorerEngine::deleteProgressBar(progress);
                     free(result);
                     this->portMutex->unlock();
                 }
                 return read/4;
             }
             unsigned int ahbuartplugin::Write(unsigned int *Value,unsigned int count, unsigned int address)
             {
                 QTime timeout;
                 timeout.start();
                 unsigned int writen=0;
                 unsigned int nextUpdateTrig=0,updateStep=512;
                 SocExplorerEngine::message(this,QString("Write ")+ QString::number(count) + QString(" words @0x")+ QString::number(address,16),2);
                 if((this->port!= badPortValue)||(this->port!=(rs232port_t)NULL))
                 {
                     if(!this->portMutex->tryLock())
                         return 0;
                     if(!this->checkConnection())
                     {
                         emit this->activateSig(false);
                         this->Connected = false;
                         this->portMutex->unlock();
                         return 0;
                     }
                     QProgressBar* progress = NULL;
                     if(count>128)
                         progress = SocExplorerEngine::getProgressBar("Writing on uart @0x"+QString::number(address,16)+" %v of "+QString::number(count)+" words ",count);
                     int offset = 0;
                     char* CMD= (char*)malloc((32*4)+5);
                     while(count>32)
                     {
                         writen=0;
                         CMD[0] = 0xC0 |  (32-1);
                         CMD[1] = (char)(((unsigned int)address>>24)&0xFF);
                         CMD[2] = (char)(((unsigned int)address>>16)&0xFF);
                         CMD[3] = (char)(((unsigned int)address>>8)&0xFF);
                         CMD[4] = (char)(((unsigned int)address)&0xFF);
                         for(int i=0;i<32;i++)
                         {
                             CMD[(i*4)+5] = (char)(((unsigned int)Value[i+offset]>>24)&0xFF);
                             CMD[(i*4)+6] = (char)(((unsigned int)Value[i+offset]>>16)&0xFF);
                             CMD[(i*4)+7] = (char)(((unsigned int)Value[i+offset]>>8)&0xFF);
                             CMD[(i*4)+8] = (char)(((unsigned int)Value[i+offset])&0xFF);
                         }
                         SAFEWRITE(CMD,((32*4)+5),timeout,1000,return 0);
                         writen+=32;
                         count-=32;
                         offset+=32;
                         address+=32*4;
                         if(offset>=nextUpdateTrig && progress!=NULL)
                         {
                             progress->setValue(offset);
                             qApp->processEvents();
                             nextUpdateTrig +=updateStep;
                         }
                     }
                     if(count>0)
                     {
                         CMD[0] = 0xC0 |  (count-1);
                         CMD[1] = (char)(((unsigned int)address>>24)&0xFF);
                         CMD[2] = (char)(((unsigned int)address>>16)&0xFF);
                         CMD[3] = (char)(((unsigned int)address>>8)&0xFF);
                         CMD[4] = (char)(((unsigned int)address)&0xFF);
                         for(int i=0;(unsigned int) i<(count);i++)
                         {
                             CMD[(i*4)+5] = (char)(((unsigned int)Value[i+offset]>>24)&0xFF);
                             CMD[(i*4)+6] = (char)(((unsigned int)Value[i+offset]>>16)&0xFF);
                             CMD[(i*4)+7] = (char)(((unsigned int)Value[i+offset]>>8)&0xFF);
                             CMD[(i*4)+8] = (char)(((unsigned int)Value[i+offset])&0xFF);
                         }
                         SAFEWRITE(CMD,((count*4)+5),timeout,1000,return 0);
                         writen+=count;
                     }
                     if(progress!=NULL)
                     {
                         progress->setValue(writen);
                         qApp->processEvents();
                         SocExplorerEngine::deleteProgressBar(progress);
                     }
                     free(CMD);
                     this->portMutex->unlock();
                     return writen;
                 }
                 return 0;
             }
             void ahbuartplugin::updatePortList()
             {
                 if(this->portListcompleter==(QCompleter*)NULL)
                 {
                     this->portListcompleter=new QCompleter(this);
                     this->portListcompleter->setCaseSensitivity(Qt::CaseInsensitive);
                     this->portListcompleterModel = new QStringListModel(this);
                     this->portListcompleter->setModel(this->portListcompleterModel);
                     this->UI->setCompleter(this->portListcompleter);
                 }
                 rs232portslist_t* portlist = rs232getportlist();
                 rs232portslist_t* portlistenum = portlist;
                 QStringList wordList;
                 while(portlistenum!=NULL)
                 {
                     wordList << portlistenum->name;
                     portlistenum = portlistenum->next;
                 }
                 rs232deleteportlist(portlist);
                 this->portListcompleterModel->setStringList(wordList);
             }
             QVariantList ahbuartplugin::ReadBytes(unsigned int address, unsigned int count)
             {
                 unsigned int data[(count/4)+1];
                 QVariantList result;
                 this->Read(data,(count/4)+1,address);
                 for(unsigned int i = 0;i<count/4;i++)
                 {
                     result.append(QVariant((int)(0x0FF&(data[i]>>24))));
                     result.append(QVariant((int)(0x0FF&(data[i]>>16))));
                     result.append(QVariant((int)(0x0FF&(data[i]>>8))));
                     result.append(QVariant((int)(0x0FF&(data[i]))));
                 }
                 for(int i=0;i<(count%4);i++)
                 {
                     result.append(QVariant((int)(0x0FF&(data[count/4]>>((3-i)*8)))));
                 }
                 return result;
             }
             void ahbuartplugin::WriteBytes(unsigned int address, QList<QVariant> dataList)
             {
                 unsigned int data[dataList.count()/4];
                 for(int i = 0;i<(dataList.count()/4);i++)
                 {
                     data[i] = 0x0FF & ((unsigned int)dataList.at(4*i).toUInt());
                     data[i] =  (data[i]<<8) + (0x0FF & ((unsigned int)dataList.at((4*i)+1).toUInt()));
                     data[i] =  (data[i]<<8) + (0x0FF & ((unsigned int)dataList.at((4*i)+2).toUInt()));
                     data[i] =  (data[i]<<8) + (0x0FF & ((unsigned int)dataList.at((4*i)+3).toUInt()));
                 }
                 this->Write(data,dataList.count()/4,address);
             }

ahbuartplugin/ahbuartplugin.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2011, Laboratory of Plasmas Physic - CNRS
+            --  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
             ----------------------------------------------------------------------------*/
             #ifndef AHBUARTPLUGIN_H
             #define AHBUARTPLUGIN_H
             #include <QMenuBar>
             #include <QMenu>
             #include <QAction>
             #include <QLayout>
             #include <QMutex>
             #include <QProgressDialog>
             #include <QStringListModel>
             #include <QTime>
             #include <socexplorerplugin.h>
             #include "ahbuartpluginui.h"
             #ifdef WinRs232
                 #include "librs232/RS232.h"
             #else
                 #include <RS232.h>
                 #undef debug
             #endif
             #define APPENDTOLOG(message) this->UI->appendToLogFile(QTime::currentTime().toString() +":" + QString::number(QTime::currentTime().msec()) + ": " + message)
             #define APENDTABLETOLOG(table,size,Qstr,message) \
                 Qstr.clear();\
                 Qstr+=message;\
                 for(int __i__tbllog__=0;(unsigned int)__i__tbllog__<size;__i__tbllog__++)\
                 {\
                     if(__i__tbllog__%16==0) Qstr += "\n"; \
                     Qstr += "0x" + QString::number((int)(0xff & table[__i__tbllog__]),16) +"\t";\
                 }\
                 APPENDTOLOG(Qstr);
             #define SAFEWRITE(data,count,timer,timeout,error) \
             while(1)\
             {\
                 unsigned int __writen__=0; \
                 (timer).restart(); \
                 while(__writen__!=(count)) \
                 {\
                     __writen__ += rs232write(this->port,((data)+__writen__),((count)-__writen__)); \
                     if((timer).elapsed()>(timeout)) \
                     {\
                         APPENDTOLOG(QString("Timeout error while writing"));\
                         this->port = (rs232port_t)NULL; \
                         this->Connected = false; \
                         emit this->activateSig(false); \
                         error; \
                     } \
                 } \
                 break;\
             }
             #define SAFEREAD(data,count,timer,timeout,error) \
             unsigned int __read__=0; \
             (timer).restart(); \
                 while(__read__ != (count)) \
             { \
                 __read__+=rs232read(this->port,((data)+__read__),((count)-__read__)); \
                 if((timer).elapsed()>(timeout)) \
                 { \
                     APPENDTOLOG(QString("Timeout error while reading"));\
                     this->Connected = false; \
                     emit this->activateSig(false); \
                     this->portMutex->unlock(); \
                     error; \
                 } \
             } \
             class ahbuartplugin : public socexplorerplugin
             {
                 Q_OBJECT
             public:
                 ahbuartplugin(QWidget *parent = 0);
                 ~ahbuartplugin();
                 int registermenu(QMainWindow *menuHolder);
                 int VID(){return driver_VID;}
                 int PID(){return driver_PID;}
             public slots:
                 void togglePort(QString PortName,int baudrate);
                 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 closeMe();
                 void close();
                 bool open(QString PortName,int baudrate);
                 void updatePortList();
                 QVariantList ReadBytes(unsigned int address,unsigned int count);
                 void WriteBytes(unsigned int address,QList<QVariant> dataList);
             signals:
                 void setProgressValue(int progress);
             private:
                 bool scanDone;
                 QProgressDialog* progress;
                 QLayout * mainLayout;
                 ahbUartPluginUI* UI;
                 QMutex* portMutex;
                 rs232port_t port;
                 QCompleter *portListcompleter;
                 QStringListModel *portListcompleterModel;
                 void connectPort(QString PortName,int baudrate);
                 bool checkConnection();
             };
             #endif // AHBUARTPLUGIN_H

ahbuartplugin/ahbuartpluginui.cpp +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2011, Laboratory of Plasmas Physic - CNRS
+            --  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 "ahbuartpluginui.h"
             #include "ui_ahbuartpluginui.h"
             ahbUartPluginUI::ahbUartPluginUI(QWidget *parent) :
                 QWidget(parent),
                 ui(new Ui::ahbUartPluginUI)
             {
                 ui->setupUi(this);
                 connect(ui->OpenPort,SIGNAL(clicked()),this,SLOT(connectPort()));
                 connect(ui->PortspeedSlider,SIGNAL(valueChanged(int)),ui->baurateLCD,SLOT(display(int)));
                 connect(ui->logFileChooseBp,SIGNAL(clicked()),this,SLOT(chooseLogFile()));
                 connect(this,SIGNAL(setLogFileName(QString)),this->ui->logFileName,SLOT(setText(QString)));
                 connect(ui->rescanPorts,SIGNAL(clicked()),this,SIGNAL(rescanPorts()));
                 this->logFile = new QFile();
             }
             void ahbUartPluginUI::connectPort()
             {
                 emit this->connectPortsig(ui->PortName->text(),ui->PortspeedSlider->value());
             }
             void ahbUartPluginUI::setConnected(bool connected)
             {
                 if(connected == true)
                 {
                     ui->OpenPort->setText(tr("Close port"));
                 }
                 else
                     ui->OpenPort->setText(tr("Open port"));
             }
             ahbUartPluginUI::~ahbUartPluginUI()
             {
                 delete ui;
             }
             void ahbUartPluginUI::chooseLogFile()
             {
                 if(this->logFile->isOpen())
                     this->logFile->close();
                 this->logFile->setFileName(QFileDialog::getSaveFileName(this,tr("Open Log file"),QDir::homePath(), tr("Log Files (*.txt *.log)")));
                 if(this->logFile->open(QIODevice::WriteOnly))
                 {
                     this->logFileStrm = new QTextStream(this->logFile);
                     emit this->setLogFileName(this->logFile->fileName());
                 }
             }
             void ahbUartPluginUI::setconfig(QString PortName, int baudrate)
             {
                 this->ui->PortName->setText(PortName);
                 this->ui->PortspeedSlider->setValue(baudrate);
             }
             void ahbUartPluginUI::logFileEnDisable(int state)
             {
                 if(state==Qt::Checked)
                 {
                     this->logFileEn = true;
                 }
                 else if(state==Qt::Unchecked)
                 {
                     this->logFileEn = false;
                 }
             }
             bool ahbUartPluginUI::islogfileenable()
             {
                 return this->logFileEn;
             }
             void ahbUartPluginUI::appendToLogFile(const QString & text)
             {
                 if(this->logFileEn && this->logFile->isOpen())
                 {
                     *(this->logFileStrm) << text << endl;
                 }
             }
             void ahbUartPluginUI::setCompleter(QCompleter *completer)
             {
                 this->ui->PortName->setCompleter(completer);
             }
             void ahbUartPluginUI::closeEvent(QCloseEvent *event)
             {
                 if(this->logFile->isOpen())
                 {
                     this->logFileStrm->flush();
                     this->logFile->waitForBytesWritten(3000);
                     this->logFile->close();
                 }
                 event->accept();
             }

ahbuartplugin/ahbuartpluginui.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2011, Laboratory of Plasmas Physic - CNRS
+            --  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
             ----------------------------------------------------------------------------*/
             #ifndef AHBUARTPLUGINUI_H
             #define AHBUARTPLUGINUI_H
             #include <QWidget>
             #include <QFile>
             #include <QTextStream>
             #include <QFileDialog>
             #include <QDir>
             #include <QCloseEvent>
             #include <QCompleter>
             namespace Ui {
                 class ahbUartPluginUI;
             }
             class ahbUartPluginUI : public QWidget
             {
                 Q_OBJECT
             public:
                 explicit ahbUartPluginUI(QWidget *parent = 0);
                 ~ahbUartPluginUI();
                 bool islogfileenable();
                 void appendToLogFile(const QString & text);
                 void closeEvent(QCloseEvent *event);
                 void setCompleter(QCompleter* completer);
             public slots:
                 void setConnected(bool connected);
                 void connectPort();
                 void chooseLogFile();
                 void logFileEnDisable(int state);
                 void setconfig(QString PortName,int baudrate);
             signals:
                 void connectPortsig(QString PortName,int baudrate);
                 void setLogFileName(QString FileName);
                 void rescanPorts();
             private:
                 Ui::ahbUartPluginUI *ui;
                 QFile* logFile;
                 QTextStream* logFileStrm;
                 bool logFileEn;
             };
             #endif // AHBUARTPLUGINUI_H

ahbuartplugin/ahbuartpywrapper.cpp +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2011, Laboratory of Plasmas Physic - CNRS
+            --  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 "ahbuartpywrapper.h"
             #include <QObject>
             #include <QFile>
             #include <QTextStream>
             #include <byteswap.h>
             #include <stdint.h>
             ahbuartPywrapper::ahbuartPywrapper(socexplorerplugin *parent) :
                 genericPySysdriver(parent)
             {
             }

ambaplugin/AHB/ahbdevicelist.cpp +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2011, Laboratory of Plasmas Physic - CNRS
+            --  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 "ahbdevicelist.h"
             ahbdevicelist::ahbdevicelist(QWidget *parent):QTableWidget(parent)
             {
                 this->setColumnCount(7);
                 this->setHorizontalHeaderLabels(QStringList() << tr("Device Name")<<tr("BAR0")<<tr("BAR1")<<tr("BAR2")<<tr("BAR3")<<tr("Vendor ID")<<tr("Product ID"));
             }
             void ahbdevicelist::clearAHBdevicesList()
             {
                 this->clear();
                 this->setRowCount(0);
                 this->setHorizontalHeaderLabels(QStringList() << tr("Device Name")<<tr("BAR0")<<tr("BAR1")<<tr("BAR2")<<tr("BAR3")<<tr("Vendor ID")<<tr("Product ID"));
             }
             void ahbdevicelist::addAHBdevice(ahbdeviceInfo* device)
             {
                 if(this->rowCount()==0)
                 {
                     this->setRowCount(1);
                 }
                 else
                 {
                     this->insertRow(this->rowCount());
                 }
                 this->ahbdevices.append(device);
                 QTableWidgetItem *newItem = new QTableWidgetItem(*device->deviceName);
                 newItem->setFlags(newItem->flags() &~ Qt::ItemIsEditable);
                 this->setItem(this->rowCount()-1, 0, newItem);
                 for(int i=0;i<4;i++)
                 {
                     if(device->BAR[i].size!=0)
                     {
                         newItem = new QTableWidgetItem("0x" + QString::number(device->BAR[i].address, 16)+" -> 0x"+ QString::number(device->BAR[i].address + device->BAR[i].size-1, 16)+" size = "+device->barAdressSize(i));
                         newItem->setFlags(newItem->flags() &~ Qt::ItemIsEditable);
                         this->setItem(this->rowCount()-1, i+1, newItem);
                     }
                 }
                 newItem = new QTableWidgetItem("0x" + QString::number(device->VID , 16));
                 newItem->setFlags(newItem->flags() &~ Qt::ItemIsEditable);
                 this->setItem(this->rowCount()-1, 5, newItem);
                 newItem = new QTableWidgetItem("0x" + QString::number(device->PID , 16));
                 newItem->setFlags(newItem->flags() &~ Qt::ItemIsEditable);
                 this->setItem(this->rowCount()-1, 6, newItem);
                 this->resizeColumnsToContents();
             }

ambaplugin/AHB/ahbdevicelist.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2011, Laboratory of Plasmas Physic - CNRS
+            --  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
             ----------------------------------------------------------------------------*/
             #ifndef AHBDEVICELIST_H
             #define AHBDEVICELIST_H
             #include <QTableWidget>
             #include <QString>
             #include <QList>
             typedef struct
             {
                 unsigned int address;
                 unsigned int size;
                 unsigned char type;
                 bool prefectchable;
                 bool cacheable;
             }AHBbarreg;
             class ahbdeviceInfo
             {
             public:
                 ahbdeviceInfo()
                 {
                 }
                 ahbdeviceInfo(const QString deviceName,AHBbarreg BAR0,AHBbarreg BAR1, AHBbarreg BAR2,AHBbarreg BAR3,int VID,int PID)
                 {
                     this->deviceName = new QString(deviceName);
                     this->BAR[0]=BAR0;
                     this->BAR[1]=BAR1;
                     this->BAR[2]=BAR2;
                     this->BAR[3]=BAR3;
                     this->VID = VID;
                     this->PID = PID;
                 }
                 QString barAdressSize(int barIndex)
                 {
                     int k=0;
                     unsigned int size=this->BAR[barIndex].size;
                     while(size>=1024){size=size>>10;k++;}
                     switch(k)
                     {
                     case 0:
                         return (QString::number(size, 10) + "B");
                         break;
                     case 1:
                         return (QString::number(size, 10) + "kB");
                         break;
                     case 2:
                         return (QString::number(size, 10) + "MB");
                         break;
                     case 3:
                         return (QString::number(size, 10) + "GB");
                         break;
                     case 4:
                         return (QString::number(size, 10) + "TB");
                         break;
                     default:
                         return (QString::number(this->BAR[barIndex].size, 10) + "B");
                         break;
                     }
                 }
                 QString* deviceName;
                 AHBbarreg BAR[4];
                 int VID;
                 int PID;
             };
             class ahbdevicelist: public QTableWidget
             {
                 Q_OBJECT
             public:
                 explicit ahbdevicelist(QWidget * parent = 0);
             public slots:
                 void addAHBdevice(ahbdeviceInfo* device);
                 void clearAHBdevicesList();
             private:
                 QList<ahbdeviceInfo*> ahbdevices;
             };
             #endif // AHBDEVICELIST_H

ambaplugin/AHB/ahbpluginui.cpp +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2011, Laboratory of Plasmas Physic - CNRS
+            --  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 "ahbpluginui.h"
             #include <socexplorerengine.h>
             ahbPluginUi::ahbPluginUi(socexplorerplugin *plugin, QWidget *parent) :
                 QWidget(parent)
             {
                 this->mainlayout = new QHBoxLayout;
                 this->scanBp = new QPushButton(tr("Scan AHB"));
                 this->deviceslst = new ahbdevicelist;
                 this->mainlayout->addWidget(this->deviceslst);
                 this->mainlayout->addWidget(this->scanBp);
                 this->setLayout(this->mainlayout);
                 this->_plugin = plugin;
                 connect(this,SIGNAL(addAHBdevice(ahbdeviceInfo*)),this->deviceslst,SLOT(addAHBdevice(ahbdeviceInfo*)));
                 connect(this,SIGNAL(clearAHBdevicesList()),this->deviceslst,SLOT(clearAHBdevicesList()));
                 connect(this->scanBp,SIGNAL(clicked()),this,SLOT(scanAHB()));
             }
             ahbdeviceInfo* ahbPluginUi::extractInfos(int *pnpregs)
             {
                 AHBbarreg BAR[4];
                 int VID;
                 int PID;
                 for(int i=0;i<4;i++)
                 {
                     BAR[i].address = pnpregs[i+4] & 0xfff00000;
                     BAR[i].size = (pnpregs[i+4] & 0x0000fff0)<<16;
                     if(BAR[i].size!=0)
                         BAR[i].size = (((-1^BAR[i].size)|BAR[i].address)-BAR[i].address)+1;
                     BAR[i].cacheable = (bool)((pnpregs[i+4]&0x00010000)>>16);
                     BAR[i].prefectchable = (bool)((pnpregs[i+4]&0x00020000)>>17);
                     BAR[i].type = (unsigned char)(pnpregs[i+4]&0xf);
                 }
                 VID = (pnpregs[0]>>24)&0xff;
                 PID = (pnpregs[0]>>12)&0xfff;
                 QString devname = SocExplorerEngine::getDevName(VID,PID);
                 return new ahbdeviceInfo(devname,BAR[0],BAR[1],BAR[2],BAR[3],VID,PID);
             }
             void ahbPluginUi::scanAHB()
             {
                 unsigned int size = AHB_PLUGNPLAY_SLAVE_STOP- AHB_PLUGNPLAY_MASTER_START;
                 int j=0;
                 unsigned long long i = AHB_PLUGNPLAY_MASTER_START;
                 int pnpregs[AHB_PLUGNPLAY_SLAVE_STOP- AHB_PLUGNPLAY_MASTER_START];
                 emit this->clearAHBdevicesList();
                 if( this->_plugin->Read((unsigned int*)pnpregs,size,(unsigned int)AHB_PLUGNPLAY_MASTER_START)==size)
                 {
                     while(i<AHB_PLUGNPLAY_SLAVE_STOP)
                     {
                         if(pnpregs[j]!=0)
                         {
                             ahbdeviceInfo* devinfo=this->extractInfos(pnpregs+j);
                             if(!devinfo->deviceName->compare("DSU3"))
                                 SocExplorerEngine::addEnumDevice(this->_plugin,devinfo->VID,devinfo->PID,devinfo->BAR[0].address,*devinfo->deviceName);
                             emit this->addAHBdevice(devinfo);
                         }
                         i+=32;
                         j+=8;
                     }
                 }
             }

ambaplugin/AHB/ahbpluginui.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2011, Laboratory of Plasmas Physic - CNRS
+            --  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
             ----------------------------------------------------------------------------*/
             #ifndef AHBPLUGINUI_H
             #define AHBPLUGINUI_H
             #include <QWidget>
             #include <QHBoxLayout>
             #include <QPushButton>
             #include "ahbdevicelist.h"
             #include <socexplorerplugin.h>
             #define AHB_PLUGNPLAY_MASTER_START ((unsigned int)(0xFFFFF000))
             #define AHB_PLUGNPLAY_MASTER_STOP  ((unsigned int)(0xFFFFF800))
             #define AHB_PLUGNPLAY_SLAVE_START  ((unsigned int)(0xFFFFF800))
             #define AHB_PLUGNPLAY_SLAVE_STOP   ((unsigned int)(0xFFFFFFFC))
             class ahbPluginUi : public QWidget
             {
                 Q_OBJECT
             public:
                 explicit ahbPluginUi(socexplorerplugin* plugin,QWidget *parent = 0);
                 ahbdeviceInfo* extractInfos(int* pnpregs);
             public slots:
                 void scanAHB();
             signals:
                 void addAHBdevice(ahbdeviceInfo* device);
                 void clearAHBdevicesList();
                 unsigned int WriteSig(unsigned int* Value,unsigned int count,unsigned int address);
                 unsigned int ReadSig(unsigned int* Value,unsigned int count,unsigned int address);
             private:
                 QHBoxLayout* mainlayout;
                 QPushButton* scanBp;
                 ahbdevicelist* deviceslst;
                 socexplorerplugin* _plugin;
             };
             #endif // AHBPLUGINUI_H

ambaplugin/APB/apbdevicelist.cpp +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2011, Laboratory of Plasmas Physic - CNRS
+            --  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 "apbdevicelist.h"
             apbdevicelist::apbdevicelist(QWidget *parent):QTableWidget(parent)
             {
                 this->setColumnCount(4);
                 this->setHorizontalHeaderLabels(QStringList() << tr("Device Name")<<tr("BAR0")<<tr("Vendor ID")<<tr("Product ID"));
             }
             void apbdevicelist::clearAPBdevicesList()
             {
                 this->clear();
                 this->setRowCount(0);
                 this->setHorizontalHeaderLabels(QStringList() << tr("Device Name")<<tr("BAR0")<<tr("Vendor ID")<<tr("Product ID"));
             }
             void apbdevicelist::addAPBdevice(apbdeviceInfo* device)
             {
                 if(this->rowCount()==0)
                 {
                     this->setRowCount(1);
                 }
                 else
                 {
                     this->insertRow(this->rowCount());
                 }
                 this->apbdevices.append(device);
                 QTableWidgetItem *newItem = new QTableWidgetItem(device->deviceName);
                 newItem->setFlags(newItem->flags() &~ Qt::ItemIsEditable);
                 this->setItem(this->rowCount()-1, 0, newItem);
                 for(int i=0;i<1;i++)
                 {
                     if(device->BAR[i].size!=0)
                     {
                         newItem = new QTableWidgetItem("0x" + QString::number(device->BAR[i].address, 16)+" -> 0x"+ QString::number(device->BAR[i].address + device->BAR[i].size-1, 16)+" size = "+device->barAdressSize(i));
                         newItem->setFlags(newItem->flags() &~ Qt::ItemIsEditable);
                         this->setItem(this->rowCount()-1, i+1, newItem);
                     }
                 }
                 newItem = new QTableWidgetItem("0x" + QString::number(device->VID , 16));
                 newItem->setFlags(newItem->flags() &~ Qt::ItemIsEditable);
                 this->setItem(this->rowCount()-1, 2, newItem);
                 newItem = new QTableWidgetItem("0x" + QString::number(device->PID , 16));
                 newItem->setFlags(newItem->flags() &~ Qt::ItemIsEditable);
                 this->setItem(this->rowCount()-1, 3, newItem);
                 this->resizeColumnsToContents();
             }

ambaplugin/APB/apbdevicelist.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2011, Laboratory of Plasmas Physic - CNRS
+            --  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
             ----------------------------------------------------------------------------*/
             #ifndef APBDEVICELIST_H
             #define APBDEVICELIST_H
             #include <QTableWidget>
             #include <QString>
             #include <QList>
             typedef struct
             {
                 unsigned int address;
                 unsigned int size;
                 unsigned char type;
             }APBbarreg;
             class apbdeviceInfo
             {
             public:
                 apbdeviceInfo()
                 {
                 }
                 apbdeviceInfo(const QString deviceName,APBbarreg BAR0,int VID,int PID)
                 {
                     this->deviceName = deviceName;
                     this->BAR[0]=BAR0;
                     this->VID = VID;
                     this->PID = PID;
                 }
                 QString barAdressSize(int barIndex)
                 {
                     int k=0;
                     unsigned int size=this->BAR[barIndex].size;
                     while(size>=1024){size=size>>10;k++;}
                     switch(k)
                     {
                     case 0:
                         return (QString::number(size, 10) + "B");
                         break;
                     case 1:
                         return (QString::number(size, 10) + "kB");
                         break;
                     case 2:
                         return (QString::number(size, 10) + "MB");
                         break;
                     case 3:
                         return (QString::number(size, 10) + "GB");
                         break;
                     case 4:
                         return (QString::number(size, 10) + "TB");
                         break;
                     default:
                         return (QString::number(this->BAR[barIndex].size, 10) + "B");
                         break;
                     }
                 }
                 QString deviceName;
                 APBbarreg BAR[1];
                 int VID;
                 int PID;
             };
             class apbdevicelist: public QTableWidget
             {
                 Q_OBJECT
             public:
                 explicit apbdevicelist(QWidget * parent = 0);
             public slots:
                 void addAPBdevice(apbdeviceInfo* device);
                 void clearAPBdevicesList();
             private:
                 QList<apbdeviceInfo*> apbdevices;
             };
             #endif // APBDEVICELIST_H

ambaplugin/APB/apbpluginui.cpp +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2011, Laboratory of Plasmas Physic - CNRS
+            --  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 "apbpluginui.h"
             #include <stdint.h>
             #include <socexplorerengine.h>
             apbPluginUi::apbPluginUi(socexplorerplugin *plugin, QWidget *parent) :
                 QWidget(parent)
             {
                 this->setWindowTitle(tr("APB Driver"));
                 this->mainlayout = new QHBoxLayout;
                 this->scanBp = new QPushButton(tr("Scan APB"));
                 this->deviceslst = new apbdevicelist;
                 this->mainlayout->addWidget(this->deviceslst);
                 this->mainlayout->addWidget(this->scanBp);
                 this->setLayout(this->mainlayout);
                 this->_plugin = plugin;
                 connect(this,SIGNAL(addAPBdevice(apbdeviceInfo*)),this->deviceslst,SLOT(addAPBdevice(apbdeviceInfo*)));
                 connect(this,SIGNAL(clearAPBdevicesList()),this->deviceslst,SLOT(clearAPBdevicesList()));
                 connect(this->scanBp,SIGNAL(clicked()),this,SLOT(scanAPB()));
             }
             void apbPluginUi::lockScanBp()
             {
                 this->scanBp->setEnabled(false);
             }
             void apbPluginUi::unlockScanBp()
             {
                 this->scanBp->setEnabled(true);
             }
             apbdeviceInfo* apbPluginUi::extractInfos(int *pnpregs)
             {
                 APBbarreg BAR[1];
                 int VID;
                 int PID;
                 for(int i=0;i<1;i++)
                 {
                     BAR[i].address = ((uint32_t)(pnpregs[i+1] & 0xfff00000)>>12)+ APB_BUS_START;
                     BAR[i].size = ((pnpregs[i+1] & 0x00000ff0)>>4 )+1;
                     BAR[i].type = (unsigned char)(pnpregs[i+1]&0xf);
                 }
                 VID = (pnpregs[0]>>24)&0xff;
                 PID = (pnpregs[0]>>12)&0xfff;
                 QString devname = SocExplorerEngine::getDevName(VID,PID);
                 return new apbdeviceInfo(devname,BAR[0],VID,PID);
             }
             void apbPluginUi::scanAPB()
             {
                 this->lockScanBp();
                 unsigned int size = APB_PLUGNPLAY_STOP - APB_PLUGNPLAY_START;
                 int j=0;
                 unsigned long long i = APB_PLUGNPLAY_START;
                 int pnpregs[APB_PLUGNPLAY_STOP - APB_PLUGNPLAY_START];
                 emit this->clearAPBdevicesList();
                 if(this->_plugin->Read((unsigned int*)pnpregs,size/4,(unsigned int)APB_PLUGNPLAY_START)==(size/4))
                 {
                     while(i<APB_PLUGNPLAY_STOP)
                     {
                         if(pnpregs[j]!=0)
                         {
                             apbdeviceInfo* devinfos=this->extractInfos(pnpregs+j);
                             SocExplorerEngine::addEnumDevice(this->_plugin,devinfos->VID,devinfos->PID,devinfos->BAR[0].address,devinfos->deviceName);
                             emit this->addAPBdevice(devinfos);
                         }
                         i+=8;
                         j+=2;
                         if(pnpregs[0]==pnpregs[j]&&pnpregs[1]==pnpregs[j+1])break;
                     }
                 }
                 this->unlockScanBp();
             }

ambaplugin/APB/apbpluginui.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2011, Laboratory of Plasmas Physic - CNRS
+            --  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
             ----------------------------------------------------------------------------*/
             #ifndef APBPLUGINUI_H
             #define APBPLUGINUI_H
             #include <QWidget>
             #include <QHBoxLayout>
             #include <QPushButton>
             #include "apbdevicelist.h"
             #include <socexplorerplugin.h>
             #define APB_BUS_START        ((unsigned int)(0x80000000))
             #define APB_PLUGNPLAY_START  ((unsigned int)(0x800FF000))
             #define APB_PLUGNPLAY_STOP   ((unsigned int)(0x800FF000+(512*8)))
             class apbPluginUi : public QWidget
             {
                 Q_OBJECT
             public:
                 explicit apbPluginUi(socexplorerplugin* plugin,QWidget *parent = 0);
                 void lockScanBp();
                 void unlockScanBp();
                 apbdeviceInfo* extractInfos(int* pnpregs);
             signals:
                 void addAPBdevice(apbdeviceInfo* device);
                 void clearAPBdevicesList();
                 unsigned int WriteSig(unsigned int* Value,unsigned int count,unsigned int address);
                 unsigned int ReadSig(unsigned int* Value,unsigned int count,unsigned int address);
             public slots:
                 void scanAPB();
             private:
                 QHBoxLayout* mainlayout;
                 QPushButton* scanBp;
                 apbdevicelist* deviceslst;
                 socexplorerplugin* _plugin;
             };
             #endif // APBPLUGINUI_H

ambaplugin/ambaplugin.cpp +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2012, Laboratory of Plasmas Physic - CNRS
+            --  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
             ----------------------------------------------------------------------------*/
             #include "ambaplugin.h"
             ambaplugin::ambaplugin(QWidget *parent):socexplorerplugin(parent,true)
             {
                 this->UI = new ambaPluginUI(this);
                 this->setWidget((QWidget*)this->UI);
                 connect(this->UI,SIGNAL(ReadSig(uint*,uint,uint)),this,SLOT(Read(uint*,uint,uint)));
                 connect(this->UI,SIGNAL(WriteSig(uint*,uint,uint)),this,SLOT(Write(uint*,uint,uint)));
                 connect(this,SIGNAL(activateSig(bool)),this,SLOT(activatePlugin(bool)));
             }
             ambaplugin::~ambaplugin()
             {
             }
             void ambaplugin::closeMe()
             {
                 emit this->closePlugin(this);
             }
             void ambaplugin::postInstantiationTrigger()
             {
                 if(this->parent->isConnected())
                 {
                     this->UI->scanAll();
                 }
             }
             void ambaplugin::activatePlugin(bool flag)
             {
                 if(flag)
                 {
                     this->UI->scanAll();
                 }
             }
             int ambaplugin::registermenu(QMainWindow *menuHolder)
             {
                 this->menu = menuHolder->menuBar()->addMenu(tr("&ambaplugin"));
                 this->closeAction = this->menu->addAction(tr("Close plugin"));
                 QObject::connect(this->closeAction,SIGNAL(triggered()),this,SLOT(closeMe()));
                 return 1;
             }
             unsigned int ambaplugin::Read(unsigned int *Value,unsigned int count,unsigned int address)
             {
                 if(parent!=NULL)
                     return parent->Read(Value,count,address);
                 return 0;
             }
             unsigned int ambaplugin::Write(unsigned int *Value,unsigned int count, unsigned int address)
             {
                 if(parent!=NULL)
                     return parent->Write(Value,count,address);
                 return 0;
             }

ambaplugin/ambaplugin.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2012, Laboratory of Plasmas Physic - CNRS
+            --  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 ambaplugin_H
             #define ambaplugin_H
             #include <QMenuBar>
             #include <QMenu>
             #include <QAction>
             #include <QLayout>
             #include "ambapluginui.h"
             #include <socexplorerplugin.h>
             class ambaplugin : public socexplorerplugin
             {
                 Q_OBJECT
             public:
                 explicit ambaplugin(QWidget *parent = 0);
                 ~ambaplugin();
                 int registermenu(QMainWindow *menuHolder);
                 int VID(){return driver_VID;}
                 int PID(){return driver_PID;}
             public slots:
                 unsigned int Write(unsigned int *Value,unsigned int count, unsigned int address=0);
                 unsigned int Read(unsigned int *Value,unsigned int count, unsigned int address=0);
                 void closeMe();
                 void postInstantiationTrigger();
                 void activatePlugin(bool flag);
             signals:
             private:
                  ambaPluginUI* UI;
             };
             #endif // ambaplugin_H

ambaplugin/ambapluginui.cpp +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2012, Laboratory of Plasmas Physic - CNRS
+            --  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
             ----------------------------------------------------------------------------*/
             #include "ambapluginui.h"
             ambaPluginUI::ambaPluginUI(socexplorerplugin *plugin, QWidget *parent) :
                 QWidget(parent)
             {
                 this->mainLayout=new QGridLayout();
                 this->ahbPlugin=new ahbPluginUi(plugin);
                 this->apbPlugin=new apbPluginUi(plugin);
                 this->mainLayout->addWidget(this->ahbPlugin,0,0,1,-1);
                 this->mainLayout->addWidget(this->apbPlugin,1,0,1,-1);
                 this->setLayout(this->mainLayout);
                 connect(this->ahbPlugin,SIGNAL(ReadSig(uint*,uint,uint)),this,SIGNAL(ReadSig(uint*,uint,uint)));
                 connect(this->ahbPlugin,SIGNAL(WriteSig(uint*,uint,uint)),this,SIGNAL(WriteSig(uint*,uint,uint)));
                 connect(this->apbPlugin,SIGNAL(ReadSig(uint*,uint,uint)),this,SIGNAL(ReadSig(uint*,uint,uint)));
                 connect(this->apbPlugin,SIGNAL(WriteSig(uint*,uint,uint)),this,SIGNAL(WriteSig(uint*,uint,uint)));
             }
             void ambaPluginUI::scanAll()
             {
                 this->ahbPlugin->scanAHB();
                 this->apbPlugin->scanAPB();
             }

ambaplugin/ambapluginui.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2012, Laboratory of Plasmas Physic - CNRS
+            --  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 AMBAPLUGINUI_H
             #define AMBAPLUGINUI_H
             #include <QWidget>
             #include <QVBoxLayout>
             #include <QGridLayout>
             #include <QPushButton>
             #include "AHB/ahbpluginui.h"
             #include "APB/apbpluginui.h"
             class ambaPluginUI : public QWidget
             {
                 Q_OBJECT
             public:
                 explicit ambaPluginUI(socexplorerplugin* plugin,QWidget *parent = 0);
             signals:
                 unsigned int WriteSig(unsigned int* Value,unsigned int count,unsigned int address);
                 unsigned int ReadSig(unsigned int* Value,unsigned int count,unsigned int address);
             public slots:
                 void scanAll();
             private:
                 QGridLayout* mainLayout;
                 ahbPluginUi* ahbPlugin;
                 apbPluginUi* apbPlugin;
             };
             #endif // AMBAPLUGINUI_H

dsu3plugin/dsu3plugin.cpp +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2011, Laboratory of Plasmas Physic - CNRS
+            --  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()));
                 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,SIGNAL(updateInfo(elfparser*)),this->UI,SIGNAL(updateInfo(elfparser*)));
             }
             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);
             }
             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 +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2012, Laboratory of Plasmas Physic - CNRS
+            --  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();
             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;
             };
             #endif // DSU3PLUGIN_H

dsu3plugin/dsu3pluginui.cpp +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2013, Laboratory of Plasmas Physic - CNRS
+            --  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*)));
             }

dsu3plugin/dsu3pluginui.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2012, Laboratory of Plasmas Physic - CNRS
+            --  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:
             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

genericrwplugin/genericrwplugin.cpp +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2011, Laboratory of Plasmas Physic - CNRS
+            --  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 "genericrwplugin.h"
             #include "genericrwpluginpywrapper.h"
             genericrwplugin::genericrwplugin(QWidget *parent):socexplorerplugin(parent,false)
             {
                 this->UI = new genericrwpluginUi();
                 this->setWidget((QWidget*)this->UI);
                 connect(this->UI,SIGNAL(ReadSig(uint*,uint,uint)),this,SLOT(Read(uint*,uint,uint)));
                 connect(this->UI,SIGNAL(WriteSig(uint*,uint,uint)),this,SLOT(Write(uint*,uint,uint)));
                 this->pyObject = new genericRWpluginPyWrapper(this);
                 //QObject::connect(this->pyObject,SIGNAL(ReadSig(uint*,uint,uint)),this,SLOT(Read(uint*,uint,uint)));
                 //QObject::connect(this->pyObject,SIGNAL(WriteSig(uint*,uint,uint)),this,SLOT(Write(uint*,uint,uint)));
                 QObject::connect(((genericRWpluginPyWrapper*)this->pyObject),SIGNAL(refresh()),this->UI,SIGNAL(refresh()));
                 QObject::connect(((genericRWpluginPyWrapper*)this->pyObject),SIGNAL(setAddress(quint32)),this->UI,SIGNAL(setAddress(quint32)));
                 QObject::connect(((genericRWpluginPyWrapper*)this->pyObject),SIGNAL(setLength(quint32)),this->UI,SIGNAL(setLength(quint32)));
             }
             genericrwplugin::~genericrwplugin()
             {}
             int genericrwplugin::registermenu(QMainWindow *menuHolder)
             {
                 this->menu = menuHolder->menuBar()->addMenu(tr("&Generic RW Driver"));
                 this->closeAction = this->menu->addAction(tr("Close plugin"));
                 QObject::connect(this->closeAction,SIGNAL(triggered()),this,SLOT(closeMe()));
                 return 1;
             }
             unsigned int genericrwplugin::Write(unsigned int *Value,unsigned int count,unsigned int address)
             {
                 if(parent!=NULL)
                     return parent->Write(Value,count,address);
                 return 0;
             }
             unsigned int genericrwplugin::Read(unsigned int *Value,unsigned int count,unsigned int address)
             {
                 if(parent!=NULL)
                     return parent->Read(Value,count,address);
                 return 0;
             }

genericrwplugin/genericrwplugin.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2011, Laboratory of Plasmas Physic - CNRS
+            --  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
             ----------------------------------------------------------------------------*/
             #ifndef GENERICRWPLUGIN_H
             #define GENERICRWPLUGIN_H
             #include "genericrwpluginui.h"
             #include <QMenuBar>
             #include <QMenu>
             #include <QAction>
             #include <QMainWindow>
             #include <socexplorerplugin.h>
             #define AHB_PLUGNPLAY_MASTER_START 0xFFFFF000
             #define AHB_PLUGNPLAY_MASTER_STOP  0xFFFFF800
             #define AHB_PLUGNPLAY_SLAVE_START  0xFFFFF800
             #define AHB_PLUGNPLAY_SLAVE_STOP   0xFFFFFFFC
             class genericrwplugin : public socexplorerplugin
             {
                 Q_OBJECT
             public:
                 explicit genericrwplugin(QWidget *parent = 0);
                 ~genericrwplugin();
                 int registermenu(QMainWindow *menuHolder);
             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);
             signals:
             private:
                 genericrwpluginUi* UI;
             };
             #endif // GENERICRWPLUGIN_H

genericrwplugin/genericrwpluginpywrapper.cpp +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2014, Laboratory of Plasmas Physic - CNRS
+            --  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 "genericrwpluginpywrapper.h"
             genericRWpluginPyWrapper::genericRWpluginPyWrapper(socexplorerplugin *parent) :
                 genericPySysdriver(parent)
             {
             }

genericrwplugin/genericrwpluginpywrapper.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2014, Laboratory of Plasmas Physic - CNRS
+            --  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 GENERICRWPLUGINPYWRAPPER_H
             #define GENERICRWPLUGINPYWRAPPER_H
             #include <genericPySysdriver.h>
             class genericRWpluginPyWrapper : public genericPySysdriver
             {
                 Q_OBJECT
             public:
                 explicit genericRWpluginPyWrapper(socexplorerplugin *parent = 0);
             signals:
                 void refresh();
                 void setAddress(quint32 address);
                 void setLength(quint32 length);
             public slots:
             };
             #endif // GENERICRWPLUGINPYWRAPPER_H

genericrwplugin/genericrwpluginui.cpp +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2011, Laboratory of Plasmas Physic - CNRS
+            --  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 "genericrwplugin.h"
             genericrwpluginUi::genericrwpluginUi(QWidget *parent) :
                 QWidget(parent)
             {
                 this->mainlayout = new QHBoxLayout;
                 this->tabWdgt = new QTabWidget;
                 this->mainlayout->addWidget(this->tabWdgt);
                 this->memEditorWdgt = new memEditor;
                 this->tabWdgt->addTab(this->memEditorWdgt,tr("Memory editor"));
                 this->setLayout(this->mainlayout);
                 connect(this->memEditorWdgt,SIGNAL(WriteSig(uint*,uint,uint)),this,SIGNAL(WriteSig(uint*,uint,uint)));
                 connect(this->memEditorWdgt,SIGNAL(ReadSig(uint*,uint,uint)),this,SIGNAL(ReadSig(uint*,uint,uint)));
                 connect(this,SIGNAL(refresh()),this->memEditorWdgt,SLOT(readMemSlt()));
                 connect(this,SIGNAL(setAddress(quint32)),this->memEditorWdgt,SLOT(setAddress(quint32)));
                 connect(this,SIGNAL(setLength(quint32)),this->memEditorWdgt,SLOT(setLength(quint32)));
             }

genericrwplugin/genericrwpluginui.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2011, Laboratory of Plasmas Physic - CNRS
+            --  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
             ----------------------------------------------------------------------------*/
             #ifndef AHBPLUGINUI_H
             #define AHBPLUGINUI_H
             #include <QWidget>
             #include <QHBoxLayout>
             #include <QTabWidget>
             #include <QPushButton>
             #include "memeditor.h"
             #include <QSplitter>
             class genericrwpluginUi : public QWidget
             {
                 Q_OBJECT
             public:
                 explicit genericrwpluginUi(QWidget *parent = 0);
             signals:
                 unsigned int WriteSig(unsigned int* Value,unsigned int count,unsigned int address);
                 unsigned int ReadSig(unsigned int* Value,unsigned int count,unsigned int address);
                 void refresh();
                 void setAddress(quint32 address);
                 void setLength(quint32 length);
             private:
                 QSplitter* verticalSpliter;
                 QHBoxLayout* mainlayout;
                 QTabWidget* tabWdgt;
                 memEditor* memEditorWdgt;
             };
             #endif // AHBPLUGINUI_H

genericrwplugin/memeditor.cpp +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2011, Laboratory of Plasmas Physic - CNRS
+            --  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 "memeditor.h"
             #include "malloc.h"
             memEditor::memEditor(QWidget *parent) :
                 QWidget(parent)
             {
                 this->verticalSpliter = new QSplitter;
                 this->ctrlWidget = new QWidget;
                 this->verticalSpliter->setOrientation(Qt::Horizontal);
                 this->mainLayout = new QHBoxLayout;
                 this->ctrlLayout = new QVBoxLayout;
                 this->hexEditor = new QHexEdit;
                 this->addressSpnBx = new QHexSpinBox;
                 this->SizeWidget = new MemSizeWdgt(256);
                 this->readMemQPb = new QPushButton(tr("Read Mem"));
                 this->writeMemQPb = new QPushButton(tr("Write Mem"));
                 this->ctrlLayout->addWidget(this->addressSpnBx);
                 this->ctrlLayout->addWidget(this->SizeWidget);
                 this->ctrlLayout->addWidget(this->readMemQPb);
                 this->ctrlLayout->addWidget(this->writeMemQPb);
                 this->ctrlWidget->setLayout(this->ctrlLayout);
                 this->verticalSpliter->addWidget(this->hexEditor);
                 this->verticalSpliter->addWidget(this->ctrlWidget);
                 this->mainLayout->addWidget(this->verticalSpliter);
                 this->setLayout(this->mainLayout);
                 connect(this->readMemQPb,SIGNAL(clicked()),this,SLOT(readMemSlt()));
                 connect(this->writeMemQPb,SIGNAL(clicked()),this,SLOT(writeMemSlt()));
                 this->SizeWidget->setMaximum(16384);
             }
             void memEditor::writeMemSlt()
             {
                 QByteArray data = this->hexEditor->data();
                 unsigned int length = data.length()/4;
                 unsigned int* buffer=(unsigned int*)malloc(length*sizeof(int));
                 unsigned int address = this->hexEditor->addressOffset();
                 for(int i=0;(unsigned int)i<length;i++)
                 {
                     buffer[i]=((data[4*i]<<24)&0xFF000000)+((data[(4*i)+1]<<16)&0x00FF0000)+((data[(4*i)+2]<<8)&0x0000FF00)+(data[(4*i)+3]&0x000000FF);
                 }
                 emit this->WriteSig(buffer,length,address);
                 free(buffer);
             }
             void memEditor::setAddress(quint32 address)
             {
                 this->addressSpnBx->setValue(address);
             }
             void memEditor::setLength(quint32 length)
             {
                 this->SizeWidget->setSizeValue(length);
             }
             void memEditor::readMemSlt()
             {
                 this->SizeWidget->updateSizeValue();
                 unsigned int size = this->SizeWidget->getsize()/4;
                 unsigned int buffer[16384];
                 unsigned char buffChar[16384*4];
                 unsigned int address = this->addressSpnBx->value();
                 if((emit this->ReadSig(buffer,size,address&(-4)))==size)
                 {
                     for(int i=0;(unsigned int)i<size;i++)
                     {
                         buffChar[4*i]=(buffer[i]>>24)&0xFF;
                         buffChar[(4*i)+1]=(buffer[i]>>16)&0xFF;
                         buffChar[(4*i)+2]=(buffer[i]>>8)&0xFF;
                         buffChar[(4*i)+3]=(buffer[i])&0xFF;
                     }
                     QByteArray data = QByteArray((char*)buffChar,size*4);
                     this->hexEditor->setData(data);
                     this->hexEditor->setAddressOffset(address&(-4));
                     this->addressSpnBx->setValue(address&(-4));
                 }
             }

genericrwplugin/memeditor.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2011, Laboratory of Plasmas Physic - CNRS
+            --  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
             ----------------------------------------------------------------------------*/
             #ifndef MEMEDITOR_H
             #define MEMEDITOR_H
             #include <QWidget>
             #include <QVBoxLayout>
             #include <QHBoxLayout>
             #include <QPushButton>
             #include <QByteArray>
             #include <QSplitter>
             #include <qhexedit.h>
             #include <qhexspinbox.h>
             #include <memsizewdgt.h>
             class memEditor : public QWidget
             {
                 Q_OBJECT
             public:
                 explicit memEditor(QWidget *parent = 0);
             signals:
                 unsigned int WriteSig(unsigned int* Value,unsigned int count,unsigned int address);
                 unsigned int ReadSig(unsigned int* Value,unsigned int count,unsigned int address);
             public slots:
                 void readMemSlt();
                 void writeMemSlt();
                 void setAddress(quint32 address);
                 void setLength(quint32 length);
             private:
                 QWidget* ctrlWidget;
                 QSplitter* verticalSpliter;
                 QHBoxLayout* mainLayout;
                 QVBoxLayout* ctrlLayout;
                 QHexEdit* hexEditor;
                 QHexSpinBox* addressSpnBx;
                 QPushButton* readMemQPb;
                 QPushButton* writeMemQPb;
                 MemSizeWdgt* SizeWidget;
             };
             #endif // MEMEDITOR_H

memctrlrplugin/memctrlrplugin.cpp +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2011, Laboratory of Plasmas Physic - CNRS
+            --  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 "memctrlrplugin.h"
             #include "memctrlrpywrapper.h"
             memctrlrplugin::memctrlrplugin(QWidget *parent):socexplorerplugin(parent,false)
             {
                 this->UI = new memctrlrPluginUi();
                 this->setWidget((QWidget*)this->UI);
                 connect(this->UI,SIGNAL(WriteSig(uint*,uint,uint)),this,SLOT(Write(uint*,uint,uint)));
                 connect(this->UI,SIGNAL(ReadSig(uint*,uint,uint)),this,SLOT(Read(uint*,uint,uint)));
                 this->pyObject = new memctrlrPyWrapper(this);
                 connect(this->pyObject,SIGNAL(launchTest(uint,uint)),this,SLOT(launchTest(uint,uint)));
             }
             memctrlrplugin::~memctrlrplugin()
             {}
             int memctrlrplugin::registermenu(QMainWindow *menuHolder)
             {
                 this->menu = menuHolder->menuBar()->addMenu(tr("&Memory Controler"));
                 this->closeAction = this->menu->addAction(tr("Close plugin"));
                 QObject::connect(this->closeAction,SIGNAL(triggered()),this,SLOT(closeMe()));
                 return 1;
             }
             unsigned int memctrlrplugin::Write(unsigned int *Value,unsigned int count,unsigned int address)
             {
                 if(parent)
                     return parent->Write(Value,count,address);
                 return 0;
             }
             unsigned int memctrlrplugin::Read(unsigned int *Value,unsigned  int count,unsigned int address)
             {
                 if(parent)
                     return parent->Read(Value,count,address);
                 return 0;
             }
             bool memctrlrplugin::launchTest(unsigned int baseAddress,unsigned int size)
             {
                 if(parent==NULL)return false;
                 unsigned int* dataLocal = (unsigned int*)malloc(size);
                 unsigned int* dataOnBoard = (unsigned int*)malloc(size);
                 bool res=true;
                 for(int i=0;(unsigned int)i<(size>>2);i++)
                 {
                     dataLocal[i]= (0xFFFF&rand())+(rand()<<16);
                 }
                 parent->Write(dataLocal,size>>2,baseAddress);
                 parent->Read(dataOnBoard,size>>2,baseAddress);
                 for(int i=0;(unsigned int)i<(size>>2);i++)
                 {
                     if(dataLocal[i]!=dataOnBoard[i])
                         res=false;
                 }
                 free(dataLocal);
                 free(dataOnBoard);
                 return res;
             }

memctrlrplugin/memctrlrplugin.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2011, Laboratory of Plasmas Physic - CNRS
+            --  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
             ----------------------------------------------------------------------------*/
             #ifndef MEMCTRLRPLUGIN_H
             #define MEMCTRLRPLUGIN_H
             #include "memctrlrpluginui.h"
             #include <QMenuBar>
             #include <QMenu>
             #include <QAction>
             #include <QMainWindow>
             #include <socexplorerplugin.h>
             #include <socexplorerplugin.h>
             class memctrlrplugin : public socexplorerplugin
             {
                 Q_OBJECT
             public:
                 explicit memctrlrplugin(QWidget *parent = 0);
                 ~memctrlrplugin();
                 int registermenu(QMainWindow *menuHolder);
             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);
                 bool launchTest(unsigned int baseAddress,unsigned int size);
             signals:
             private:
                 memctrlrPluginUi* UI;
             };
             #endif // MEMCTRLRPLUGIN_H

memctrlrplugin/memctrlrpluginui.cpp +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2011, Laboratory of Plasmas Physic - CNRS
+            --  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 "memctrlrpluginui.h"
             memctrlrPluginUi::memctrlrPluginUi(QWidget *parent) :
                 QWidget(parent)
             {
                 this->mainlayout = new QHBoxLayout;
                 this->memorycheckWdgt = new memorycheck;
                 this->tabWdgt = new QTabWidget;
                 this->tabWdgt->addTab(this->memorycheckWdgt,QString(tr("Memory Check")));
                 this->mainlayout->addWidget(this->tabWdgt);
                 this->setLayout(this->mainlayout);
                 connect(this->memorycheckWdgt,SIGNAL(ReadSig(uint*,uint,uint)),this,SIGNAL(ReadSig(uint*,uint,uint)));
                 connect(this->memorycheckWdgt,SIGNAL(WriteSig(uint*,uint,uint)),this,SIGNAL(WriteSig(uint*,uint,uint)));
             }

memctrlrplugin/memctrlrpluginui.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2011, Laboratory of Plasmas Physic - CNRS
+            --  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
             ----------------------------------------------------------------------------*/
             #ifndef MEMCTRLRPLUGINUI_H
             #define MEMCTRLRPLUGINUI_H
             #include <QWidget>
             #include <QHBoxLayout>
             #include <QPushButton>
             #include <QTabWidget>
             #include "memorycheck.h"
             class memctrlrPluginUi : public QWidget
             {
                 Q_OBJECT
             public:
                 explicit memctrlrPluginUi(QWidget *parent = 0);
             signals:
                 unsigned int WriteSig(unsigned int* Value,unsigned int count,unsigned int address);
                 unsigned int ReadSig(unsigned int* Value,unsigned int count,unsigned int address);
             private:
                 QHBoxLayout* mainlayout;
                 QTabWidget* tabWdgt;
                 memorycheck* memorycheckWdgt;
             };
             #endif

spwplugin/abstractspwbridge.cpp +1 -1

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

spwplugin/abstractspwbridge.h +3 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2014, Laboratory of Plasmas Physic - CNRS
+            --  Copyright (C) 2014, Plasma Physics Laboratory - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@member.fsf.org
             ----------------------------------------------------------------------------*/
             #ifndef ABSTRACTSPWBRIDGE_H
             #define ABSTRACTSPWBRIDGE_H
             #include <QObject>
             #include <socexplorerplugin.h>
             #define RMAP_MAX_XFER_SIZE 4000 //slightly less than 16kBytes
             #include <spw.h>
             class abstractSpwBridge : public QObject
             {
                 Q_OBJECT
             public:
                 explicit abstractSpwBridge(socexplorerplugin *parent);
                 QWidget *getGUI();
             public slots:
                 virtual bool connectBridge();
                 virtual bool disconnectBridge();
                 virtual unsigned int Write(unsigned int *Value,unsigned int count, unsigned int address=0)=0;
                 virtual unsigned int Read(unsigned int *Value,unsigned int count, unsigned int address=0)=0;
                 virtual int pushRMAPPacket(char* packet,int size)=0;
+            signals:
+                void setConnected(bool connected);
             protected:
                 socexplorerplugin* plugin;
                 QWidget* p_GUI;
             private:
             };
             #endif // ABSTRACTSPWBRIDGE_H

spwplugin/spw.h +1 -1

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

spwplugin/spwplugin.cpp +10 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2014, Laboratory of Plasmas Physic - CNRS
+            --  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>
             spwplugin::spwplugin(QWidget *parent):socexplorerplugin(parent,true)
             {
                 Q_UNUSED(parent)
                 this->bridge = NULL;
                 this->scanDone = false;
                 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)));
                 }
             }
+            void spwplugin::setConnected(bool connected)
+            {
+                this->Connected = connected;
+                emit activateSig(connected);
+            }
             unsigned int spwplugin::Write(unsigned int *Value,unsigned int count, unsigned int address)
             {
                 if(Connected)
                 {
                     return  bridge->Write(Value,count,address);
                 }
                 return 0;
             }

spwplugin/spwplugin.h +3 -2

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

spwplugin/stardundeeGUI.ui +44 -4

             <?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>614</width>
+                <width>645</width>
-                <height>152</height>
+                <height>231</height>
                </rect>
               </property>
               <property name="windowTitle">
                <string>Form</string>
               </property>
               <layout class="QFormLayout" name="formLayout">
                <property name="fieldGrowthPolicy">
                 <enum>QFormLayout::AllNonFixedFieldsGrow</enum>
                </property>
                <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">
                  <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">
                  <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">
                  <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="inputMask">
-                  <string comment="009"/>
+                  <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="QPushButton" name="pushButton">
+                <widget class="QLineEdit" name="RMAPAddresslineEdit">
+                 <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="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">
+                <widget class="QPushButton" name="connectQpb">
                  <property name="text">
                   <string>Connect</string>
                  </property>
                 </widget>
                </item>
               </layout>
              </widget>
              <resources/>
              <connections/>
             </ui>

spwplugin/stardundeegui.cpp +89 0

@@ -1,9 +1,98
		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 "stardundeegui.h"	22	#include "stardundeegui.h"
2		23
3	#include "ui_stardundeeGUI.h"	24	#include "ui_stardundeeGUI.h"
4		25
5	StarDundeeGUI::StarDundeeGUI(QWidget *parent) :	26	StarDundeeGUI::StarDundeeGUI(QWidget *parent) :
6	QWidget(parent),ui(new Ui::StarDundeeUI)	27	QWidget(parent),ui(new Ui::StarDundeeUI)
7	{	28	{
8	this->ui->setupUi(this);	29	this->ui->setupUi(this);
		30	connect(this->ui->selectBrickCmbx,SIGNAL(currentIndexChanged(int)),this,SIGNAL(brickSelectionChanged(int)));
		31	connect(this->ui->selectLinkCmbx,SIGNAL(currentIndexChanged(int)),this,SIGNAL(linkNumberSelectionChanged(int)));
		32	connect(this->ui->setLinkSpeedCmbx,SIGNAL(currentIndexChanged(QString)),this,SIGNAL(linkSpeedSelectionChanged(QString)));
		33	connect(this->ui->destKeyLineEdit,SIGNAL(textChanged(QString)),this,SIGNAL(destinationKeyChanged(QString)));
		34	connect(this->ui->RMAPAddresslineEdit,SIGNAL(textChanged(QString)),this,SIGNAL(rmapAddressChanged(QString)));
		35	connect(this->ui->RMAPKeylineEdit,SIGNAL(textChanged(QString)),this,SIGNAL(rmapKeyChanged(QString)));
		36	connect(this->ui->connectQpb,SIGNAL(clicked()),this,SIGNAL(connectClicked()));
		37
9	}	38	}
		39
		40	int StarDundeeGUI::getBrickSelection()
		41	{
		42	return ui->selectBrickCmbx->currentIndex();
		43	}
		44
		45	int StarDundeeGUI::getLinkNumberSelection()
		46	{
		47	return ui->selectLinkCmbx->currentIndex();
		48	}
		49
		50	QString StarDundeeGUI::getLinkSpeedSelection()
		51	{
		52	return ui->setLinkSpeedCmbx->currentText();
		53	}
		54
		55	QString StarDundeeGUI::getDestinationKey()
		56	{
		57	return ui->destKeyLineEdit->text();
		58	}
		59
		60	QString StarDundeeGUI::getRmapAddress()
		61	{
		62	return ui->RMAPAddresslineEdit->text();
		63	}
		64
		65	QString StarDundeeGUI::getRmapKey()
		66	{
		67	return ui->RMAPKeylineEdit->text();
		68	}
		69
		70
		71
		72	void StarDundeeGUI::lock(bool lock)
		73	{
		74	this->ui->selectBrickCmbx->setDisabled(lock);
		75	this->ui->selectLinkCmbx->setDisabled(lock);
		76	this->ui->setLinkSpeedCmbx->setDisabled(lock);
		77	this->ui->destKeyLineEdit->setDisabled(lock);
		78	this->ui->RMAPAddresslineEdit->setDisabled(lock);
		79	this->ui->RMAPKeylineEdit->setDisabled(lock);
		80	if(lock)
		81	this->ui->connectQpb->setText("Disconnect");
		82	else
		83	this->ui->connectQpb->setText("Connect");
		84	}
		85
		86	void StarDundeeGUI::updateAvailableBrickCount(int count)
		87	{
		88	this->ui->selectBrickCmbx->clear();
		89	this->ui->selectBrickCmbx->addItem("none");
		90	for(int i =0;i<32;i++)
		91	{
		92	if((count&1)==1)
		93	{
		94	this->ui->selectBrickCmbx->addItem("STAR-Dundee USB brick "+QString::number(i));
		95	}
		96	count>>=1;
		97	}
		98	}

spwplugin/stardundeegui.h +36 -2

@@ -1,24 +1,58
		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	#ifndef STARDUNDEEGUI_H	22	#ifndef STARDUNDEEGUI_H
2	#define STARDUNDEEGUI_H	23	#define STARDUNDEEGUI_H
3		24
4	#include <QWidget>	25	#include <QWidget>
5		26
6	namespace Ui {	27	namespace Ui {
7	class StarDundeeUI;	28	class StarDundeeUI;
8	}	29	}
9		30
10	class StarDundeeGUI : public QWidget	31	class StarDundeeGUI : public QWidget
11	{	32	{
12	Q_OBJECT	33	Q_OBJECT
13	public:	34	public:
14	explicit StarDundeeGUI(QWidget *parent = 0);	35	explicit StarDundeeGUI(QWidget *parent = 0);
15		36	int getBrickSelection();
		37	int getLinkNumberSelection();
		38	QString getLinkSpeedSelection();
		39	QString getDestinationKey();
		40	QString getRmapAddress();
		41	QString getRmapKey();
16	signals:	42	signals:
17		43	void brickSelectionChanged(int brickIndex);
		44	void linkNumberSelectionChanged(int linkIndex);
		45	void linkSpeedSelectionChanged(const QString & linkSpeed);
		46	void destinationKeyChanged(const QString & destKey);
		47	void rmapAddressChanged(const QString & address);
		48	void rmapKeyChanged(const QString & key);
		49	void connectClicked();
18	public slots:	50	public slots:
		51	void lock(bool lock);
		52	void updateAvailableBrickCount(int count);
19		53
20	private:	54	private:
21	Ui::StarDundeeUI *ui;	55	Ui::StarDundeeUI *ui;
22	};	56	};
23		57
24	#endif // STARDUNDEEGUI_H	58	#endif // STARDUNDEEGUI_H

spwplugin/stardundeespw_usb.cpp +141 -58

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2014, Laboratory of Plasmas Physic - CNRS
+            --  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->connectBridgeButton->setText("Connect");
+                        ((StarDundeeGUI*)this->p_GUI)->lock(false);
+                        emit setConnected(false);
                     }
                 }
                 else
                 {
                     if(this->connectBridge())
                     {
-                        this->connectBridgeButton->setText("Disconnect");
+                        ((StarDundeeGUI*)this->p_GUI)->lock(true);
+                        emit setConnected(true);
                     }
                 }
             }
             bool stardundeeSPW_USB::connectBridge()
             {
                 return this->manager->connectBridge();
             }
             bool stardundeeSPW_USB::disconnectBridge()
             {
                 return this->manager->disconnectBridge();
             }
             int stardundeeSPW_USB::pushRMAPPacket(char *packet, int size)
             {
                 return this->manager->sendPacket(packet,size);
             }
             unsigned int stardundeeSPW_USB::Write(unsigned int *Value, unsigned int count, unsigned int address)
             {
                 char writeBuffer[RMAP_WRITE_PACKET_MIN_SZ((RMAP_MAX_XFER_SIZE*4))+1];
-                writeBuffer[0]=1;//Link number
+                writeBuffer[0]=this->manager->linkNumber;//Link number
                 int transactionID = 0;
                 int written=0;
-                SocExplorerEngine::message(this->plugin,"Enter Write function");
+                SocExplorerEngine::message(this->plugin,"Enter Write function",2);
                 QProgressBar* progress=NULL;
                 if(count>RMAP_MAX_XFER_SIZE)
                     progress= SocExplorerEngine::getProgressBar("Writing on SPW @0x"+QString::number(address,16)+" %v of "+QString::number(count)+" words ",count);
                 //Quite stupide loop, I guess that I always get the number of byte I asked for!
                 while(count>=RMAP_MAX_XFER_SIZE)
                 {
                     for(int i=0;i<(RMAP_MAX_XFER_SIZE);i++)
                     {
                         writeBuffer[RMAP_WRITE_HEADER_MIN_SZ+(i*4)+1] = (char)(((unsigned int)Value[i+written]>>24)&0xFF);
                         writeBuffer[RMAP_WRITE_HEADER_MIN_SZ+(i*4)+2] = (char)(((unsigned int)Value[i+written]>>16)&0xFF);
                         writeBuffer[RMAP_WRITE_HEADER_MIN_SZ+(i*4)+3] = (char)(((unsigned int)Value[i+written]>>8)&0xFF);
                         writeBuffer[RMAP_WRITE_HEADER_MIN_SZ+(i*4)+4] = (char)(((unsigned int)Value[i+written])&0xFF);
                     }
-                    RMAP_build_tx_request_header(254,2,1,transactionID,address+(written*4),RMAP_MAX_XFER_SIZE*4,writeBuffer+1);
+                    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(254,2,1,transactionID,address+(written*4),count*4,writeBuffer+1);
+                    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)
                 {
                     SocExplorerEngine::deleteProgressBar(progress);
                 }
                 return written;
             }
             unsigned int stardundeeSPW_USB::Read(unsigned int *Value, unsigned int count, unsigned int address)
             {
                 char requestBuffer[RMAP_READ_HEADER_MIN_SZ+1];
                 char* RMAP_AnswerBuffer;
-                requestBuffer[0]=1;//Link number
+                requestBuffer[0]=this->manager->linkNumber;//Link number
                 int transactionID = 0;
                 int read=0;
                 QProgressBar* progress=NULL;
                 if(count>RMAP_MAX_XFER_SIZE)
                     progress= SocExplorerEngine::getProgressBar("Reading on SPW @0x"+QString::number(address,16)+" %v of "+QString::number(count)+" words ",count);
-                SocExplorerEngine::message(this->plugin,QString("Enter read function, count=%1, RMAP_MAX_XFER_SIZE=%2").arg(count).arg(RMAP_MAX_XFER_SIZE));
+                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));
+                    SocExplorerEngine::message(this->plugin,QString("New transactionID:%1").arg(transactionID),2);
-                    RMAP_build_rx_request_header(254,2,1,transactionID,address+(read*4),RMAP_MAX_XFER_SIZE*4,requestBuffer+1);
+                    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));
+                    SocExplorerEngine::message(this->plugin,QString("New transactionID: %1").arg(transactionID),2);
-                    SocExplorerEngine::message(this->plugin,QString("Building request with:"));
+                    SocExplorerEngine::message(this->plugin,QString("Building request with:"),2);
-                    SocExplorerEngine::message(this->plugin,QString("Address = %1").arg(address+(read*4),8,16));
+                    SocExplorerEngine::message(this->plugin,QString("Address = %1").arg(address+(read*4),8,16),2);
-                    SocExplorerEngine::message(this->plugin,QString("Size = %1").arg(count*4));
+                    SocExplorerEngine::message(this->plugin,QString("Size = %1").arg(count*4),2);
-                    SocExplorerEngine::message(this->plugin,QString("Size + 13 = %1").arg((count*4)+13));
+                    SocExplorerEngine::message(this->plugin,QString("Size + 13 = %1").arg((count*4)+13),2);
-                    RMAP_build_rx_request_header(254,2,1,transactionID,address+(read*4),count*4,requestBuffer+1);
+                    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)
                 {
                     SocExplorerEngine::deleteProgressBar(progress);
                 }
                 return read;
             }
-            void stardundeeSPW_USB::updateAvailableBrickCount(int count)
+            void stardundeeSPW_USB::brickSelectionChanged(int brickIndex)
+            {
+                this->manager->selectedBrick = brickIndex-1;
+                SocExplorerEngine::message(plugin,QString("Changing brick index: %1").arg(manager->selectedBrick));
+            }
+            void stardundeeSPW_USB::linkNumberSelectionChanged(int linkIndex)
+            {
+                this->manager->linkNumber = linkIndex + 1;
+                SocExplorerEngine::message(plugin,QString("Changing Link Number: %1").arg(manager->linkNumber));
+            }
+            void stardundeeSPW_USB::linkSpeedSelectionChanged(const QString &linkSpeed)
             {
+                this->manager->linkSpeed = linkSpeed.toInt();
+                SocExplorerEngine::message(plugin,QString("Changing Link Speed: %1").arg(manager->linkSpeed));
+            }
+            void stardundeeSPW_USB::destinationKeyChanged(const QString &destKey)
+            {
+                this->manager->destinationKey = destKey.toInt();
+                SocExplorerEngine::message(plugin,QString("Changing Destination Key: %1").arg(manager->destinationKey));
+            }
+            void stardundeeSPW_USB::rmapAddressChanged(const QString &rmapaddress)
+            {
+                this->manager->rmapAddress = rmapaddress.toInt();
+                SocExplorerEngine::message(plugin,QString("Changing RMAP address: %1").arg(manager->rmapAddress));
+            }
+            void stardundeeSPW_USB::rmapKeyChanged(const QString &key)
+            {
+                this->manager->rmapKey = key.toInt();
+                SocExplorerEngine::message(plugin,QString("Changing RMAP Key: %1").arg(manager->rmapKey));
             }
             void stardundeeSPW_USB::makeGUI(socexplorerplugin *parent)
             {
-                this->p_GUI = new StarDundeeGUI(plugin);
+                this->p_GUI = new StarDundeeGUI();
-                this->mainLayout = new QGridLayout(this->p_GUI);
+            //    this->mainLayout = new QGridLayout(this->p_GUI);
-            //    connect(this->connectBridgeButton,SIGNAL(clicked()),this,SLOT(toggleBridgeConnection()));
+                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)));
+                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());
             }
             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;
             }
             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");
+                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");
                         if(USBSpaceWire_WaitOnReadPacketAvailable(hDevice,0.01))
                         {
-                            SocExplorerEngine::message(this->plugin,"Got packet");
+                            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");
+                                    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");
                                         if(buffer[1]==(char)SPW_PROTO_ID_RMAP) //RMAP packet
                                         {
-                                            SocExplorerEngine::message(this->plugin,"Got RMAP packet");
+                                            SocExplorerEngine::message(this->plugin,"Got RMAP packet",2);
-                                            SocExplorerEngine::message(this->plugin,QString("Rmap packet size %1").arg(properties.len));
+                                            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");
+                                            SocExplorerEngine::message(this->plugin,"Got SPW packet",2);
                                         }
                                     }
                                     else
                                     {
-                                        SocExplorerEngine::message(this->plugin,"No EOP received");
+                                        SocExplorerEngine::message(this->plugin,"No EOP received",2);
                                     }
                                 }
                             }
                             else
                             {
                                 USBSpaceWire_FreeRead(hDevice, pIdentifier);
                                 handleMutex->unlock();
                             }
                         }
                         else
                         {
                             USBSpaceWire_FreeRead(hDevice, pIdentifier);
                             handleMutex->unlock();
                         }
                     }
                     else
                     {
                         sleep(1);
-                        this->brickList = USBSpaceWire_ListDevices();
+                        int list = USBSpaceWire_ListDevices();
+                        if(this->brickList!=list)
+                        {
+                            this->brickList = list;
+                            emit updateAvailableBrickCount(this->brickList);
+                        }
                     }
                     usleep(1000);
                 }
-                SocExplorerEngine::message(this->plugin,"Exiting Startdundee USB pooling thread");
+                SocExplorerEngine::message(this->plugin,"Exiting Startdundee USB pooling thread",1);
             }
             bool stardundeeSPW_USB_Manager::connectBridge()
             {
-                this->handleMutex->lock();
+                QMutexLocker mlock(this->handleMutex);
                 int status;
                 U32 statusControl;
-                int brickNumber=0;
-                int linkNumber=1;
                 this->connected = false;
-                if (!USBSpaceWire_Open(&hDevice, brickNumber)) // Open the USB device
+                if (!USBSpaceWire_Open(&hDevice, this->selectedBrick)) // Open the USB device
                 {
-                    SocExplorerEngine::message(this->plugin,"stardundee *** Open *** ERROR: USBSpaceWire_Open(&hDevice, 0))");
+                    SocExplorerEngine::message(this->plugin,"stardundee *** Open *** ERROR: USBSpaceWire_Open(&hDevice, 0))",0);
-                    this->handleMutex->unlock();
                     return false;
                 }
-                SocExplorerEngine::message(this->plugin,"stardundee *** Open *** USBSpaceWire_Open successful");
+                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");
+                    SocExplorerEngine::message(this->plugin,"ERROR CFGSpaceWire_SetBrickBaseTransmitRate",1);
                     return false;
                 }
                 else
                 {
-                    SocExplorerEngine::message(this->plugin,"OK CFGSpaceWire_SetBrickBaseTransmitRate, base rate = 100 MHz");
+                    SocExplorerEngine::message(this->plugin,"OK CFGSpaceWire_SetBrickBaseTransmitRate, base rate = 100 MHz",1);
                 }
                 // read the link status
-                if (CFGSpaceWire_GetLinkStatusControl(hDevice, linkNumber, &statusControl) != CFG_TRANSFER_SUCCESS)
+                if (CFGSpaceWire_GetLinkStatusControl(hDevice, this->linkNumber, &statusControl) != CFG_TRANSFER_SUCCESS)
                 {
-                    SocExplorerEngine::message(this->plugin,"Could not read link status control for link " + QString::number(linkNumber));
+                    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(linkNumber));
+                    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, linkNumber, statusControl) != CFG_TRANSFER_SUCCESS)
+                    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(linkNumber));
+                        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(linkNumber));
+                        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");
+                    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");
+                    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");
+                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");
+                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)));
+                SocExplorerEngine::message(this->plugin,"USBSpaceWire_IsReadThrottling is " + QString::number(USBSpaceWire_IsReadThrottling(hDevice)),1);
                 this->connected = true;
-                this->handleMutex->unlock();
                 return true;
             }
             bool stardundeeSPW_USB_Manager::disconnectBridge()
             {
                 this->handleMutex->lock();
                 USBSpaceWire_Close(hDevice); // Close the device
-                SocExplorerEngine::message(this->plugin,"stardundee *** Close *** USBSpaceWire_Close, device: " + QString::number(0));
+                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<65536)
+                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
-                    if(!buffer)
+                    SocExplorerEngine::message(this->plugin,"waiting until a new packet is pushed",2);
+                    if(*buffer==NULL)
                     {
-                        SocExplorerEngine::message(this->plugin,"waiting until a new packet is pushed");
+                        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");
+                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 ");
+                    SocExplorerEngine::message(this->plugin,"ERR sending the READ command ",2);
                     this->handleMutex->unlock();
                     return false;
                 }
                 else
                 {
-                    SocExplorerEngine::message(this->plugin,"Packet sent");
+                    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 +19 -5

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2014, Laboratory of Plasmas Physic - CNRS
+            --  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:
             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 updateAvailableBrickCount(int count);
+                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);
             private:
                 void makeGUI(socexplorerplugin *parent);
                 stardundeeSPW_USB_Manager* manager;
-                QGridLayout* mainLayout;
+            //    QGridLayout* mainLayout;
-                QPushButton* connectBridgeButton;
-                QComboBox* selectBrickQcmbx;
             };
             #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