HG_REPOSITORIES/LPP/INSTRUMENTATION/SocExplorerPlugins Commit - r29:8466dbc97576

APBUART Working, need some cosmetic now.

Jeandet Alexis -

r29:8466dbc97576 default

parent child

Context file:

r29:8466dbc97576

Collapse all files

APBUARTPLUGIN/apbuart_plugin_ui.cpp +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2014, Plasma Physics Laboratory - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 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 "apbuart_plugin_ui.h"
             #include "ui_apbuart_plugin_ui.h"
             #include "apbuartterminal.h"
             APBUART_Plugin_ui::APBUART_Plugin_ui(QWidget *parent) :
                 QWidget(parent),
                 ui(new Ui::APBUART_Plugin_ui)
             {
                 ui->setupUi(this);
                 connect(this->ui->FIFODebugChkBx,SIGNAL(stateChanged(int)),this,SIGNAL(loopbackChkBxStateChanged(int)));
-                connect(this,SIGNAL(apbUartTextReceived(QString)),this->ui->UART_TERM,SLOT(append(QString)));
+                connect(this,SIGNAL(apbUartTextReceived(QString)),this->ui->UART_TERM,SLOT(apbUartTextReceived(QString)));
                 connect(this->ui->ConnectQpb,SIGNAL(clicked()),this,SIGNAL(connectPort()));
                 connect(this->ui->UART_TERM,SIGNAL(sendChar(char)),this,SIGNAL(sendChar(char)));
                 connect(this->ui->PortNameLineEdit,SIGNAL(textChanged(QString)),this,SIGNAL(PortNameChanged(QString)));
                 connect(this->ui->UartSpeedLineEdit,SIGNAL(textChanged(QString)),this,SIGNAL(UartSpeedChanged(QString)));
             }
             APBUART_Plugin_ui::~APBUART_Plugin_ui()
             {
                 delete ui;
             }
             void APBUART_Plugin_ui::setEnableForLoopBack(bool enable)
             {
                 this->ui->PortNameLineEdit->setEnabled(enable);
                 this->ui->ConnectQpb->setEnabled(enable);
                 this->ui->UartSpeedLineEdit->setEnabled(enable);
             }
             void APBUART_Plugin_ui::setUartConnected(bool enable)
             {
                 this->ui->PortNameLineEdit->setDisabled(enable);
                 this->ui->UartSpeedLineEdit->setDisabled(enable);
                 this->ui->FIFODebugChkBx->setDisabled(enable);
                 if(enable)
                 {
                     this->ui->ConnectQpb->setText("Close Port");
                 }
                 else
                 {
                     this->ui->ConnectQpb->setText("Open Port");
                 }
             }

APBUARTPLUGIN/apbuart_plugin_ui.ui +2 -2

             <?xml version="1.0" encoding="UTF-8"?>
             <ui version="4.0">
              <class>APBUART_Plugin_ui</class>
              <widget class="QWidget" name="APBUART_Plugin_ui">
               <property name="geometry">
                <rect>
                 <x>0</x>
                 <y>0</y>
                 <width>400</width>
                 <height>300</height>
                </rect>
               </property>
               <property name="windowTitle">
                <string>Form</string>
               </property>
               <layout class="QVBoxLayout" name="verticalLayout">
                <item>
                 <widget class="QTabWidget" name="TabWidget">
                  <property name="currentIndex">
-                  <number>1</number>
+                  <number>0</number>
                  </property>
                  <widget class="QWidget" name="Config">
                   <attribute name="title">
                    <string>Configuration</string>
                   </attribute>
                   <layout class="QGridLayout" name="gridLayout">
                    <item row="1" column="1">
                     <widget class="QLineEdit" name="PortNameLineEdit"/>
                    </item>
                    <item row="0" column="0" colspan="2">
                     <widget class="QCheckBox" name="FIFODebugChkBx">
                      <property name="text">
                       <string>Enable FIFO debug mode</string>
                      </property>
                      <property name="checked">
-                      <bool>true</bool>
+                      <bool>false</bool>
                      </property>
                     </widget>
                    </item>
                    <item row="1" column="0">
                     <widget class="QLabel" name="PortNameLbl">
                      <property name="text">
                       <string>Port Name</string>
                      </property>
                     </widget>
                    </item>
                    <item row="3" column="0">
                     <widget class="QLabel" name="UartSpeedLbl">
                      <property name="text">
                       <string>Uart Speed</string>
                      </property>
                     </widget>
                    </item>
                    <item row="4" column="1">
                     <widget class="QPushButton" name="ConnectQpb">
                      <property name="text">
                       <string>Open Port</string>
                      </property>
                     </widget>
                    </item>
                    <item row="3" column="1">
                     <widget class="QLineEdit" name="UartSpeedLineEdit"/>
                    </item>
                   </layout>
                  </widget>
                  <widget class="QWidget" name="Terminal">
                   <attribute name="title">
                    <string>Terminal</string>
                   </attribute>
                   <layout class="QVBoxLayout" name="verticalLayout_2">
                    <item>
                     <widget class="ApbUartTerminal" name="UART_TERM"/>
                    </item>
                   </layout>
                  </widget>
                 </widget>
                </item>
               </layout>
              </widget>
              <customwidgets>
               <customwidget>
                <class>ApbUartTerminal</class>
                <extends>QTextEdit</extends>
                <header>apbuartterminal.h</header>
               </customwidget>
              </customwidgets>
              <resources/>
              <connections/>
             </ui>

APBUARTPLUGIN/apbuartterminal.cpp +12 -2

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2013, Plasma Physics Laboratory - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@member.fsf.org
             ----------------------------------------------------------------------------*/
             #include "apbuartterminal.h"
             ApbUartTerminal::ApbUartTerminal(QWidget *parent) :
                 QTextEdit(parent)
             {
-                connect(this,SIGNAL(apbUartTextReceived(QString)),this,SLOT(append(QString)));
+            //    connect(this,SIGNAL(apbUartTextReceived(QString)),this,SLOT(append(QString)));
                 setReadOnly(true);
             }
             void ApbUartTerminal::keyPressEvent(QKeyEvent *e)
             {
-                emit this->sendChar((char)e->key());
+                if((e->modifiers()==(Qt::ShiftModifier | Qt::ControlModifier)) && (e->key()==Qt::Key_L))
+                    this->clear();
+                else
+                    emit this->sendChar((char)e->key());
                 e->accept();
             }
+            void ApbUartTerminal::apbUartTextReceived(QString text)
+            {
+                moveCursor (QTextCursor::End);
+                insertPlainText (text);
+                moveCursor (QTextCursor::End);
+            }

