HG_REPOSITORIES/LPP/INSTRUMENTATION/SocExplorerPlugins Commit - r52:c8f8e77e323c

Removed deprecated genericPySysdriver interface.

jeandet -

r52:c8f8e77e323c default

parent child

Context file:

r52:c8f8e77e323c

APBUARTPLUGIN/APBUARTPLUGIN.cpp +7 -7

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2013, Plasma Physics Laboratory - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 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>
             #include <apbuartpywrapper.h>
             ApbUartPlugin::ApbUartPlugin(QWidget *parent):socexplorerplugin(parent,false)
             {
                 this->setBaseAddress(-1);
                 this->p_curentAPBUart = 0;
                 this->UI = new APBUART_Plugin_ui();
                 this->setWidget((QWidget*)this->UI);
                 this->uartConnected = false;
                 this->UartThread = new UARTPollingThread(this);
-                this->pyObject = new APBUartPyWrapper(this);
+            //    this->pyObject = new APBUartPyWrapper(this);
                 connect(this->UI,SIGNAL(loopbackChkBxStateChanged(int)),this,SLOT(fifoDebugChangeState(int)));
                 connect(this->UartThread,SIGNAL(apbUartTextReceived(QString)),this->UI,SIGNAL(apbUartTextReceived(QString)));
                 connect(this->UI,SIGNAL(connectPort()),this,SLOT(toggleUartState()));
                 connect(this->UI,SIGNAL(sendChar(char)),this->UartThread,SLOT(sendChar(char)));
                 connect(this->UI,SIGNAL(PortNameChanged(QString)),this->UartThread,SLOT(setPortName(QString)));
                 connect(this->UI,SIGNAL(UartSpeedChanged(QString)),this->UartThread,SLOT(setPortSpeedStr(QString)));
                 connect(this->UI,SIGNAL(updateAPBUartsList()),this,SLOT(updateAPBUartsList()));
                 connect(this->UI,SIGNAL(curentAPBUartChanged(int)),this,SLOT(setCurentAPBUart(int)));
-                connect(((APBUartPyWrapper*)this->pyObject),SIGNAL(openUart()),this,SLOT(openUart()));
+            //    connect(((APBUartPyWrapper*)this->pyObject),SIGNAL(openUart()),this,SLOT(openUart()));
-                connect(((APBUartPyWrapper*)this->pyObject),SIGNAL(closeUart()),this,SLOT(closeUart()));
+            //    connect(((APBUartPyWrapper*)this->pyObject),SIGNAL(closeUart()),this,SLOT(closeUart()));
-                connect(((APBUartPyWrapper*)this->pyObject),SIGNAL(setFifoDebugEnabled(bool)),this,SLOT(setFifoDebugEnabled(bool)));
+            //    connect(((APBUartPyWrapper*)this->pyObject),SIGNAL(setFifoDebugEnabled(bool)),this,SLOT(setFifoDebugEnabled(bool)));
-                connect(((APBUartPyWrapper*)this->pyObject),SIGNAL(setUARTPortNane(QString)),this,SLOT(setUARTPortNane(QString)));
+            //    connect(((APBUartPyWrapper*)this->pyObject),SIGNAL(setUARTPortNane(QString)),this,SLOT(setUARTPortNane(QString)));
-                connect(((APBUartPyWrapper*)this->pyObject),SIGNAL(setUARTPortSpeed(int)),this,SLOT(setUARTPortSpeed(int)));
+            //    connect(((APBUartPyWrapper*)this->pyObject),SIGNAL(setUARTPortSpeed(int)),this,SLOT(setUARTPortSpeed(int)));
-                connect(((APBUartPyWrapper*)this->pyObject),SIGNAL(updateAPBUartsList()),this,SLOT(updateAPBUartsList()));
+            //    connect(((APBUartPyWrapper*)this->pyObject),SIGNAL(updateAPBUartsList()),this,SLOT(updateAPBUartsList()));
                 this->UartThread->start();
             }
             ApbUartPlugin::~ApbUartPlugin()
             {
             }
             int ApbUartPlugin::curentAPBUart()
             {
                 return p_curentAPBUart;
             }
             void ApbUartPlugin::closeMe()
             {
                 emit this->closePlugin(this);
             }
             void ApbUartPlugin::toggleUartState()
             {
                 if(!uartConnected)
                 {
                     this->openUart();
                 }
                 else
                 {
                     this->closeUart();
                 }
             }
             void ApbUartPlugin::activate(bool flag)
             {
                 socexplorerplugin::activate(flag);
                 this->updateAPBUartsList();
             }
             void ApbUartPlugin::updateAPBUartsList()
             {
                 QList<unsigned int> addresses;
                 int count = SocExplorerEngine::self()->getEnumDeviceCount(this,this->VID(),this->PID());
                 for(int i=0;i<count;i++)
                 {
                     addresses.append(SocExplorerEngine::self()->getEnumDeviceBaseAddress(this,this->VID(),this->PID(),i));
                 }
                 this->UI->updateAPBUartList(addresses);
             }
             void ApbUartPlugin::setCurentAPBUart(int index)
             {
                 this->p_curentAPBUart = index;
                 this->setBaseAddress(SocExplorerEngine::self()->getEnumDeviceBaseAddress(this,this->VID(),this->PID(),index));
             }
             void ApbUartPlugin::openUart()
             {
                 if(this->UartThread->fifoDebugEnabled())
                     setFifoDebugEnabled(false);
                 if(!uartConnected)
                     uartConnected = this->UartThread->openUart();
                 this->UI->setUartConnected(uartConnected);
             }
             void ApbUartPlugin::closeUart()
             {
                 if(uartConnected)
                     this->UartThread->closeUart();
                 this->uartConnected = false;
                 this->UI->setUartConnected(uartConnected);
             }
             void ApbUartPlugin::setFifoDebugEnabled(bool enable)
             {
                 if(uartConnected)
                     closeUart();
                 this->UI->setEnableForLoopBack(!enable);
                 this->UartThread->setFifoDebugEable(enable);
             }
             void ApbUartPlugin::setAPBUartIndex(int index)
             {
                 this->UI->setAPBUartIndex(index);
             }
             void ApbUartPlugin::setUARTPortNane(QString name)
             {
                 this->UI->setUartPortName(name);
             }
             void ApbUartPlugin::setUARTPortSpeed(int speed)
             {
                 this->UI->setUartSpeed(speed);
             }
             void ApbUartPlugin::fifoDebugChangeState(int state)
             {
                 if(state==Qt::Checked)
                 {
                     this->setFifoDebugEnabled(true);
                 }
                 else
                 {
                     this->setFifoDebugEnabled(false);
                 }
             }
             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;
             }

ahbuartplugin/ahbuartplugin.cpp +47 -5

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2011, Plasma Physics Laboratory - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #include <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);
+            //    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(open(QString,int)),this,SLOT(open(QString,int)));
-                QObject::connect(((ahbuartPywrapper*)this->pyObject),SIGNAL(close()),this,SLOT(close()));
+            //    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(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(((ahbuartPywrapper*)this->pyObject),SIGNAL(WriteBytes(uint,QList<QVariant>)),this,SLOT(WriteBytes(uint,QList<QVariant>)));
                 QObject::connect(this->UI,SIGNAL(rescanPorts()),this,SLOT(updatePortList()));
                 QObject::connect(this,SIGNAL(addReadBytes(int)),this->UI,SLOT(addReadBytes(int)));
                 QObject::connect(this,SIGNAL(addWritenBytes(int)),this->UI,SLOT(addWritenBytes(int)));
                 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);
                 QMutexLocker lock(portMutex);
                 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();
                 int avail = 0;
                 do
                 {
                     avail = rs232availablebytes(this->port);
                     if(timeout.elapsed()>1000)
                     {
                         if(avail)
                             rs232read(this->port,test2,avail);
                         SocExplorerEngine::message(this,"Connection Error",2);
                         return false;
                     }
                 }while(avail<4);
                 read = rs232read(this->port,test2,avail);
                 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();
                 QMutexLocker lock(portMutex);
                 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);
                     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;
                             }
+                            this->UI->setSystemSpeed(this->detectSpeed());
                             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=1024;
                 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))
                 {
                     QMutexLocker lock(portMutex);
                     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);
                         SAFEWRITE(CMD,5,timeout,1000,return 0);
                         timeout.restart();
                         int avail=0;
                         do{
                             avail=rs232availablebytes(this->port);
                             if(timeout.elapsed()>1000)
                             {
                                 rs232close(this->port);
                                 this->port = (rs232port_t)NULL;
                                 this->Connected = false;
                                 emit this->activateSig(false);
                                 return 0;
                             }
                         }while(avail<(32*4));
                         rs232read(this->port,result+((cnt-count)*4),32*4);
                         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);
                         timeout.restart();
                         int avail=0;
                         do{
                             avail=rs232availablebytes(this->port);
                             if(timeout.elapsed()>1000)
                             {
                                 rs232close(this->port);
                                 this->port = (rs232port_t)NULL;
                                 this->Connected = false;
                                 emit this->activateSig(false);
                                 return 0;
                             }
                         }while(avail<(count*4));
                         rs232read(this->port,result+((cnt-count)*4),count*4);
                     }
                     if(cnt>128)
                     {
                         progress->setValue(cnt-count);
                         qApp->processEvents();
                     }
                     for(int i=0;(unsigned int)i<cnt;i++)
                     {
             #if __BYTE_ORDER == __LITTLE_ENDIAN
             //            for(int j =0;j<4;j++)
             //            {
             //                Value[i]= ((unsigned char)(result[i*4+j])) + Value[i]*256;
             //            }
                         Value[i]= socexplorerBswap32(((uint32_t*)result)[i]);
             #elif __BYTE_ORDER == __BIG_ENDIAN
                         Value[i]= ((uint32_t*)result)[i];
             #endif
                     }
                     read = cnt*4;
                     if(cnt>128)
                         SocExplorerEngine::deleteProgressBar(progress);
                     free(result);
                 }
                 emit this->addReadBytes(read);
                 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=1024;
                 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))
                 {
                     QMutexLocker lock(portMutex);
                     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);
                     writen=0;
                     while(count>32)
                     {
                         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++)
                         {
             #if __BYTE_ORDER == __LITTLE_ENDIAN
                             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);
             #elif __BYTE_ORDER == __BIG_ENDIAN
                             CMD[(i*4)+5] = (char)(((unsigned int)Value[i+offset])&0xFF);
                             CMD[(i*4)+6] = (char)(((unsigned int)Value[i+offset]>>8)&0xFF);
                             CMD[(i*4)+7] = (char)(((unsigned int)Value[i+offset]>>16)&0xFF);
                             CMD[(i*4)+8] = (char)(((unsigned int)Value[i+offset]>>24)&0xFF);
             #endif
                         }
                         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++)
                         {
             #if __BYTE_ORDER == __LITTLE_ENDIAN
                             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);
             #elif __BYTE_ORDER == __BIG_ENDIAN
                             CMD[(i*4)+5] = (char)(((unsigned int)Value[i+offset])&0xFF);
                             CMD[(i*4)+6] = (char)(((unsigned int)Value[i+offset]>>8)&0xFF);
                             CMD[(i*4)+7] = (char)(((unsigned int)Value[i+offset]>>16)&0xFF);
                             CMD[(i*4)+8] = (char)(((unsigned int)Value[i+offset]>>24)&0xFF);
             #endif
                         }
                         SAFEWRITE(CMD,((count*4)+5),timeout,1000,return 0);
                         writen+=count;
                     }
                     if(progress!=NULL)
                     {
                         progress->setValue(writen);
                         qApp->processEvents();
                         SocExplorerEngine::deleteProgressBar(progress);
                     }
                     free(CMD);
                     emit this->addWritenBytes(writen*4);
                     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);
             }
+            int ahbuartplugin::detectSpeed()
+            {
+                //scaler = (((system_clk*10)/(baudrate*8))-5)/10
+                unsigned int ahbUartBaseAddress = SocExplorerEngine::self()->getEnumDeviceBaseAddress(this,0x01,0x007,0);
+            //    unsigned int dsuBaseAddress = SocExplorerEngine::self()->getEnumDeviceBaseAddress(this,0x01,0x0017,0);
+                unsigned int dsuBaseAddress = 0x90000000;
+                unsigned int scaler = 0,dsuVal1=0,dsuVal2=0;
+                int speed=0;
+                QElapsedTimer time;
+                if(dsuBaseAddress!=-1)
+                {
+                    time.start();
+                    if( this->Read(&dsuVal1,1,dsuBaseAddress+0x08)==1)
+                    {
+                        usleep(1000*1000);
+                        qint64 el = time.elapsed();
+                        this->Read(&dsuVal2,1,dsuBaseAddress+0x08);
+                        if(dsuVal1!=dsuVal2)
+                            return ((dsuVal2-dsuVal1)/el)*1000;
+                    }
+                }
+                if(ahbUartBaseAddress!=-1)
+                {
+                    if( this->Read(&scaler,1,ahbUartBaseAddress+0x0C)==1)
+                    {
+                        scaler&=0x3FFFF;
+                        speed = (int)(((double)scaler*10.0)+5.0)*((double)this->UI->baudRate()/10.0)*8.0;
+            //            speed = (int)((double)(scaler+1)*8.0*(double)this->UI->baudRate());
+                    }
+                }
+                return speed;
+            }
+            void ahbuartplugin::postInstantiationTrigger()
+            {
+                if(this->scanDone && this->Connected)
+                {
+                    this->UI->setSystemSpeed(this->detectSpeed());
+                }
+            }

ahbuartplugin/ahbuartplugin.h +2 0

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2011, Plasma Physics Laboratory - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #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"
             #include <RS232.h>
             #include <unistd.h>
             #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)) \
             {\
                 this->port = (rs232port_t)NULL; \
                 this->Connected = false; \
                 emit this->activateSig(false); \
                 error; \
                 } \
                 } \
                 break;\
                 }
             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);
+                int detectSpeed();
+                void postInstantiationTrigger();
             signals:
                 void setProgressValue(int progress);
                 void addWritenBytes(int count);
                 void addReadBytes(int count);
             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/ahbuartplugin.pro +62 -65

@@ -1,65 +1,62
1	#	1	#
2	# Project created by QtCreator 2011-09-20T08:15:30	2	# Project created by QtCreator 2011-09-20T08:15:30
3	#	3	#
4	#-------------------------------------------------	4	#-------------------------------------------------
5		5
6	CONFIG += socexplorerplugin	6	CONFIG += socexplorerplugin
7	TEMPLATE = lib	7	TEMPLATE = lib
8	CONFIG += dll	8	CONFIG += dll
9	CONFIG -= static	9	CONFIG -= static
10	VERSION=1.4.0	10	VERSION=1.4.0
11	TARGET = ahbuartplugin #$${DEBUG_EXT}	11	TARGET = ahbuartplugin #$${DEBUG_EXT}
12	DEFINES += PLUGIN=ahbuartplugin	12	DEFINES += PLUGIN=ahbuartplugin
13	DEFINES += PLUGINHEADER="\"\\\"ahbuartplugin.h"\\\"\"	13	DEFINES += PLUGINHEADER="\"\\\"ahbuartplugin.h"\\\"\"
14	DEFINES += driver_Name="\"\\\"AHBUARTplugin"\\\"\"	14	DEFINES += driver_Name="\"\\\"AHBUARTplugin"\\\"\"
15	DEFINES += driver_Author="\"\\\"Alexis Jeandet alexis.jeandet@lpp.polytechnique.fr"\\\"\"	15	DEFINES += driver_Author="\"\\\"Alexis Jeandet alexis.jeandet@lpp.polytechnique.fr"\\\"\"
16	DEFINES += driver_Description="\"\\\"Gaisler's AHBUART driver, gives master access to AHB bus."\\\"\"	16	DEFINES += driver_Description="\"\\\"Gaisler's AHBUART driver, gives master access to AHB bus."\\\"\"
17	DEFINES += driver_can_be_root=1	17	DEFINES += driver_can_be_root=1
18	DEFINES += driver_can_be_child=0	18	DEFINES += driver_can_be_child=0
19	DEFINES += driver_VID=0	19	DEFINES += driver_VID=0
20	DEFINES += driver_PID=0	20	DEFINES += driver_PID=0
21		21
22		22
23		23
24		24
25	INCLUDEPATH += \	25	INCLUDEPATH += \
26	$${PWD}	26	$${PWD}
27		27
28		28
29	HEADERS += \	29	HEADERS += \
30	ahbuartplugin.h \	30	ahbuartplugin.h \
31	ahbuartpluginui.h \	31	ahbuartpluginui.h
32	ahbuartpywrapper.h \	32
33	ahbuartpywrapper.h	33
34		34
35		35	SOURCES += \
36		36	ahbuartplugin.cpp \
37	SOURCES += \	37	ahbuartpluginui.cpp
38	ahbuartplugin.cpp \	38
39	ahbuartpluginui.cpp \	39	FORMS += \
40	ahbuartpywrapper.cpp	40	ahbuartpluginui.ui
41		41
42	FORMS += \	42
43	ahbuartpluginui.ui	43
44		44
45		45
46		46
47		47
48		48
49		49
50		50
51		51
52		52
53		53
54		54
55		55
56		56
57		57
58		58
59		59
60		60
61		61
62		62
63
64
65

ahbuartplugin/ahbuartpluginui.cpp +18 0

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2011, Plasma Physics Laboratory - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #include "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->rescanPorts,SIGNAL(clicked()),this,SIGNAL(rescanPorts()));
                 QStringList allowedSpeeds;
                 allowedSpeeds<<"0"<<"50"<<"75"<<"110"<<"134"<<"150"<<
                             "200"<<"300"<<"600"<<"1200"<<"1800"<<"2400"<<
                             "4800"<<"9600"<<"19200"<<"38400"<<"57600"<<
                             "115200"<<"230400"<<"460800"<<"500000"<<"576000"<<
                             "921600"<<"1000000"<<"1152000"<<"1500000"<<"2000000"<<
                             "2500000"<<"3000000"<<"3500000"<<"4000000";
                 portSpeedCompleter = new QCompleter(allowedSpeeds);
                 this->ui->portSpeed->setCompleter(portSpeedCompleter);
                 this->writtenBytes = 0;
                 this->readBytes = 0;
             }
             void ahbUartPluginUI::connectPort()
             {
                 int baudrate = ui->portSpeed->text().toInt();
                 emit this->connectPortsig(ui->PortName->text(),baudrate);
             }
             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::setconfig(QString PortName, int baudrate)
             {
                 this->ui->PortName->setText(PortName);
                 this->ui->portSpeed->setText(QString::number(baudrate));
             }
             void ahbUartPluginUI::addWritenBytes(int count)
             {
                 this->writtenBytes+=count;
                 this->ui->WrBytesLCD->display(this->writtenBytes);
             }
             void ahbUartPluginUI::addReadBytes(int count)
             {
                 this->readBytes+=count;
                 this->ui->RdBytesLCD->display(this->readBytes);
             }
+            void ahbUartPluginUI::setSystemSpeed(int speed)
+            {
+                QStringList frLst = QStringList()<<"Hz"<<"kHz"<<"MHz"<<"GHz";
+                int ind=0;
+                double speedD = speed;
+                while(speedD>1000.0)
+                {
+                    speedD/=1000.0;
+                    ind++;
+                }
+                this->ui->detectedSpeedLbl->setText(QString::number(speedD)+frLst[ind]);
+            }
             void ahbUartPluginUI::setCompleter(QCompleter *completer)
             {
                 this->ui->PortName->setCompleter(completer);
             }
+            int ahbUartPluginUI::baudRate()
+            {
+                return ui->portSpeed->text().toInt();
+            }
             void ahbUartPluginUI::closeEvent(QCloseEvent *event)
             {
                 event->accept();
             }

ahbuartplugin/ahbuartpluginui.h +2 0

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2011, Plasma Physics Laboratory - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #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();
                 void closeEvent(QCloseEvent *event);
                 void setCompleter(QCompleter* completer);
+                int baudRate();
             public slots:
                 void setConnected(bool connected);
                 void connectPort();
                 void setconfig(QString PortName,int baudrate);
                 void addWritenBytes(int count);
                 void addReadBytes(int count);
+                void setSystemSpeed(int speed);
             signals:
                 void connectPortsig(QString PortName,int baudrate);
                 void setLogFileName(QString FileName);
                 void rescanPorts();
             private:
                 int writtenBytes;
                 int readBytes;
                 Ui::ahbUartPluginUI *ui;
                 QCompleter* portSpeedCompleter;
             };
             #endif // AHBUARTPLUGINUI_H

ahbuartplugin/ahbuartpluginui.ui +20 -3

             <?xml version="1.0" encoding="UTF-8"?>
             <ui version="4.0">
              <class>ahbUartPluginUI</class>
              <widget class="QWidget" name="ahbUartPluginUI">
               <property name="geometry">
                <rect>
                 <x>0</x>
                 <y>0</y>
-                <width>884</width>
+                <width>902</width>
-                <height>221</height>
+                <height>256</height>
                </rect>
               </property>
               <property name="windowTitle">
                <string>Form</string>
               </property>
               <layout class="QGridLayout" name="gridLayout_2">
