HG_REPOSITORIES/LPP/INSTRUMENTATION/SocExplorerPlugins Commit - r21:4db1f259222a

Sync

jeandet -

r21:4db1f259222a default

parent child

Context file:

r21:4db1f259222a

Collapse all files

spwplugin/SpwTcpPacketServer/spwtcppacketserver.cpp +7 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 "spwtcppacketserver.h"
             #include "ui_spwtcppacketserver.h"
             #include <QNetworkInterface>
             #include <QByteArray>
             SpwTcpPacketServer::SpwTcpPacketServer(QWidget *parent) :
                 QWidget(parent),
                 ui(new Ui::SpwTcpPacketServer)
             {
                 ui->setupUi(this);
                 this->p_bridge = NULL;
                 this->p_server = new QTcpServer();
                 connect(this->ui->startServeQpb,SIGNAL(clicked(bool)),SLOT(toggleServer()));
                 updateHostIP();
                 this->ui->PortLineEdit->setText("2200");
+                connect(this->p_server,SIGNAL(newConnection()),this,SLOT(newConnection()));
             }
             SpwTcpPacketServer::~SpwTcpPacketServer()
             {
                 delete ui;
             }
             void SpwTcpPacketServer::setBridge(abstractSpwBridge *bridge)
             {
                 if(this->p_bridge!=NULL)
                 {
                     disconnect(this,SLOT(pushPacket(char*,int)));
                 }
                 this->p_bridge = bridge;
                 connect(bridge,SIGNAL(pushPacketOverTCP(char*,int)),SLOT(pushPacket(char*,int)));
             }
             void SpwTcpPacketServer::pushPacket(char *packet, int size)
             {
                 QByteArray data;
                 char sizech[3];
                 data.append((char)0);
                 sizech[0]=size & 0x0FF;
                 sizech[1]=(size>>8) & 0x0FF;
                 sizech[2]=(size>>16) & 0x0FF;
                 data.append(sizech,3);
                 data.append(packet,size);
                 for(int i=0;i<connectedClients.count();i++)
                 {
                     QTcpSocket* soc=connectedClients.at(i);
                     if(soc->state()!=QAbstractSocket::ConnectedState)
                     {
                         connectedClients.removeAt(i);
                         delete soc;
                     }
                     else
                     {
                         connectedClients.at(i)->write(data);
                     }
                 }
             }
             void SpwTcpPacketServer::toggleServer()
             {
                 if(this->p_server->isListening())
                 {
                    disconnectServer();
                 }
                 else
                 {
                     connectServer();
                 }
             }
             void SpwTcpPacketServer::connectServer()
             {
                 this->p_server->listen(QHostAddress::Any,this->ui->PortLineEdit->text().toInt());
                 this->ui->startServeQpb->setText("Stop Server");
             }
             void SpwTcpPacketServer::disconnectServer()
             {
                 this->ui->startServeQpb->setText("Start Server");
                 this->p_server->close();
             }
             void SpwTcpPacketServer::setServerPort(qint32 port)
             {
                 this->ui->PortLineEdit->setText(QString("%1").arg(port));
             }
+            void SpwTcpPacketServer::setServerSetIP(QString ip)
+            {
+                this->ui->IPLineEdit->setText(ip);
+            }
             void SpwTcpPacketServer::newConnection()
             {
                 this->connectedClients.append(this->p_server->nextPendingConnection());
+                this->ui->listWidget->addItem(this->connectedClients.last()->peerAddress().toString());
             }
             void SpwTcpPacketServer::updateHostIP()
             {
                 QList<QHostAddress> list = QNetworkInterface::allAddresses();
                 for(int nIter=0; nIter<list.count(); nIter++)
                 {
                     if(!list[nIter].isLoopback())
                         if (list[nIter].protocol() == QAbstractSocket::IPv4Protocol )
                             this->ui->IPLineEdit->setText(list[nIter].toString());
                 }
             }

spwplugin/SpwTcpPacketServer/spwtcppacketserver.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 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@member.fsf.org
             ----------------------------------------------------------------------------*/
             #ifndef SPWTCPPACKETSERVER_H
             #define SPWTCPPACKETSERVER_H
             #include <QWidget>
             #include <abstractspwbridge.h>
             #include <QTcpServer>
             #include <QList>
             #include <QTcpSocket>
             namespace Ui {
             class SpwTcpPacketServer;
             }
             class SpwTcpPacketServer : public QWidget
             {
                 Q_OBJECT
             public:
                 explicit SpwTcpPacketServer(QWidget *parent = 0);
                 ~SpwTcpPacketServer();
                 void setBridge(abstractSpwBridge* bridge);
             public slots:
                 void pushPacket(char* packet,int size);
                 void toggleServer();
                 void connectServer();
                 void disconnectServer();
                 void setServerPort(qint32 port);
+                void setServerSetIP(QString ip);
                 void newConnection();
             private:
                 void updateHostIP();
                 Ui::SpwTcpPacketServer *ui;
                 abstractSpwBridge* p_bridge;
                 QTcpServer* p_server;
                 QList<QTcpSocket*> connectedClients;
             };
             #endif // SPWTCPPACKETSERVER_H