APBUARTPLUGIN/apbuartterminal.h +2 -2

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2013, Plasma Physics Laboratory - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@member.fsf.org
             ----------------------------------------------------------------------------*/
             #ifndef APBUARTTERMINAL_H
             #define APBUARTTERMINAL_H
             #include <QWidget>
             #include <QTextEdit>
             #include <QKeyEvent>
             class ApbUartTerminal : public QTextEdit
             {
                 Q_OBJECT
             public:
                 explicit ApbUartTerminal(QWidget *parent = 0);
             protected:
                 void keyPressEvent(QKeyEvent * e);
+            public slots:
+                void apbUartTextReceived(QString text);
             signals:
-                void apbUartTextReceived(QString text);
                 void sendChar(char c);
             public slots:
             };
             #endif // APBUARTTERMINAL_H

APBUARTPLUGIN/uartpollingthread.cpp +21 -5

             /*------------------------------------------------------------------------------
             --  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 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 "uartpollingthread.h"
             #include <socexplorerengine.h>
             UARTPollingThread::UARTPollingThread(socexplorerplugin *parent) :
                 QThread((QObject*)parent)
             {
                 this->plugin = parent;
                 uartMutex = new QMutex();
                 uartOpened = false;
                 fifoDebugConfigured = false;
+                fifoDebugEnabled = false;
                 this->moveToThread(this);
             }
+            UARTPollingThread::~UARTPollingThread()
+            {
+                this->requestInterruption();
+                while(isRunning());
+            }
             void UARTPollingThread::run()
             {
                 SocExplorerEngine::message(this->plugin,"Entering APB UART polling thread",3);
                 while (!this->isInterruptionRequested())
                 {
                     if(fifoDebugEnabled)
                     {
                         if(fifoDebugConfigured)
                         {
                             if(this->plugin->baseAddress()!=-1)
                             {
                                 unsigned int status_reg,data;
                                 char ch;
                                 QString printdata="";
                                 plugin->parent->Read(&status_reg,1,this->plugin->baseAddress()+APB_UART_STATUS_REG);
                                 while ((status_reg&4)==0) {
                                     plugin->parent->Read(&data,1,this->plugin->baseAddress()+APB_UART_FIFO_DEBUG_REG);
                                     ch = (char)(0xff & data);
                                     printdata+=ch;
                                     plugin->parent->Read(&status_reg,1,this->plugin->baseAddress()+APB_UART_STATUS_REG);
                                 }
                                 if(printdata!="")
                                     emit apbUartTextReceived(printdata);
                             }
                             else
                             {
                                 this->plugin->setBaseAddress(SocExplorerEngine::self()->getEnumDeviceBaseAddress(this->plugin,this->plugin->VID(),this->plugin->PID(),0));
                             }
                         }
                         else
                         {
                             configFifoDebug(true);
                         }
                     }
                     else
                     {
                         int read =0;
-                        char ch;
+                        char ch[1];
                         uartMutex->lock();
                         if(uartOpened)
                         {
-                            read =rs232read(this->uart,&ch,1);
+                            read =rs232read(this->uart,ch,1);
+                            SocExplorerEngine::message(this->plugin,QString("Read %1 bytes on uart").arg(read),3);
                         }
                         uartMutex->unlock();
-                        if(read==1)
+                        if(read>=1)
                         {
-                            emit this->sendChar(ch);
+                            SocExplorerEngine::message(this->plugin,QString("Received one char from APBUART"),3);
+                            emit this->apbUartTextReceived(QString(ch[0]));
                         }
+                        msleep(1);
                     }
-                    msleep(100);
                 }
             }
             void UARTPollingThread::sendChar(char c)
             {
                 if(fifoDebugEnabled)
                 {
                     if(this->plugin->baseAddress()!=-1)
                     {
                         unsigned int i=0x0FF & c;
                         plugin->parent->Write(&i,1,this->plugin->baseAddress()+APB_UART_FIFO_DEBUG_REG);
                     }
                 }
                 else
                 {
                     uartMutex->lock();
                     rs232write(this->uart,&c,1);
                     uartMutex->unlock();
                 }
             }
             bool UARTPollingThread::openUart()
             {
+                uartMutex->lock();
                 if(uartOpened)
                 {
                     closeUart();
                 }
+                SocExplorerEngine::message(this->plugin,"Opening UART "+this->portName,3);
                 this->uart = rs232open((char*)this->portName.toStdString().c_str());
                 if(this->uart!=badPortValue)
                 {
+                    SocExplorerEngine::message(this->plugin,QString("Configuring UART, speed =%1").arg(this->uartSpeed),3);
                     rs232setup(this->uart,8,this->uartSpeed,rs232parityNo,rs232OneStop);
                     uartOpened = true;
                 }
+                uartMutex->unlock();
                 return uartOpened;
             }
             void UARTPollingThread::closeUart()
             {
                 uartMutex->lock();
                 rs232close(this->uart);
                 uartOpened = false;
                 uartMutex->unlock();
             }
             void UARTPollingThread::setPortName(QString name)
             {
+                SocExplorerEngine::message(this->plugin,"Changing UART port Name: "+name,3);
                 this->portName = name;
             }
             void UARTPollingThread::setPortSpeedStr(QString speed)
             {
+                SocExplorerEngine::message(this->plugin,"Changing UART speed: "+speed,3);
                 this->uartSpeed = speed.toInt();
             }
             void UARTPollingThread::setPortSpeed(int speed)
             {
+                SocExplorerEngine::message(this->plugin,QString("Changing UART speed: %1").arg(speed),3);
                 this->uartSpeed = speed;
             }
             void UARTPollingThread::setFifoDebugEable(bool enable)
             {
                 if(enable)
                     SocExplorerEngine::message(this->plugin,"Enabling APB UART FIFO debug mode",3);
                 else
                     SocExplorerEngine::message(this->plugin,"Disabling APB UART FIFO debug mode",3);
                 if(uartOpened && enable)
                 {
                     closeUart();
                 }
                 this->fifoDebugConfigured = false;
                 configFifoDebug(enable);
                 this->fifoDebugEnabled = enable;
             }
             void UARTPollingThread::configFifoDebug(bool enable)
             {
                 SocExplorerEngine::message(this->plugin,"Configuring APB UART in FIFO debug mode",3);
                 if(this->plugin->baseAddress()==-1)
                 {
                     this->plugin->setBaseAddress(SocExplorerEngine::self()->getEnumDeviceBaseAddress(this->plugin,this->plugin->VID(),this->plugin->PID(),0));
                 }
                 if(this->plugin->baseAddress()!=-1)
                 {
                     if(enable)
                     {
                         unsigned int ctrl_reg= 0x843;
                         this->plugin->parent->Write(&ctrl_reg,1,this->plugin->baseAddress()+APB_UART_CONTROL_REG);
                         this->fifoDebugConfigured = true;
                     }
                     else
                     {
                         unsigned int ctrl_reg;
                         /* Firts get Control reg value*/
                         this->plugin->parent->Read(&ctrl_reg,1,this->plugin->baseAddress()+APB_UART_CONTROL_REG);
                         ctrl_reg = ctrl_reg & (~(1<<11));
                         this->plugin->parent->Write(&ctrl_reg,1,this->plugin->baseAddress()+APB_UART_CONTROL_REG);
                         this->fifoDebugConfigured = true;
                     }
                 }
             }

APBUARTPLUGIN/uartpollingthread.h +1 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 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
             ----------------------------------------------------------------------------*/
             #ifndef UARTPOLLINGTHREAD_H
             #define UARTPOLLINGTHREAD_H
             #include <QObject>
             #include <QThread>
             #include <socexplorerplugin.h>
             #include <RS232.h>
             #include <QMutex>
             #define  APB_UART_DATA_REG          0x0
             #define  APB_UART_STATUS_REG        0x4
             #define  APB_UART_CONTROL_REG       0x8
             #define  APB_UART_SCALE_REG         0xC
             #define  APB_UART_FIFO_DEBUG_REG    0x10
             class UARTPollingThread : public QThread
             {
                 Q_OBJECT
             public:
                 explicit UARTPollingThread(socexplorerplugin *parent = 0);
+                ~UARTPollingThread();
                 void run();
             signals:
                 void apbUartTextReceived(QString text);
             public slots:
                 void sendChar(char c);
                 bool openUart();
                 void closeUart();
                 void setPortName(QString name);
                 void setPortSpeedStr(QString speed);
                 void setPortSpeed(int speed);
                 void setFifoDebugEable(bool enable);
             private:
                 void configFifoDebug(bool enable);
                 bool fifoDebugEnabled;
                 bool fifoDebugConfigured;
                 QString portName;
                 int uartSpeed;
                 bool uartOpened;
                 socexplorerplugin* plugin;
                 rs232port_t uart;
                 QMutex* uartMutex;
             };
             #endif // UARTPOLLINGTHREAD_H

spwplugin/GR-ESB/gr_esb_bridge.cpp +2 0

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2014, Plasma Physics Laboratory - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@member.fsf.org
             ----------------------------------------------------------------------------*/
             #include "gr_esb_bridge.h"
             #include "gr_esb_ui.h"
             #include <unistd.h>
             #include "spw.h"
             #include <socexplorerengine.h>
             GR_ESB_bridge::GR_ESB_bridge(socexplorerplugin *parent) :
                 abstractSpwBridge(parent)
             {
                 this->p_GUI = new GR_ESB_ui();
                 this->manager = new GR_ESB_Manager(parent,this);
                 connect((GR_ESB_ui*)(this->p_GUI),SIGNAL(ipchanged(QString)),this,SLOT(setIP(QString)));
                 connect((GR_ESB_ui*)(this->p_GUI),SIGNAL(vlinkchanged(QString)),this,SLOT(setVirtualLink(QString)));
                 connect((GR_ESB_ui*)(this->p_GUI),SIGNAL(connectClicked()),this,SLOT(toggleBridgeConnection()));
                 this->manager->virtualLinkIndex = 0;
                 this->manager->start();
             }
             GR_ESB_bridge::~GR_ESB_bridge()
             {
+                this->manager->requestInterruption();
+                while(this->manager->isRunning());
             }
             void GR_ESB_bridge::toggleBridgeConnection()
             {
                 if(this->plugin->isConnected())
                 {
                     this->disconnectBridge();
                 }
                 else
                 {
                     this->connectBridge();
                 }
             }
             bool GR_ESB_bridge::connectBridge()
             {
                 if(this->manager->connectBridge())
                 {
                     ((GR_ESB_ui*)this->p_GUI)->lock(true);
                     emit setConnected(true);
                     return true;
                 }
                 return false;
             }
             bool GR_ESB_bridge::disconnectBridge()
             {
                 if(this->manager->disconnectBridge())
                 {
                     ((GR_ESB_ui*)this->p_GUI)->lock(false);
                     emit setConnected(false);
                     return true;
                 }
                 return false;
             }
             void GR_ESB_bridge::setIP(QString ip)
             {
                 this->manager->IP = ip;
             }
             void GR_ESB_bridge::setVirtualLink(QString vlink)
             {
                 vlink = vlink.section("Virtual link",0,0);
                 bool success;
                 int vlinkTmp = vlink.toInt(&success);
                 if(success)
                 {
                     setVirtualLink(vlinkTmp);
                 }
             }
             void GR_ESB_bridge::setVirtualLink(qint32 vlink)
             {
                 if(vlink<6 && vlink>=0)
                 {
                     this->manager->virtualLinkIndex = vlink;
                 }
             }
             unsigned int GR_ESB_bridge::Write(unsigned int *Value, unsigned int count, unsigned int address)
             {
             }
             unsigned int GR_ESB_bridge::Read(unsigned int *Value, unsigned int count, unsigned int address)
             {
             }
             int GR_ESB_bridge::pushRMAPPacket(char *packet, int size)
             {
                 return this->manager->sendPacket(packet,size);
             }
             GR_ESB_Manager::GR_ESB_Manager(socexplorerplugin *plugin, QObject *parent)
                 :QThread((QObject*)parent)
             {
                 this->Read_soc = new QTcpSocket(this);
                 this->Write_soc = new QTcpSocket(this);
                 this->RMAPtimeout = 2000;
                 this->handleMutex = new QMutex(QMutex::NonRecursive);
                 this->RMAP_AnswersSem = new QSemaphore(0);
                 this->RMAP_AnswersMtx=new QMutex(QMutex::Recursive);
                 this->RMAP_pending_transaction_IDsMtx=new QMutex(QMutex::Recursive);
                 this->plugin = plugin;
                 connected = false;
                 this->moveToThread(this);
             }
             GR_ESB_Manager::~GR_ESB_Manager()
             {
             }
             void GR_ESB_Manager::run()
             {
                 SocExplorerEngine::message(this->plugin,"Starting GRESB pooling thread",1);
                 while (!this->isInterruptionRequested())
                 {
                     if(this->connected)
                     {
                         handleMutex->lock();
                         SocExplorerEngine::message(this->plugin,"Looking for new RMAP packets",4);
                     }
                     else
                     {
                         //do some sanity checks!
                         usleep(RMAPtimeout/2);
                     }
                     usleep(1000);
                 }
                 SocExplorerEngine::message(this->plugin,"Exiting Startdundee USB pooling thread",1);
             }
             bool GR_ESB_Manager::connectBridge()
             {
                 int timeout=60;
                 if(this->Read_soc->state()==QTcpSocket::UnconnectedState)
                 {
                     this->Read_soc->connectToHost(IP,gresb_Conf[virtualLinkIndex].Read_port);
                     this->Read_soc->waitForConnected(30000);
                 }
                 if(this->Write_soc->state()==QTcpSocket::UnconnectedState)
                 {
                     this->Write_soc->connectToHost(IP,gresb_Conf[virtualLinkIndex].Write_port);
                     this->Write_soc->waitForConnected(30000);
                 }
                 while((this->Read_soc->state()!=QTcpSocket::ConnectedState) && (this->Write_soc->state()!=QTcpSocket::ConnectedState))
                 {
                     usleep(100000);
                     if(timeout--==0)return false;
                 }
                 return true;
             }
             bool GR_ESB_Manager::disconnectBridge()
             {
                 int timeout=60;
                 if(this->Read_soc->state()!=QTcpSocket::UnconnectedState)
                 {
                     this->Read_soc->disconnectFromHost();
                     this->Read_soc->waitForDisconnected(30000);
                 }
                 if(this->Write_soc->state()!=QTcpSocket::UnconnectedState)
                 {
                     this->Write_soc->disconnectFromHost();
                     this->Write_soc->waitForDisconnected(30000);
                 }
                 while((this->Read_soc->state()!=QTcpSocket::UnconnectedState) && (this->Write_soc->state()!=QTcpSocket::UnconnectedState))
                 {
                     usleep(100000);
                     if(timeout--==0)return false;
                 }
                 return true;
             }
             int GR_ESB_Manager::getRMAPtransactionID()
             {
             }
             int GR_ESB_Manager::getRMAPanswer(int transactionID, char **buffer)
             {
             }
             bool GR_ESB_Manager::sendPacket(char *packet, int size)
             {
             }
             void GR_ESB_Manager::pushRmapPacket(char *packet, int len)
             {
             }

spwplugin/StarDundee/stardundeespw_usb.cpp +1 0

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2014, Plasma Physics Laboratory - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@member.fsf.org
             ----------------------------------------------------------------------------*/
             #include "stardundeespw_usb.h"
             #include <socexplorerengine.h>
             #include <qhexedit.h>
             stardundeeSPW_USB::stardundeeSPW_USB(socexplorerplugin *parent) :
                 abstractSpwBridge(parent)
             {
                 Q_UNUSED(parent)
                 this->manager = new stardundeeSPW_USB_Manager(parent,this);
                 makeGUI(parent);
                 this->manager->start();
                 connect(this->manager,SIGNAL(emitPacket(char*,int)),this,SIGNAL(pushPacketOverTCP(char*,int)));
             }
             stardundeeSPW_USB::~stardundeeSPW_USB()
             {
                 this->manager->requestInterruption();
+                while(this->manager->isRunning());
             }
             void stardundeeSPW_USB::toggleBridgeConnection()
             {
                 if(this->plugin->isConnected())
                 {
                     this->disconnectBridge();
                 }
                 else
                 {
                     this->connectBridge();
                 }
             }
             bool stardundeeSPW_USB::connectBridge()
             {
                 if(this->manager->connectBridge())
                 {
                     ((StarDundeeGUI*)this->p_GUI)->lock(true);
                     emit setConnected(true);
                     return true;
                 }
                 return false;
             }
             bool stardundeeSPW_USB::disconnectBridge()
             {
                 if(this->manager->disconnectBridge())
                 {
                     ((StarDundeeGUI*)this->p_GUI)->lock(false);
                     emit setConnected(false);
                     return true;
                 }
                 return false;
             }
             int stardundeeSPW_USB::pushRMAPPacket(char *packet, int size)
             {
                 return this->manager->sendPacket(packet,size);
             }
             unsigned int stardundeeSPW_USB::Write(unsigned int *Value, unsigned int count, unsigned int address)
             {
                 char writeBuffer[RMAP_WRITE_PACKET_MIN_SZ((RMAP_MAX_XFER_SIZE*4))+1];
                 char *RMAPAckBuff;
                 writeBuffer[0]=this->manager->linkNumber;//Link number
                 int transactionID = 0;
                 int written=0;
                 SocExplorerEngine::message(this->plugin,"Enter Write function",2);
                 QProgressBar* progress=NULL;
                 SocExplorerAutoProgressBar autopb;
                 if(count>RMAP_MAX_XFER_SIZE)
                 {
                     progress= SocExplorerEngine::getProgressBar("Writing on SPW @0x"+QString::number(address,16)+" %v of "+QString::number(count)+" words ",count);
                     autopb.setProgressBar(progress);
                 }
                 //Quite stupide loop, I guess that I always get the number of byte I asked for!
                 while(count>=RMAP_MAX_XFER_SIZE)
                 {
                     for(int i=0;i<(RMAP_MAX_XFER_SIZE);i++)
                     {
                         writeBuffer[RMAP_WRITE_HEADER_MIN_SZ+(i*4)+1] = (char)(((unsigned int)Value[i+written]>>24)&0xFF);
                         writeBuffer[RMAP_WRITE_HEADER_MIN_SZ+(i*4)+2] = (char)(((unsigned int)Value[i+written]>>16)&0xFF);
                         writeBuffer[RMAP_WRITE_HEADER_MIN_SZ+(i*4)+3] = (char)(((unsigned int)Value[i+written]>>8)&0xFF);
                         writeBuffer[RMAP_WRITE_HEADER_MIN_SZ+(i*4)+4] = (char)(((unsigned int)Value[i+written])&0xFF);
                     }
                     transactionID=manager->getRMAPtransactionID();
                     SocExplorerEngine::message(this->plugin,QString("Sending Write request with ID=%1").arg(transactionID),2);
                     RMAP_build_tx_request_header(this->manager->rmapAddress,this->manager->rmapKey,1,transactionID,address+(written*4),RMAP_MAX_XFER_SIZE*4,writeBuffer+1);
                     manager->sendPacket(writeBuffer,RMAP_WRITE_PACKET_MIN_SZ(RMAP_MAX_XFER_SIZE*4)+1);
                     manager->getRMAPanswer(transactionID,&RMAPAckBuff);
                     free(RMAPAckBuff);
                     written+=RMAP_MAX_XFER_SIZE;
                     count-=RMAP_MAX_XFER_SIZE;
                     progress->setValue(written);
                     qApp->processEvents();
                 }
                 if(count>0)
                 {
                     for(int i=0;i<((int)count);i++)
                     {
                         writeBuffer[RMAP_WRITE_HEADER_MIN_SZ+(i*4)+1] = (char)(((unsigned int)Value[i+written]>>24)&0xFF);
                         writeBuffer[RMAP_WRITE_HEADER_MIN_SZ+(i*4)+2] = (char)(((unsigned int)Value[i+written]>>16)&0xFF);
                         writeBuffer[RMAP_WRITE_HEADER_MIN_SZ+(i*4)+3] = (char)(((unsigned int)Value[i+written]>>8)&0xFF);
                         writeBuffer[RMAP_WRITE_HEADER_MIN_SZ+(i*4)+4] = (char)(((unsigned int)Value[i+written])&0xFF);
                     }
                     transactionID=manager->getRMAPtransactionID();
                     SocExplorerEngine::message(this->plugin,QString("Sending Write request with ID=%1").arg(transactionID),2);
                     RMAP_build_tx_request_header(this->manager->rmapAddress,this->manager->rmapKey,1,transactionID,address+(written*4),count*4,writeBuffer+1);
                     manager->sendPacket(writeBuffer,RMAP_WRITE_PACKET_MIN_SZ(count*4) +1);
                     manager->getRMAPanswer(transactionID,&RMAPAckBuff);
                     free(RMAPAckBuff);
                     written+=count;
                     if(progress!=NULL)
                     {
                         progress->setValue(written);
                         qApp->processEvents();
                     }
                 }
                 return written;
             }
             unsigned int stardundeeSPW_USB::Read(unsigned int *Value, unsigned int count, unsigned int address)
             {
                 char requestBuffer[RMAP_READ_HEADER_MIN_SZ+1];
                 char* RMAP_AnswerBuffer;
                 requestBuffer[0]=this->manager->linkNumber;//Link number
                 int transactionID = 0;
                 int read=0;
                 QProgressBar* progress=NULL;
                 SocExplorerAutoProgressBar autopb;
                 if(count>RMAP_MAX_XFER_SIZE)
                 {
                     progress= SocExplorerEngine::getProgressBar("Reading on SPW @0x"+QString::number(address,16)+" %v of "+QString::number(count)+" words ",count);
                     autopb.setProgressBar(progress);
                 }
                 SocExplorerEngine::message(this->plugin,QString("Enter read function, count=%1, RMAP_MAX_XFER_SIZE=%2").arg(count).arg(RMAP_MAX_XFER_SIZE),2);
                 //Quite stupide loop, I guess that I always get the number of byte I asked for!
                 while((int)count>=(int)RMAP_MAX_XFER_SIZE)
                 {
                     transactionID = manager->getRMAPtransactionID();
                     SocExplorerEngine::message(this->plugin,QString("New transactionID:%1").arg(transactionID),2);
                     RMAP_build_rx_request_header(this->manager->rmapAddress,this->manager->rmapKey,1,transactionID,address+(read*4),RMAP_MAX_XFER_SIZE*4,requestBuffer+1);
                     manager->sendPacket(requestBuffer,RMAP_READ_HEADER_MIN_SZ+1);
                     int len=manager->getRMAPanswer(transactionID,&RMAP_AnswerBuffer);
                     if(len==-1)
                     {
                         this->toggleBridgeConnection();
                         return 0;
                     }
                     for(int i=0;i<((len-13)/4);i++)
                     {
                         Value[read+i] =   0x0FF & ((unsigned int)RMAP_AnswerBuffer[(4*i)+12]);
                         Value[read+i] =  (Value[read+i]<<8) + (0x0FF & ((unsigned int)RMAP_AnswerBuffer[(4*i)+13]));
                         Value[read+i] =  (Value[read+i]<<8) + (0x0FF & ((unsigned int)RMAP_AnswerBuffer[(4*i)+14]));
                         Value[read+i] =  (Value[read+i]<<8) + (0x0FF & ((unsigned int)RMAP_AnswerBuffer[(4*i)+15]));
                     }
                     free(RMAP_AnswerBuffer);
                     read+=RMAP_MAX_XFER_SIZE;
                     count-=RMAP_MAX_XFER_SIZE;
                     progress->setValue(read);
                     qApp->processEvents();
                 }
                 if((int)count>0)
                 {
                     transactionID = manager->getRMAPtransactionID();
                     SocExplorerEngine::message(this->plugin,QString("New transactionID: %1").arg(transactionID),2);
                     SocExplorerEngine::message(this->plugin,QString("Building request with:"),2);
                     SocExplorerEngine::message(this->plugin,QString("Address = %1").arg(address+(read*4),8,16),2);
                     SocExplorerEngine::message(this->plugin,QString("Size = %1").arg(count*4),2);
                     SocExplorerEngine::message(this->plugin,QString("Size + 13 = %1").arg((count*4)+13),2);
                     RMAP_build_rx_request_header(this->manager->rmapAddress,this->manager->rmapKey,1,transactionID,address+(read*4),count*4,requestBuffer+1);
                     manager->sendPacket(requestBuffer,RMAP_READ_HEADER_MIN_SZ+1);
                     int len=manager->getRMAPanswer(transactionID,&RMAP_AnswerBuffer);
                     if(len==-1)
                     {
                         this->toggleBridgeConnection();
                         return 0;
                     }
                     for(int i=0;i<((len-13)/4);i++)
                     {
                         Value[read+i] =   0x0FF & ((unsigned int)RMAP_AnswerBuffer[(4*i)+12]);
                         Value[read+i] =  (Value[read+i]<<8) + (0x0FF & ((unsigned int)RMAP_AnswerBuffer[(4*i)+13]));
                         Value[read+i] =  (Value[read+i]<<8) + (0x0FF & ((unsigned int)RMAP_AnswerBuffer[(4*i)+14]));
                         Value[read+i] =  (Value[read+i]<<8) + (0x0FF & ((unsigned int)RMAP_AnswerBuffer[(4*i)+15]));
                     }
                     free(RMAP_AnswerBuffer);
                     read+=count;
                     if(progress!=NULL)
                     {
                         progress->setValue(read);
                         qApp->processEvents();
                     }
                 }
                 return read;
             }
             void stardundeeSPW_USB::brickSelectionChanged(int brickIndex)
             {
                 this->manager->selectedBrick = brickIndex-1;
                 SocExplorerEngine::message(plugin,QString("Changing brick index: %1").arg(manager->selectedBrick),1);
             }
             void stardundeeSPW_USB::linkNumberSelectionChanged(int linkIndex)
             {
                 this->manager->linkNumber = linkIndex + 1;
                 SocExplorerEngine::message(plugin,QString("Changing Link Number: %1").arg(manager->linkNumber),1);
             }
             void stardundeeSPW_USB::linkSpeedSelectionChanged(const QString &linkSpeed)
             {
                 this->manager->linkSpeed = linkSpeed.toInt();
                 SocExplorerEngine::message(plugin,QString("Changing Link Speed: %1").arg(manager->linkSpeed),1);
             }
             void stardundeeSPW_USB::destinationKeyChanged(const QString &destKey)
             {
                 this->manager->destinationKey = destKey.toInt();
                 SocExplorerEngine::message(plugin,QString("Changing Destination Key: %1").arg(manager->destinationKey),1);
             }
             void stardundeeSPW_USB::rmapAddressChanged(const QString &rmapaddress)
             {
                 this->manager->rmapAddress = rmapaddress.toInt();
                 SocExplorerEngine::message(plugin,QString("Changing RMAP address: %1").arg(manager->rmapAddress),1);
             }
             void stardundeeSPW_USB::rmapKeyChanged(const QString &key)
             {
                 this->manager->rmapKey = key.toInt();
                 SocExplorerEngine::message(plugin,QString("Changing RMAP Key: %1").arg(manager->rmapKey),1);
             }
             void stardundeeSPW_USB::rmapTimeoutChanged(const QString &timeout)
             {
                 int tim=timeout.toInt();
                 if(tim<50)
                 {
                     tim = 50;
                     ((StarDundeeGUI*)this->p_GUI)->setRmapTimeout(QString("%1").arg(tim));
                 }
                 this->manager->RMAPtimeout = tim;
                 SocExplorerEngine::message(plugin,QString("Changing RMAP Timeout: %1").arg(manager->RMAPtimeout),1);
             }
             void stardundeeSPW_USB::makeGUI(socexplorerplugin *parent)
             {
                 this->p_GUI = new StarDundeeGUI();
                 //    this->mainLayout = new QGridLayout(this->p_GUI);
                 connect(((StarDundeeGUI*)this->p_GUI),SIGNAL(connectClicked()),this,SLOT(toggleBridgeConnection()));
                 connect(this->manager,SIGNAL(updateAvailableBrickCount(int)),((StarDundeeGUI*)this->p_GUI),SLOT(updateAvailableBrickCount(int)));
                 connect(((StarDundeeGUI*)this->p_GUI),SIGNAL(brickSelectionChanged(int)),this,SLOT(brickSelectionChanged(int)));
                 connect(((StarDundeeGUI*)this->p_GUI),SIGNAL(linkNumberSelectionChanged(int)),this,SLOT(linkNumberSelectionChanged(int)));
                 connect(((StarDundeeGUI*)this->p_GUI),SIGNAL(linkSpeedSelectionChanged(QString)),this,SLOT(linkSpeedSelectionChanged(QString)));
                 connect(((StarDundeeGUI*)this->p_GUI),SIGNAL(destinationKeyChanged(QString)),this,SLOT(destinationKeyChanged(QString)));
                 connect(((StarDundeeGUI*)this->p_GUI),SIGNAL(rmapAddressChanged(QString)),this,SLOT(rmapAddressChanged(QString)));
                 connect(((StarDundeeGUI*)this->p_GUI),SIGNAL(rmapKeyChanged(QString)),this,SLOT(rmapKeyChanged(QString)));
                 connect(((StarDundeeGUI*)this->p_GUI),SIGNAL(rmapTimeoutChanged(QString)),this,SLOT(rmapTimeoutChanged(QString)));
                 this->brickSelectionChanged(((StarDundeeGUI*)this->p_GUI)->getBrickSelection());
                 this->linkNumberSelectionChanged(((StarDundeeGUI*)this->p_GUI)->getLinkNumberSelection());
                 this->linkSpeedSelectionChanged(((StarDundeeGUI*)this->p_GUI)->getLinkSpeedSelection());
                 this->destinationKeyChanged(((StarDundeeGUI*)this->p_GUI)->getDestinationKey());
                 this->rmapAddressChanged(((StarDundeeGUI*)this->p_GUI)->getRmapAddress());
                 this->rmapKeyChanged(((StarDundeeGUI*)this->p_GUI)->getRmapKey());
                 this->rmapTimeoutChanged(((StarDundeeGUI*)this->p_GUI)->getRmapTimeout());
                 connect(this,SIGNAL(SelectBrick(int)),((StarDundeeGUI*)this->p_GUI),SLOT(selectBrick(int)));
                 connect(this,SIGNAL(SelectLinkNumber(int)),((StarDundeeGUI*)this->p_GUI),SLOT(selectLinkNumber(int)));
                 connect(this,SIGNAL(SelectLinkSpeed(int)),((StarDundeeGUI*)this->p_GUI),SLOT(selectLinkSpeed(int)));
                 connect(this,SIGNAL(SetDestinationKey(QString)),((StarDundeeGUI*)this->p_GUI),SLOT(setDestinationKey(QString)));
                 connect(this,SIGNAL(SetRmapAddress(QString)),((StarDundeeGUI*)this->p_GUI),SLOT(setRmapAddress(QString)));
                 connect(this,SIGNAL(SetRmapKey(QString)),((StarDundeeGUI*)this->p_GUI),SLOT(setRmapKey(QString)));
                 connect(this,SIGNAL(SetRmapTimeout(QString)),((StarDundeeGUI*)this->p_GUI),SLOT(setRmapTimeout(QString)));
             }
             stardundeeSPW_USB_Manager::stardundeeSPW_USB_Manager(socexplorerplugin *plugin, QObject *parent)
                 :QThread((QObject*)parent)
             {
                 this->RMAPtimeout = 2000;
                 this->handleMutex = new QMutex(QMutex::NonRecursive);
                 this->RMAP_AnswersSem = new QSemaphore(0);
                 this->RMAP_AnswersMtx=new QMutex(QMutex::Recursive);
                 this->RMAP_pending_transaction_IDsMtx=new QMutex(QMutex::Recursive);
                 this->plugin = plugin;
                 connected = false;
                 this->moveToThread(this);
             }
             stardundeeSPW_USB_Manager::~stardundeeSPW_USB_Manager()
             {
                 this->terminate();
                 while (!this->isFinished()) {
                     this->usleep(1000);
                 }
             }
             void stardundeeSPW_USB_Manager::run()
             {
                 USB_SPACEWIRE_PACKET_PROPERTIES properties;
                 USB_SPACEWIRE_ID pIdentifier=NULL;
                 USB_SPACEWIRE_STATUS stat;
                 SocExplorerEngine::message(this->plugin,"Starting Startdundee USB pooling thread",1);
                 char buffer[(RMAP_MAX_XFER_SIZE*4)+50];
                 while (!this->isInterruptionRequested())
                 {
                     if(this->connected)
                     {
                         handleMutex->lock();
                         SocExplorerEngine::message(this->plugin,"Looking for new RMAP packets",4);
                         if(USBSpaceWire_WaitOnReadPacketAvailable(hDevice,0.01))
                         {
                             SocExplorerEngine::message(this->plugin,"Got packet",2);
                             stat = USBSpaceWire_ReadPackets(hDevice, buffer, (RMAP_MAX_XFER_SIZE*4)+50,1, 1, &properties, &pIdentifier);
                             if (stat == TRANSFER_SUCCESS)
                             {
                                 if(USBSpaceWire_GetReadTrafficType(&properties, 0) ==SPACEWIRE_TRAFFIC_PACKET)
                                 {
                                     SocExplorerEngine::message(this->plugin,"It's a SPW packet",2);
                                     if(USBSpaceWire_GetReadEOPStatus(&properties, 0)== SPACEWIRE_USB_EOP)
                                     {
                                         SocExplorerEngine::message(this->plugin,"Got end of packet",2);
                                         if(buffer[1]==(char)SPW_PROTO_ID_RMAP) //RMAP packet
                                         {
                                             RMAP_Answer* packet;
                                             SocExplorerEngine::message(this->plugin,"Got RMAP packet",2);
                                             SocExplorerEngine::message(this->plugin,QString("Rmap packet size %1").arg(properties.len),2);
                                             char* packetbuffer = (char*)malloc(properties.len);
                                             memcpy(packetbuffer,buffer,properties.len);
                                             USBSpaceWire_FreeRead(hDevice, pIdentifier);
                                             pIdentifier = NULL;
                                             handleMutex->unlock();
                                             if(properties.len==8)
                                             {
                                                 packet=new RMAP_Answer(RMAP_get_transactionID(buffer),packetbuffer,properties.len);
                                             }
                                             else
                                             {
                                                 packet=new RMAP_Answer(RMAP_get_transactionID(buffer+1),packetbuffer,properties.len);
                                             }
                                             RMAP_AnswersMtx->lock();
                                             RMAP_Answers.append(packet);
                                             RMAP_AnswersMtx->unlock();
                                             RMAP_AnswersSem->release();
                                         }
                                         else //any non-rmap packet will be pushed to the network
                                         {
                                             char* packetbuffer = (char*)malloc(properties.len);
                                             memcpy(packetbuffer,buffer,properties.len);
                                             emit emitPacket(packetbuffer,properties.len);
                                             USBSpaceWire_FreeRead(hDevice, pIdentifier);
                                             handleMutex->unlock();
                                             SocExplorerEngine::message(this->plugin,"Got SPW packet",2);
                                         }
                                     }
                                     else
                                     {
                                         SocExplorerEngine::message(this->plugin,"No EOP received",2);
                                     }
                                 }
                             }
                             else
                             {
                                 USBSpaceWire_FreeRead(hDevice, pIdentifier);
                                 handleMutex->unlock();
                             }
                         }
                         else
                         {
                             USBSpaceWire_FreeRead(hDevice, pIdentifier);
                             handleMutex->unlock();
                         }
                     }
                     else
                     {
                         //do some sanity checks!
                         int list = USBSpaceWire_ListDevices();
                         if(this->brickList!=list)
                         {
                             this->brickList = list;
                             emit updateAvailableBrickCount(this->brickList);
                         }
                         usleep(RMAPtimeout/2);
                     }
                     usleep(1000);
                 }
                 SocExplorerEngine::message(this->plugin,"Exiting Startdundee USB pooling thread",1);
             }
             bool stardundeeSPW_USB_Manager::connectBridge()
             {
                 QMutexLocker mlock(this->handleMutex);
                 int status;
                 U32 statusControl;
                 this->connected = false;
                 if (!USBSpaceWire_Open(&hDevice, this->selectedBrick)) // Open the USB device
                 {
                     SocExplorerEngine::message(this->plugin,"stardundee *** Open *** ERROR: USBSpaceWire_Open(&hDevice, 0))",0);
                     return false;
                 }
                 SocExplorerEngine::message(this->plugin,"stardundee *** Open *** USBSpaceWire_Open successful",0);
                 USBSpaceWire_EnableNetworkMode(hDevice, 0); // deactivate the network mode
                 CFGSpaceWire_EnableRMAP(1);                 // Enable the use of RMAP for the StarDundee brick configuration
                 CFGSpaceWire_SetRMAPDestinationKey(0x20);   // Set the destination key expected by STAR-Dundee devices
                 // Set the path and return path to the device
                 CFGSpaceWire_StackClear();
                 CFGSpaceWire_AddrStackPush(0);
                 CFGSpaceWire_AddrStackPush(254);
                 CFGSpaceWire_RetAddrStackPush(254);
                 // set the base transmit rate to 100 MHz
                 status = CFGSpaceWire_SetBrickBaseTransmitRate( hDevice, CFG_BRK_CLK_100_MHZ, CFG_BRK_DVDR_1, 0xff);
                 if (status != CFG_TRANSFER_SUCCESS)
                 {
                     SocExplorerEngine::message(this->plugin,"ERROR CFGSpaceWire_SetBrickBaseTransmitRate",1);
                     return false;
                 }
                 else
                 {
                     SocExplorerEngine::message(this->plugin,"OK CFGSpaceWire_SetBrickBaseTransmitRate, base rate = 100 MHz",1);
                 }
                 // read the link status
                 if (CFGSpaceWire_GetLinkStatusControl(hDevice, this->linkNumber, &statusControl) != CFG_TRANSFER_SUCCESS)
                 {
                     SocExplorerEngine::message(this->plugin,"Could not read link status control for link " + QString::number(this->linkNumber),1);
                     return false;
                 }
                 else
                 {
                     SocExplorerEngine::message(this->plugin,"OK CFGSpaceWire_GetLinkStatusControl of link " + QString::number(this->linkNumber),1);
                     // Set the link status control register properties
                     CFGSpaceWire_LSEnableAutoStart(&statusControl, 1);
                     CFGSpaceWire_LSEnableStart(&statusControl, 1);
                     CFGSpaceWire_LSEnableDisabled(&statusControl, 0);
                     CFGSpaceWire_LSEnableTristate(&statusControl, 0);
                     CFGSpaceWire_LSSetOperatingSpeed(&statusControl, 9);    // sets the link speed to ( 100 MHz / (9+1) ) = 10 MHz
                     // Set the link status control register
                     if (CFGSpaceWire_SetLinkStatusControl(hDevice, this->linkNumber, statusControl) != CFG_TRANSFER_SUCCESS)
                     {
                         SocExplorerEngine::message(this->plugin,"Could not set the link status control for link " + QString::number(this->linkNumber),1);
                         return false;
                     }
                     else
                     {
                         SocExplorerEngine::message(this->plugin,"Set the link status control for link " + QString::number(this->linkNumber),1);
                     }
                 }
                 if (CFGSpaceWire_SetAsInterface(hDevice, 1, 0) != CFG_TRANSFER_SUCCESS)
                 {
                     SocExplorerEngine::message(this->plugin,"Could not set the device to be an interface",1);
                     return false;
                 }
                 else
                 {
                     SocExplorerEngine::message(this->plugin,"Device set to be an interface",1);
                 }
                 USBSpaceWire_RegisterReceiveOnAllPorts(hDevice);    // Register to receive on all ports
                 USBSpaceWire_ClearEndpoints(hDevice);               // clear the USB endpoints
                 USBSpaceWire_SetTimeout(hDevice,1.0);
                 SocExplorerEngine::message(this->plugin,"The driver's current send buffer size is " + QString::number(USBSpaceWire_GetDriverSendBufferSize(hDevice)) + " bytes",1);
                 SocExplorerEngine::message(this->plugin,"The driver's current read buffer size is " + QString::number(USBSpaceWire_GetDriverReadBufferSize(hDevice)) + " bytes",1);
                 SocExplorerEngine::message(this->plugin,"USBSpaceWire_IsReadThrottling is " + QString::number(USBSpaceWire_IsReadThrottling(hDevice)),1);
                 this->connected = true;
                 return true;
             }
             bool stardundeeSPW_USB_Manager::disconnectBridge()
             {
                 this->handleMutex->lock();
                 USBSpaceWire_Close(hDevice); // Close the device
                 SocExplorerEngine::message(this->plugin,"stardundee *** Close *** USBSpaceWire_Close, device: " + QString::number(0),0);
                 USBSpaceWire_UnregisterReceiveOnAllPorts(hDevice);  // Stop receiving on all ports
                 this->handleMutex->unlock();
                 this->RMAP_pending_transaction_IDsMtx->lock();
                 this->RMAP_pending_transaction_IDs.clear();
                 this->RMAP_pending_transaction_IDsMtx->unlock();
                 this->RMAP_AnswersMtx->lock();
                 this->RMAP_Answers.clear();
                 this->RMAP_AnswersMtx->unlock();
                 this->RMAP_AnswersSem->acquire(this->RMAP_AnswersSem->available());
                 return true;
             }
             int stardundeeSPW_USB_Manager::getRMAPtransactionID()
             {
                 this->RMAP_pending_transaction_IDsMtx->lock();
                 int  ID=0;
                 bool found=true;
                 while(ID<511)
                 {
                     for(int i=0;i<RMAP_pending_transaction_IDs.count();i++)
                     {
                         if(RMAP_pending_transaction_IDs[i]==ID)found=false;
                     }
                     if(found==true)break;
                     ID++;
                     found = true;
                 }
                 if(found)
                 {
                     RMAP_pending_transaction_IDs.append(ID);
                 }
                 this->RMAP_pending_transaction_IDsMtx->unlock();
                 return ID;
             }
             int stardundeeSPW_USB_Manager::getRMAPanswer(int transactionID, char **buffer)
             {
                 QTime timeout;
                 *buffer=NULL;
                 int count=0;
                 SocExplorerEngine::message(this->plugin,"Looking for RMAP answer",2);
                 timeout.start();
                 while (*buffer==NULL)
                 {
                     this->RMAP_AnswersMtx->lock();
                     SocExplorerEngine::message(this->plugin,"Got exclusive access on RMAP_Answers stack",2);
                     SocExplorerEngine::message(this->plugin,QString("%1 packet(s) available in RMAP_Answers stack").arg(RMAP_Answers.count()),2);
                     for(int i=0;i<RMAP_Answers.count();i++)
                     {
                         SocExplorerEngine::message(this->plugin,QString("Packet %1 ID=%2").arg(i).arg(RMAP_Answers[i]->transactionID),2);
                         if(RMAP_Answers[i]->transactionID==transactionID)
                         {
                             this->RMAP_pending_transaction_IDsMtx->lock();
                             SocExplorerEngine::message(this->plugin,"Got exclusive access on RMAP_pending_transaction_ID stack",2);
                             for(int j=0;j<RMAP_pending_transaction_IDs.count();j++)
                             {
                                 if(RMAP_pending_transaction_IDs[j]==transactionID)
                                 {
                                     RMAP_pending_transaction_IDs.removeAt(j);
                                 }
                             }
                             this->RMAP_pending_transaction_IDsMtx->unlock();
                             *buffer = RMAP_Answers[i]->data;
                             count = RMAP_Answers[i]->len;
                             RMAP_Answer* tmp=RMAP_Answers[i];
                             RMAP_Answers.removeAt(i);
                             delete tmp;
                         }
                     }
                     this->RMAP_AnswersMtx->unlock();
                     //if no answer found in the stack wait until a new packet is pushed
                     SocExplorerEngine::message(this->plugin,"waiting until a new packet is pushed",2);
                     if(*buffer==NULL)
                     {
                         while (0==this->RMAP_AnswersSem->available())
                         {
                             SocExplorerEngine::message(this->plugin,QString("this->RMAP_AnswersSem->available() = %1").arg(this->RMAP_AnswersSem->available()),2);
                             if(timeout.elapsed()>=RMAPtimeout)
                             {
                                 SocExplorerEngine::message(this->plugin,"Timeout reached giving up!",2);
                                 return -1;
                             }
                             usleep(1000);
                         }
                         this->RMAP_AnswersSem->acquire();
                     }
                 }
                 return count;
             }
             bool stardundeeSPW_USB_Manager::sendPacket(char *packet, int size)
             {
                 USB_SPACEWIRE_STATUS result;
                 USB_SPACEWIRE_ID pIdentifier;
                 SocExplorerEngine::message(this->plugin,"Sending SPW packet",2);
                 this->handleMutex->lock();
                 result = USBSpaceWire_SendPacket(hDevice,packet,size,1, &pIdentifier);
                 if (result != TRANSFER_SUCCESS)
                 {
                     SocExplorerEngine::message(this->plugin,"ERR sending the READ command ",2);
                     this->handleMutex->unlock();
                     return false;
                 }
                 else
                 {
                     SocExplorerEngine::message(this->plugin,"Packet sent",2);
                     USBSpaceWire_FreeSend(hDevice, pIdentifier);
                 }
                 this->handleMutex->unlock();
                 return true;
             }
             void stardundeeSPW_USB_Manager::pushRmapPacket(char *packet, int len)
             {
                 char* packetbuffer = (char*)malloc(len);
                 memcpy(packetbuffer,packet,len);
                 RMAP_Answer* RMPAPpacket=new RMAP_Answer(RMAP_get_transactionID(packetbuffer+1),packetbuffer,len);
                 RMAP_AnswersMtx->lock();
                 RMAP_Answers.append(RMPAPpacket);
                 RMAP_AnswersMtx->unlock();
             }

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