-               <item row="4" column="0" colspan="3">
+               <item row="5" column="0" colspan="3">
                 <widget class="QGroupBox" name="Statistiques">
                  <property name="title">
                   <string>Statistics</string>
                  </property>
                  <layout class="QGridLayout" name="gridLayout">
                   <item row="0" column="2">
                    <widget class="QLCDNumber" name="WrBytesLCD">
                     <property name="digitCount">
                      <number>8</number>
                     </property>
                     <property name="segmentStyle">
                      <enum>QLCDNumber::Flat</enum>
                     </property>
                    </widget>
                   </item>
                   <item row="1" column="2">
                    <widget class="QLCDNumber" name="RdBytesLCD">
                     <property name="digitCount">
                      <number>8</number>
                     </property>
                     <property name="segmentStyle">
                      <enum>QLCDNumber::Flat</enum>
                     </property>
                    </widget>
                   </item>
                   <item row="1" column="0">
                    <widget class="QLabel" name="RdBytesLbl">
                     <property name="text">
                      <string>Read Bytes</string>
                     </property>
                    </widget>
                   </item>
                   <item row="0" column="0">
                    <widget class="QLabel" name="WrBytesLbl">
                     <property name="text">
                      <string>Writen Bytes</string>
                     </property>
                    </widget>
                   </item>
                  </layout>
                 </widget>
                </item>
                <item row="1" column="0">
                 <widget class="QLabel" name="label_2">
                  <property name="text">
                   <string>Port Speed</string>
                  </property>
                 </widget>
                </item>
                <item row="0" column="0">
                 <widget class="QLabel" name="label">
                  <property name="text">
                   <string>Port Name</string>
                  </property>
                 </widget>
                </item>
                <item row="0" column="2">
                 <widget class="QPushButton" name="rescanPorts">
                  <property name="text">
                   <string>SCAN</string>
                  </property>
                 </widget>
                </item>
                <item row="0" column="1">
                 <widget class="QLineEdit" name="PortName"/>
                </item>
                <item row="3" column="0">
                 <spacer name="verticalSpacer">
                  <property name="orientation">
                   <enum>Qt::Vertical</enum>
                  </property>
                  <property name="sizeHint" stdset="0">
                   <size>
                    <width>20</width>
                    <height>40</height>
                   </size>
                  </property>
                 </spacer>
                </item>
                <item row="3" column="1" colspan="2">
                 <widget class="QPushButton" name="OpenPort">
                  <property name="text">
                   <string>Open Port</string>
                  </property>
                 </widget>
                </item>
                <item row="1" column="1" colspan="2">
                 <widget class="QLineEdit" name="portSpeed">
                  <property name="inputMask">
                   <string>00000000</string>
                  </property>
                  <property name="text">
                   <string>115200</string>
                  </property>
                 </widget>
                </item>
+               <item row="4" column="0">
+                <widget class="QLabel" name="label_3">
+                 <property name="text">
+                  <string>Detected Speed</string>
+                 </property>
+                </widget>
+               </item>
+               <item row="4" column="1" colspan="2">
+                <widget class="QLabel" name="detectedSpeedLbl">
+                 <property name="text">
+                  <string/>
+                 </property>
+                 <property name="alignment">
+                  <set>Qt::AlignCenter</set>
+                 </property>
+                </widget>
+               </item>
               </layout>
              </widget>
              <resources/>
              <connections/>
             </ui>

dsu3plugin/dsu3plugin.cpp +8 -8

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2011, Plasma Physics Laboratory - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #include "dsu3plugin.h"
             #include <QFileDialog>
             #include <QDir>
             #include "dsu3pluginpywrapper.h"
             #include <socexplorerengine.h>
             struct acceptedMemctrlr_str
             {
                 int vid;
                 int pid;
                 const char* name;
             };
             const struct acceptedMemctrlr_str acceptedMemctrlr[]=
             {
             {0x04,0x0f,"MCTRL"},
             {0x01,0x51,"FTSRCTRL"},
             {0x20,0x01,"SRCTRLE_0WS" },
             {0x20,0x02,"SRCTRLE_1WS" }
             };
             #define acceptedMemctrlrCnt 4
             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);
+            //    this->pyObject = new dsu3pluginPywrapper(this);
-                QObject::connect(((dsu3pluginPywrapper*)this->pyObject),SIGNAL(openFile(QString)),this,SLOT(openFile(QString)));
+            //    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(loadFile()),this,SLOT(flashTarget()));
-                QObject::connect(((dsu3pluginPywrapper*)this->pyObject),SIGNAL(run()),this,SLOT(run()));
+            //    QObject::connect(((dsu3pluginPywrapper*)this->pyObject),SIGNAL(run()),this,SLOT(run()));
-                QObject::connect(((dsu3pluginPywrapper*)this->pyObject),SIGNAL(stop()),this,SLOT(stop()));
+            //    QObject::connect(((dsu3pluginPywrapper*)this->pyObject),SIGNAL(stop()),this,SLOT(stop()));
-                QObject::connect(((dsu3pluginPywrapper*)this->pyObject),SIGNAL(cacheEnable()),this,SLOT(cacheEnable()));
+            //    QObject::connect(((dsu3pluginPywrapper*)this->pyObject),SIGNAL(cacheEnable()),this,SLOT(cacheEnable()));
-                QObject::connect(((dsu3pluginPywrapper*)this->pyObject),SIGNAL(cacheDisable()),this,SLOT(cacheDisable()));
+            //    QObject::connect(((dsu3pluginPywrapper*)this->pyObject),SIGNAL(cacheDisable()),this,SLOT(cacheDisable()));
-                QObject::connect(((dsu3pluginPywrapper*)this->pyObject),SIGNAL(setCacheEnable(bool)),this,SLOT(setCacheEnable(bool)));
+            //    QObject::connect(((dsu3pluginPywrapper*)this->pyObject),SIGNAL(setCacheEnable(bool)),this,SLOT(setCacheEnable(bool)));
                 connect(this->UI,SIGNAL(openFile()),this,SLOT(openFile()));
                 connect(this->UI,SIGNAL(flashTarget()),this,SLOT(flashTarget()));
                 connect(this->UI,SIGNAL(run()),this,SLOT(toggleRun()));
                 connect(this,SIGNAL(updateInfo(elfparser*)),this->UI,SIGNAL(updateInfo(elfparser*)));
                 this->running = false;
             }
             dsu3plugin::~dsu3plugin()
             {
             }
             void dsu3plugin::openFile()
             {
                 QString filename = QFileDialog::getOpenFileName(this,tr("Open elf File"), QDir::homePath(), tr("Elf Files (*)"));
                 if(filename!="")
                 {
                     this->openFile(filename);
                 }
             }
             void dsu3plugin::openFile(QString fileName)
             {
                 this->elfparserInst->setFilename(fileName);
                 emit this->updateInfo(this->elfparserInst);
             }
             bool dsu3plugin::configureTarget()
             {
                 int detectedMctrlr=-1;
                 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 =-1;
                 for(int i=0; i<acceptedMemctrlrCnt;i++)
                 {
                     MCTRLBASEADDRESS = SocExplorerEngine::self()->getEnumDeviceBaseAddress(this,acceptedMemctrlr[i].vid , acceptedMemctrlr[i].pid,0);
                     if(MCTRLBASEADDRESS != (unsigned int)-1)
                     {
                         SocExplorerEngine::message(this,QString("Found %1 @%2").arg(acceptedMemctrlr[i].name).arg(MCTRLBASEADDRESS,8,16),1);
                         detectedMctrlr=i;
                         break;
                     }
                 }
                 if(MCTRLBASEADDRESS == (unsigned int)-1)
                 {
                     SocExplorerEngine::message(this,"Can't any compatible memory controller",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);
             //    {0x04,0x0f,"MCTRL"},
             //    {0x01,0x51,"FTSRCTRL"},
             //    {0x20,0x01,"SRCTRLE_0WS" },
             //    {0x20,0x02,"SRCTRLE_1WS" }
                 if(QString(acceptedMemctrlr[detectedMctrlr].name)=="MCTRL" || QString(acceptedMemctrlr[detectedMctrlr].name)=="FTSRCTRL" )
                 {
                     WriteRegs(uIntlist()<<0x2FF<<0xE60<<0,(unsigned int)MCTRLBASEADDRESS);
                 }
                 if(QString(acceptedMemctrlr[detectedMctrlr].name)=="SRCTRLE_0WS" || QString(acceptedMemctrlr[detectedMctrlr].name)=="SRCTRLE_1WS" )
                 {
                     //let's perform a mem Wash
                     unsigned int val = ReadReg(MCTRLBASEADDRESS);
                     val |=1<<31;
                     WriteRegs(uIntlist()<<val,(unsigned int)MCTRLBASEADDRESS);
                     usleep(1000*1000);
                 }
                 WriteRegs(uIntlist()<<0<<0<<0<<0,(unsigned int)DSUBASEADDRESS+0x400060);
                 WriteRegs(uIntlist()<<0x0000FFFF,(unsigned int)DSUBASEADDRESS+0x24);
                 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::cacheDisable()
             {
                 return setCacheEnable(false);
             }
             bool dsu3plugin::cacheEnable()
             {
                 return setCacheEnable(true);
             }
             bool dsu3plugin::setCacheEnable(bool enabled)
             {
                 if(parent==NULL)
                     return false;
                 unsigned int DSUBASEADDRESS = SocExplorerEngine::self()->getEnumDeviceBaseAddress(this,0x01 , 0x004,0);
                 if(DSUBASEADDRESS == (unsigned int)-1)
                     DSUBASEADDRESS = 0x90000000;
                 WriteRegs(uIntlist()<<2,DSUBASEADDRESS+0x400024);
                 unsigned int reg = ReadReg(DSUBASEADDRESS+0x700000);
                 if(enabled)
                 {
                     WriteRegs(uIntlist()<<(0x0001000F|reg),DSUBASEADDRESS+0x700000);
                     //flushes cache.
                     WriteRegs(uIntlist()<<(0x0061000F|reg),DSUBASEADDRESS+0x700000);
                 }
                 else
                 {
                     WriteRegs(uIntlist()<<((!0x0001000F)&reg),DSUBASEADDRESS+0x700000);
                     WriteRegs(uIntlist()<<(0x00600000|reg),DSUBASEADDRESS+0x700000);
                 }
                 return true;
             }
             bool dsu3plugin::flashTarget()
             {
                 stop();
                 cacheDisable();
                 configureTarget();
                 /*Write .text*/
                 this->writeSection(".text");
                 /*Write .data*/
                 this->writeSection(".data");
                 return true;
             }
             void dsu3plugin::run()
             {
                 unsigned int DSUBASEADDRESS = SocExplorerEngine::self()->getEnumDeviceBaseAddress(this,0x01 , 0x004,0);
                 if(DSUBASEADDRESS == (unsigned int)-1)
                     DSUBASEADDRESS = 0x90000000;
                 WriteRegs(uIntlist()<<0,DSUBASEADDRESS+0x020);
                 this->running = true;
                 this->UI->setRunning(true);
             }
             void dsu3plugin::stop()
             {
                 unsigned int DSUBASEADDRESS = SocExplorerEngine::self()->getEnumDeviceBaseAddress(this,0x01 , 0x004,0);
                 if(DSUBASEADDRESS == (unsigned int)-1)
                     DSUBASEADDRESS = 0x90000000;
                 WriteRegs(uIntlist()<<0xFFFF,DSUBASEADDRESS+0x020);
                 this->running = false;
                 this->UI->setRunning(false);
             }
             void dsu3plugin::toggleRun()
             {
                 if(this->running)
                     this->stop();
                 else
                     this->run();
             }
             void dsu3plugin::WriteRegs(uIntlist Values, unsigned int address)
             {
                 unsigned int* buff;
                 buff = (unsigned int*)malloc(Values.count()*sizeof(unsigned int));
                 for(int i=0;i<Values.count();i++)
                 {
                     buff[i]=Values.at(i);
                 }
                 parent->Write(buff,(unsigned int)Values.count(),address);
                 free(buff);
             }
             unsigned int dsu3plugin::ReadReg(unsigned int address)
             {
                 unsigned int buff;
                 parent->Read(&buff,1,address);
                 return 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 +2 0

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2012, Plasma Physics Laboratory - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #ifndef DSU3PLUGIN_H
             #define DSU3PLUGIN_H
             #include "dsu3pluginui.h"
             #include <QMenuBar>
             #include <QMenu>
             #include <QAction>
             #include <QMainWindow>
             #include <QList>
             #include "elfparser.h"
             #include <socexplorerplugin.h>
             #include <socexplorerengine.h>
             typedef QList<unsigned int> uIntlist;
             class dsu3plugin : public socexplorerplugin
             {
                 Q_OBJECT
             public:
                 explicit dsu3plugin(QWidget *parent = 0);
                 ~dsu3plugin();
                 bool memSet(unsigned int address, int value, unsigned int count);
             public slots:
                 unsigned int Write(unsigned int *Value,unsigned int count,unsigned  int address=0);
                 unsigned int Read(unsigned int *Value,unsigned int count, unsigned int address=0);
                 void openFile();
                 void openFile(QString fileName);
                 bool configureTarget();
                 bool cacheDisable();
                 bool cacheEnable();
                 bool setCacheEnable(bool enabled);
                 bool flashTarget();
                 void run();
                 void stop();
                 void toggleRun();
+                //added for python backward compatibility
+                void loadFile(){this->flashTarget();}
             signals:
                 void updateInfo(elfparser* parser);
             private:
                 void WriteRegs(uIntlist Values, unsigned int address);
                 unsigned int ReadReg(unsigned int address);
                 void writeSection(int index);
                 void writeSection(const QString& name);
                 dsu3pluginui* UI;
                 elfparser* elfparserInst;
                 bool running;
             };
             #endif // DSU3PLUGIN_H

dsu3plugin/dsu3plugin.pro +2 -4

             #
             # Project created by QtCreator 2011-09-20T08:15:30
             #
             #-------------------------------------------------
             CONFIG += socexplorerplugin
             TEMPLATE = lib
             QMAKE_LFLAGS_RELEASE += --enable-auto-import -mstackrealign
             QMAKE_LFLAGS_DEBUG += --enable-auto-import -mstackrealign
             VERSION=0.2.0
             TARGET = dsu3plugin #$${DEBUG_EXT}
             DEFINES += PLUGIN=dsu3plugin
             DEFINES += PLUGINHEADER="\"\\\"dsu3plugin.h"\\\"\"
             DEFINES += driver_Name="\"\\\"dsu3plugin"\\\"\"
             DEFINES += driver_Author="\"\\\"Alexis Jeandet alexis.jeandet@lpp.polytechnique.fr"\\\"\"
             DEFINES += driver_Description="\"\\\"DSU driver, works with GAISLER's DSU3 unit."\\\"\"
             DEFINES += driver_can_be_root=0
             DEFINES += driver_can_be_child=1
             DEFINES += driver_VID=0x00
             DEFINES += driver_PID=0x00
             INCLUDEPATH += \
                     $${PWD}
             HEADERS += \
                 dsu3plugin.h \
-                dsu3pluginui.h \
+                dsu3pluginui.h
-                dsu3pluginpywrapper.h
             SOURCES += \
                 dsu3plugin.cpp \
-                dsu3pluginui.cpp \
+                dsu3pluginui.cpp
-                dsu3pluginpywrapper.cpp

genericrwplugin/genericrwplugin.cpp +6 -6

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2011, Plasma Physics Laboratory - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #include "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);
+            //    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(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(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(refresh()),this->UI,SIGNAL(refresh()));
-                QObject::connect(((genericRWpluginPyWrapper*)this->pyObject),SIGNAL(setAddress(quint32)),this->UI,SIGNAL(setAddress(quint32)));
+            //    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)));
+            //    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.pro +2 -4

             #
             # Project created by QtCreator 2011-09-20T08:15:30
             #
             #-------------------------------------------------
             CONFIG += socexplorerplugin
             CONFIG += dll
             CONFIG -= static
             VERSION=1.1.0
             TARGET = genericrwplugin
             DEFINES += PLUGIN=genericrwplugin
             DEFINES += PLUGINHEADER="\"\\\"genericrwplugin.h"\\\"\"
             DEFINES += driver_Name="\"\\\"GenericRWplugin"\\\"\"
             DEFINES += driver_Author="\"\\\"Alexis Jeandet alexis.jeandet@lpp.polytechnique.fr"\\\"\"
             DEFINES += driver_Description="\"\\\"Generic plugin, gives you R/W access to any memory area."\\\"\"
             DEFINES += driver_can_be_root=0
             DEFINES += driver_can_be_child=1
             DEFINES += driver_VID=0
             DEFINES += driver_PID=0
             INCLUDEPATH += \
                     $${PWD}
             #LIBS +=-llppmoncommon$${DEBUG_EXT}
             HEADERS += \
                 genericrwplugin.h \
                 genericrwpluginui.h \
-                memeditor.h \
+                memeditor.h
-                genericrwpluginpywrapper.h
             SOURCES += \
                 genericrwplugin.cpp \
                 genericrwpluginui.cpp \
-                memeditor.cpp \
+                memeditor.cpp
-                genericrwpluginpywrapper.cpp

memctrlrplugin/memctrlrplugin.cpp +2 -2

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2011, Plasma Physics Laboratory - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #include "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);
+            //    this->pyObject = new memctrlrPyWrapper(this);
-                connect(this->pyObject,SIGNAL(launchTest(uint,uint)),this,SLOT(launchTest(uint,uint)));
+            //    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.pro +2 -4

             #
             # Project created by QtCreator 2011-09-20T08:15:30
             #
             #-------------------------------------------------
             CONFIG += socexplorerplugin
             CONFIG += dll
             CONFIG -= static
             VERSION=1.0.1
             TARGET = memctrlrplugin
             DEFINES += PLUGIN=memctrlrplugin
             DEFINES += PLUGINHEADER="\"\\\"memctrlrplugin.h"\\\"\"
             DEFINES += driver_Name="\"\\\"MemControler"\\\"\"
             DEFINES += driver_Author="\"\\\"Alexis Jeandet alexis.jeandet@lpp.polytechnique.fr"\\\"\"
             DEFINES += driver_Description="\"\\\"Memory controler driver, works with ESA's LEON2 memory controler."\\\"\"
             DEFINES += driver_can_be_root=0
             DEFINES += driver_can_be_child=1
             DEFINES += driver_VID=0x04
             DEFINES += driver_PID=0x0f
             #LIBS +=-llppmoncommon
             INCLUDEPATH += \
                     $${PWD}
             HEADERS += \
                 memctrlrplugin.h \
                 memctrlrpluginui.h \
                 memorycheck.h \
-                genericmemoryspacecheck.h \
+                genericmemoryspacecheck.h
-                memctrlrpywrapper.h
             SOURCES += \
                 memctrlrplugin.cpp \
                 memctrlrpluginui.cpp \
                 memorycheck.cpp \
-                genericmemoryspacecheck.cpp \
+                genericmemoryspacecheck.cpp
-                memctrlrpywrapper.cpp

spwplugin/spwplugin.cpp +24 -24

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2014, Plasma Physics Laboratory - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@member.fsf.org
             ----------------------------------------------------------------------------*/
             #include "spwplugin.h"
             #include "stardundeespw_usb.h"
             #include "gr_esb_bridge.h"
             #include <socexplorerproxy.h>
             #include "spwpywrapper.h"
             spwplugin::spwplugin(QWidget *parent):socexplorerplugin(parent,false)
             {
                 Q_UNUSED(parent)
                 this->bridge = NULL;
                 this->scanDone = false;
-                this->pyObject = new spwPyWrapper(this);
+            //    this->pyObject = new spwPyWrapper(this);
                 this->tcpServer = new SpwTcpPacketServer(this);
                 this->mainGroupBox = new QGroupBox("SpaceWire Plugin Configuration",this);
                 this->bridgeSelector = new QComboBox(this);
                 this->mainTabWidgt = new QTabWidget(this);
                 this->mainTabWidgt->addTab(this->mainGroupBox,"Bridge Configuration");
                 this->mainTabWidgt->addTab(this->tcpServer,"TCP Server");
                 this->mainLayout = new QGridLayout(this->mainGroupBox);
                 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->setWidget(this->mainTabWidgt);
                 this->bridgeSelector->addItem("none");
                 this->bridgeSelector->addItem("STAR-Dundee Spw USB Brick");
                 this->bridgeSelector->addItem("GR-ESB");
                 connect(this->bridgeSelector,SIGNAL(currentIndexChanged(QString)),this,SLOT(bridgeSelectionChanged(QString)));
-                connect(((spwPyWrapper*)this->pyObject),SIGNAL(selectBridge(QString)),this,SLOT(selectBridge(QString)));
+                connect(this,SIGNAL(selectBridge(QString)),this,SLOT(selectBridge(QString)));
-                connect(((spwPyWrapper*)this->pyObject),SIGNAL(TCPServerConnect()),this->tcpServer,SLOT(connectServer()));
+                connect(this,SIGNAL(TCPServerConnect()),this->tcpServer,SLOT(connectServer()));
-                connect(((spwPyWrapper*)this->pyObject),SIGNAL(TCPServerDisconnect()),this->tcpServer,SLOT(disconnectServer()));
+                connect(this,SIGNAL(TCPServerDisconnect()),this->tcpServer,SLOT(disconnectServer()));
-                connect(((spwPyWrapper*)this->pyObject),SIGNAL(TCPServerSetPort(qint32)),this->tcpServer,SLOT(setServerPort(qint32)));
+                connect(this,SIGNAL(TCPServerSetPort(qint32)),this->tcpServer,SLOT(setServerPort(qint32)));
-                connect(((spwPyWrapper*)this->pyObject),SIGNAL(TCPServerSetIP(QString)),this->tcpServer,SLOT(setServerSetIP(QString)));
+                connect(this,SIGNAL(TCPServerSetIP(QString)),this->tcpServer,SLOT(setServerSetIP(QString)));
             }
             spwplugin::~spwplugin()
             {
             }
             unsigned int spwplugin::Read(unsigned int *Value,unsigned int count,unsigned int address)
             {
                 if(Connected)
                 {
                     return  bridge->Read(Value,count,address);
                 }
                 return 0;
             }
             void spwplugin::bridgeSelectionChanged(const QString &text)
             {
                 printf("test");
                 if(text=="none")
                 {
                     if(this->bridge!=NULL)
                     {
                         this->mainLayout->removeWidget(this->bridge->getGUI());
                         this->disconnect(this,SLOT(setConnected(bool)));
                         delete this->bridge;
                         this->bridge= NULL;
                     }
                 }
                 if(text=="STAR-Dundee Spw USB Brick")
                 {
                     if(this->bridge!=NULL)
                     {
                         this->mainLayout->removeWidget(this->bridge->getGUI());
                         this->disconnect(this,SLOT(setConnected(bool)));
                         delete this->bridge;
                     }
                     this->bridge = new stardundeeSPW_USB(this);
                     this->mainLayout->addWidget(this->bridge->getGUI(),1,0,1,2);
                     connect(this->bridge,SIGNAL(setConnected(bool)),this,SLOT(setConnected(bool)));
-                    connect(((spwPyWrapper*)this->pyObject),SIGNAL(StarDundeeSelectBrick(int)),((stardundeeSPW_USB*)bridge),SIGNAL(SelectBrick(int)));
+                    connect(this,SIGNAL(StarDundeeSelectBrick(int)),((stardundeeSPW_USB*)bridge),SIGNAL(SelectBrick(int)));
-                    connect(((spwPyWrapper*)this->pyObject),SIGNAL(StarDundeeSelectLinkNumber(int)),((stardundeeSPW_USB*)bridge),SIGNAL(SelectLinkNumber(int)));
+                    connect(this,SIGNAL(StarDundeeSelectLinkNumber(int)),((stardundeeSPW_USB*)bridge),SIGNAL(SelectLinkNumber(int)));
-                    connect(((spwPyWrapper*)this->pyObject),SIGNAL(StarDundeeSelectLinkSpeed(int)),((stardundeeSPW_USB*)bridge),SIGNAL(SelectLinkSpeed(int)));
+                    connect(this,SIGNAL(StarDundeeSelectLinkSpeed(int)),((stardundeeSPW_USB*)bridge),SIGNAL(SelectLinkSpeed(int)));
-                    connect(((spwPyWrapper*)this->pyObject),SIGNAL(StarDundeeSetSourceAddress(QString)),((stardundeeSPW_USB*)bridge),SIGNAL(SetSourceAddress(QString)));
+                    connect(this,SIGNAL(StarDundeeSetSourceAddress(QString)),((stardundeeSPW_USB*)bridge),SIGNAL(SetSourceAddress(QString)));
-                    connect(((spwPyWrapper*)this->pyObject),SIGNAL(StarDundeeSetDestinationAddress(QString)),((stardundeeSPW_USB*)bridge),SIGNAL(SetDestinationAddress(QString)));
+                    connect(this,SIGNAL(StarDundeeSetDestinationAddress(QString)),((stardundeeSPW_USB*)bridge),SIGNAL(SetDestinationAddress(QString)));
-                    connect(((spwPyWrapper*)this->pyObject),SIGNAL(StarDundeeSetDestinationKey(QString)),((stardundeeSPW_USB*)bridge),SIGNAL(SetDestinationKey(QString)));
+                    connect(this,SIGNAL(StarDundeeSetDestinationKey(QString)),((stardundeeSPW_USB*)bridge),SIGNAL(SetDestinationKey(QString)));
-                    connect(((spwPyWrapper*)this->pyObject),SIGNAL(StarDundeeSetRmapTimeout(QString)),((stardundeeSPW_USB*)bridge),SIGNAL(SetRmapTimeout(QString)));
+                    connect(this,SIGNAL(StarDundeeSetRmapTimeout(QString)),((stardundeeSPW_USB*)bridge),SIGNAL(SetRmapTimeout(QString)));
-                    connect(((spwPyWrapper*)this->pyObject),SIGNAL(connectBridge()),((stardundeeSPW_USB*)bridge),SLOT(connectBridge()));
+                    connect(this,SIGNAL(connectBridge()),((stardundeeSPW_USB*)bridge),SLOT(connectBridge()));
-                    connect(((spwPyWrapper*)this->pyObject),SIGNAL(disconnectBridge()),((stardundeeSPW_USB*)bridge),SLOT(disconnectBridge()));
+                    connect(this,SIGNAL(disconnectBridge()),((stardundeeSPW_USB*)bridge),SLOT(disconnectBridge()));
-                    connect(((spwPyWrapper*)this->pyObject),SIGNAL(StarDundeeGetAvailableBrickCount()),
+                    connect(this,SIGNAL(StarDundeeGetAvailableBrickCount()),
                             ((stardundeeSPW_USB*)bridge),SIGNAL(GetAvailableBrickCount()));
-                    connect(((spwPyWrapper*)this->pyObject),SIGNAL(StarDundeeGetNbPacketsTransmittedToSpw()),
+                    connect(this,SIGNAL(StarDundeeGetNbPacketsTransmittedToSpw()),
                             ((stardundeeSPW_USB*)bridge),SIGNAL(GetNbPacketsTransmittedToSpw()));
-                    connect(((spwPyWrapper*)this->pyObject),SIGNAL(StarDundeeGetNbCCSDSPacketsTransmittedToSpw()),
+                    connect(this,SIGNAL(StarDundeeGetNbCCSDSPacketsTransmittedToSpw()),
                             ((stardundeeSPW_USB*)bridge),SIGNAL(GetNbCCSDSPacketsTransmittedToSpw()));
-                    connect(((spwPyWrapper*)this->pyObject),SIGNAL(StarDundeeGetLinkNumber()),((stardundeeSPW_USB*)bridge),SIGNAL(GetLinkNumber()));
+                    connect(this,SIGNAL(StarDundeeGetLinkNumber()),((stardundeeSPW_USB*)bridge),SIGNAL(GetLinkNumber()));
-                    connect(((spwPyWrapper*)this->pyObject),SIGNAL(StarDundeeSetBrickAsAninterface(bool)),
+                    connect(this->,SIGNAL(StarDundeeSetBrickAsAninterface(bool)),
                             ((stardundeeSPW_USB*)bridge),SIGNAL(SetBrickAsAnInterface(bool)));
-                    connect(((spwPyWrapper*)this->pyObject),SIGNAL(StarDundeeSetBrickAsARouter(bool)),
+                    connect(this,SIGNAL(StarDundeeSetBrickAsARouter(bool)),
                             ((stardundeeSPW_USB*)bridge),SIGNAL(SetBrickAsARouter(bool)));
-                    connect(((spwPyWrapper*)this->pyObject),SIGNAL(StarDundeeStartTimecodes(bool)),
+                    connect(this,SIGNAL(StarDundeeStartTimecodes(bool)),
                             ((stardundeeSPW_USB*)bridge),SIGNAL(StartSendingTimecodes(bool)));
-                    connect(((spwPyWrapper*)this->pyObject),SIGNAL(StarDundeeSetTimecodeFrequency(double)),
+                    connect(this,SIGNAL(StarDundeeSetTimecodeFrequency(double)),
                             ((stardundeeSPW_USB*)bridge),SIGNAL(SetTimecodeFrequency(double)));
-                    connect(((spwPyWrapper*)this->pyObject),SIGNAL(StarDundeeSendOneTimecode(unsigned char)),
+                    connect(this,SIGNAL(StarDundeeSendOneTimecode(unsigned char)),
                             ((stardundeeSPW_USB*)bridge),SIGNAL(SendOneTimecode(unsigned char)));
                     connect(this->bridge,SIGNAL(pushPacketOverTCP(char*,int)),this->tcpServer,SLOT(pushPacket(char*,int)));
                     connect(this->tcpServer, SIGNAL(sendSPWPacket(char*,int)), ((stardundeeSPW_USB*)bridge), SLOT(sendPacketComingFromTCPServer(char*,int)));
                 }
                 if(text=="GR-ESB")
                 {
                     if(this->bridge!=NULL)
                     {
                         this->mainLayout->removeWidget(this->bridge->getGUI());
                         this->disconnect(this,SLOT(setConnected(bool)));
                         delete this->bridge;
                     }
                     this->bridge = new GR_ESB_bridge(this);
                     this->mainLayout->addWidget(this->bridge->getGUI(),1,0,1,2);
                     connect(this->bridge,SIGNAL(setConnected(bool)),this,SLOT(setConnected(bool)));
                 }
             }
             void spwplugin::selectBridge(const QString &text)
             {
                 if(text=="none")
                 {
                     this->bridgeSelector->setCurrentIndex(0);
                 }
                 if(text=="STAR-Dundee Spw USB Brick")
                 {
                     this->bridgeSelector->setCurrentIndex(1);
                 }
             }
             void spwplugin::setConnected(bool connected)
             {
                 this->bridgeSelector->setDisabled(connected);
                 this->Connected = connected;
                 emit activateSig(connected);
                 if(!this->scanDone)
                 {
                     socexplorerproxy::loadChildSysDriver(this,"AMBA_PLUGIN");
                     this->scanDone=true;
                 }
             }
             unsigned int spwplugin::Write(unsigned int *Value,unsigned int count, unsigned int address)
             {
                 if(Connected)
                 {
                     return  bridge->Write(Value,count,address);
                 }
                 return 0;
             }

spwplugin/spwplugin.h +24 0

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2014, Plasma Physics Laboratory - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@member.fsf.org
             ----------------------------------------------------------------------------*/
             #ifndef spwplugin_H
             #define spwplugin_H
             #include <QMenuBar>
             #include <QMenu>
             #include <QAction>
             #include <QLayout>
             #include <QGroupBox>
             #include <QComboBox>
             #include <QLabel>
             #include <QTabWidget>
             #include <abstractspwbridge.h>
             #include <socexplorerplugin.h>
             #include "SpwTcpPacketServer/spwtcppacketserver.h"
             // TODO switch to a class factory approach with self registration
             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 selectBridge( const QString & text );
                 void setConnected(bool connected);
             signals:
+                void selectBridge(const QString &bridgeName);
+                bool connectBridge();
+                bool disconnectBridge();
+                void StarDundeeSelectBrick(int brickIndex);
+                void StarDundeeSelectLinkNumber(int linkIndex);
+                void StarDundeeSelectLinkSpeed(int linkSpeed);
+                void StarDundeeSetSourceAddress(const QString & destKey);
+                void StarDundeeSetDestinationAddress(const QString & address);
+                void StarDundeeSetDestinationKey(const QString & key);
+                void StarDundeeSetRmapTimeout(const QString & timeout);
+                int StarDundeeGetAvailableBrickCount();
+                unsigned int StarDundeeGetNbPacketsTransmittedToSpw( void );
+                unsigned int StarDundeeGetNbCCSDSPacketsTransmittedToSpw( void );
+                int StarDundeeGetLinkNumber();
+                void StarDundeeSetBrickAsAninterface( bool );
+                void StarDundeeSetBrickAsARouter( bool );
+                void StarDundeeSetTimecodeFrequency( double );
+                void StarDundeeStartTimecodes( bool );
+                void StarDundeeSendOneTimecode( unsigned char timecode );
+                void TCPServerConnect();
+                void TCPServerDisconnect();
+                void TCPServerSetPort(qint32 port);
+                void TCPServerSetIP(QString ip);
             private:
                 SpwTcpPacketServer* tcpServer;
                 abstractSpwBridge* bridge;
                 bool scanDone;
                 QTabWidget* mainTabWidgt;
                 QGroupBox* mainGroupBox;
                 QComboBox* bridgeSelector;
                 QGridLayout* mainLayout;
             };
             #endif // spwplugin_H

spwplugin/spwplugin.pro 0 -2

             #
             # Project created by QtCreator 2011-09-20T08:15:30
             #
             #-------------------------------------------------
             CONFIG += socexplorerplugin
             QT += network webkit
             greaterThan(QT_MAJOR_VERSION, 4): QT += webkitwidgets
             win32:CONFIG += dll
             win32:CONFIG -= static
             VERSION=0.5.0
             TARGET = spwplugin
             DEFINES += PLUGIN=spwplugin
             DEFINES += PLUGINHEADER="\"\\\"spwplugin.h"\\\"\"
             DEFINES += driver_Name="\"\\\"SpwPlugin"\\\"\"
             DEFINES += driver_Author="\"\\\"Alexis Jeandet alexis.jeandet@member.fsf.org; Paul Leroy paul.leroy@lpp.polytechnique.fr"\\\"\"
             DEFINES += driver_Description="\"\\\"This plugin allows you to use spacewire's RMAP protocol with Stardundee USB brick v1"\\\"\"
             DEFINES += driver_can_be_root=1
             DEFINES += driver_can_be_child=0
             DEFINES += driver_VID=0
             DEFINES += driver_PID=0
             STARTDUNDEEPATH=/home/spacewire/usb/spw_usb_driver_v2.68/
             LIBS += $$STARTDUNDEEPATH/lib/x86_64/libSpaceWireUSBAPI.so \
                 $$STARTDUNDEEPATH/lib/x86_64/libConfigLibraryUSB.so
             INCLUDEPATH += \
                     $${PWD} \
                     $$STARTDUNDEEPATH/inc \
                     StarDundee \
                     SpwTcpPacketServer \
                     GR-ESB
             HEADERS += \
                 spwplugin.h \
                 StarDundee/stardundeespw_usb.h \
                 abstractspwbridge.h \
                 spw.h \
                 StarDundee/stardundeegui.h \
                 SpwTcpPacketServer/spwtcppacketserver.h \
-                spwpywrapper.h \
                 GR-ESB/gr_esb_bridge.h \
                 GR-ESB/gr_esb_ui.h \
                 SpwTcpPacketServer/incomingpacketparser.h
             SOURCES += \
                 spwplugin.cpp \
                 StarDundee/stardundeespw_usb.cpp \
                 abstractspwbridge.cpp \
                 StarDundee/stardundeegui.cpp \
                 SpwTcpPacketServer/spwtcppacketserver.cpp \
-                spwpywrapper.cpp \
                 GR-ESB/gr_esb_bridge.cpp \
                 GR-ESB/gr_esb_ui.cpp \
                 SpwTcpPacketServer/incomingpacketparser.cpp
             FORMS += \
                 StarDundee/stardundeeGUI.ui \
                 SpwTcpPacketServer/spwtcppacketserver.ui \
                 GR-ESB/gr_esb_ui.ui
             RESOURCES += \
                 spwRessources.qrc

ahbuartplugin/ahbuartpywrapper.cpp removed 0 -32

NO CONTENT: file was removed

ahbuartplugin/ahbuartpywrapper.h removed 0 -25

NO CONTENT: file was removed

dsu3plugin/dsu3pluginpywrapper.cpp removed 0 -6

NO CONTENT: file was removed

dsu3plugin/dsu3pluginpywrapper.h removed 0 -23

NO CONTENT: file was removed

genericrwplugin/genericrwpluginpywrapper.cpp removed 0 -27

NO CONTENT: file was removed

genericrwplugin/genericrwpluginpywrapper.h removed 0 -40

NO CONTENT: file was removed

memctrlrplugin/memctrlrpywrapper.cpp removed 0 -6

NO CONTENT: file was removed

memctrlrplugin/memctrlrpywrapper.h removed 0 -17

NO CONTENT: file was removed

spwplugin/spwpywrapper.cpp removed 0 -27

NO CONTENT: file was removed

spwplugin/spwpywrapper.h removed 0 -39

NO CONTENT: file was removed

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