spwplugin/spwplugin.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 "spwplugin.h"
             #include "stardundeespw_usb.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->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->mainGroupBox->setLayout(this->mainLayout);
                 this->setWidget(this->mainTabWidgt);
                 this->bridgeSelector->addItem("none");
                 this->bridgeSelector->addItem("STAR-Dundee Spw USB Brick");
                 connect(this->bridgeSelector,SIGNAL(currentIndexChanged(QString)),this,SLOT(bridgeSelectionChanged(QString)));
                 connect(((spwPyWrapper*)this->pyObject),SIGNAL(selectBridge(QString)),this,SLOT(selectBridge(QString)));
                 connect(((spwPyWrapper*)this->pyObject),SIGNAL(TCPServerConnect()),this->tcpServer,SLOT(connectServer()));
                 connect(((spwPyWrapper*)this->pyObject),SIGNAL(TCPServerDisconnect()),this->tcpServer,SLOT(disconnectServer()));
                 connect(((spwPyWrapper*)this->pyObject),SIGNAL(TCPServerSetPort(qint32)),this->tcpServer,SLOT(setServerPort(qint32)));
+                connect(((spwPyWrapper*)this->pyObject),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(((spwPyWrapper*)this->pyObject),SIGNAL(StarDundeeSelectLinkNumber(int)),((stardundeeSPW_USB*)bridge),SIGNAL(SelectLinkNumber(int)));
                     connect(((spwPyWrapper*)this->pyObject),SIGNAL(StarDundeeSelectLinkSpeed(int)),((stardundeeSPW_USB*)bridge),SIGNAL(SelectLinkSpeed(int)));
                     connect(((spwPyWrapper*)this->pyObject),SIGNAL(StarDundeeSetDestinationKey(QString)),((stardundeeSPW_USB*)bridge),SIGNAL(SetDestinationKey(QString)));
                     connect(((spwPyWrapper*)this->pyObject),SIGNAL(StarDundeeSetRmapAddress(QString)),((stardundeeSPW_USB*)bridge),SIGNAL(SetRmapAddress(QString)));
                     connect(((spwPyWrapper*)this->pyObject),SIGNAL(StarDundeeSetRmapKey(QString)),((stardundeeSPW_USB*)bridge),SIGNAL(SetRmapKey(QString)));
                     connect(((spwPyWrapper*)this->pyObject),SIGNAL(StarDundeeSetRmapTimeout(QString)),((stardundeeSPW_USB*)bridge),SIGNAL(SetRmapTimeout(QString)));
                     connect(((spwPyWrapper*)this->pyObject),SIGNAL(connectBridge()),((stardundeeSPW_USB*)bridge),SLOT(connectBridge()));
                     connect(((spwPyWrapper*)this->pyObject),SIGNAL(disconnectBridge()),((stardundeeSPW_USB*)bridge),SLOT(disconnectBridge()));
                 }
             }
             void spwplugin::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/spwpywrapper.h +1 0

             #ifndef SPWPYWRAPPER_H
             #define SPWPYWRAPPER_H
             #include <genericPySysdriver.h>
             class spwPyWrapper : public genericPySysdriver
             {
                 Q_OBJECT
             public:
                 explicit spwPyWrapper(socexplorerplugin *parent = 0);
             signals:
                 void selectBridge(const QString &bridgeName);
                 bool connectBridge();
                 bool disconnectBridge();
                 void StarDundeeSelectBrick(int brickIndex);
                 void StarDundeeSelectLinkNumber(int linkIndex);
                 void StarDundeeSelectLinkSpeed(int linkSpeed);
                 void StarDundeeSetDestinationKey(const QString & destKey);
                 void StarDundeeSetRmapAddress(const QString & address);
                 void StarDundeeSetRmapKey(const QString & key);
                 void StarDundeeSetRmapTimeout(const QString & timeout);
                 void TCPServerConnect();
                 void TCPServerDisconnect();
                 void TCPServerSetPort(qint32 port);
+                void TCPServerSetIP(QString ip);
             public slots:
             };
             #endif // SPWPYWRAPPER_H

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages