HG_REPOSITORIES/LPP/INSTRUMENTATION/SocExplorerPlugins Commit - r32:4c8d1b562d91

Improved APB UART Plugin, now check how many bytes are available on uart...

jeandet -

r32:4c8d1b562d91 default

parent child

Context file:

r32:4c8d1b562d91

Collapse all files

APBUARTPLUGIN/apbuart_plugin_ui.cpp +36 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
             ----------------------------------------------------------------------------*/
             #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(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)));
+                connect(this->ui->rescanQpb,SIGNAL(clicked()),this,SLOT(updatePortList()));
+                this->portListcompleter = NULL;
+                this->updatePortList();
             }
             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");
                 }
             }
+            #include <RS232.h>
+            void APBUART_Plugin_ui::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->PortNameLineEdit->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);
+            }

APBUARTPLUGIN/apbuart_plugin_ui.h +5 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 APBUART_PLUGIN_UI_H
             #define APBUART_PLUGIN_UI_H
             #include <QWidget>
+            #include <QCompleter>
+            #include <QStringListModel>
             namespace Ui {
             class APBUART_Plugin_ui;
             }
             class APBUART_Plugin_ui : public QWidget
             {
                 Q_OBJECT
             public:
                 explicit APBUART_Plugin_ui(QWidget *parent = 0);
                 ~APBUART_Plugin_ui();
             public slots:
                 void setEnableForLoopBack(bool enable);
                 void setUartConnected(bool enable);
+                void updatePortList();
             signals:
                 void loopbackChkBxStateChanged( int state );
                 void apbUartTextReceived(QString text);
                 void connectPort();
                 void sendChar(char c);
                 void UartSpeedChanged(QString text);
                 void PortNameChanged(QString text);
             private:
                 Ui::APBUART_Plugin_ui *ui;
+                QCompleter *portListcompleter;
+                QStringListModel *portListcompleterModel;
             };
             #endif // APBUART_PLUGIN_UI_H

APBUARTPLUGIN/apbuart_plugin_ui.ui +11 -4

             <?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>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>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">
+                   <item row="1" column="2">
+                    <widget class="QPushButton" name="rescanQpb">
+                     <property name="text">
+                      <string>Rescan ports</string>
+                     </property>
+                    </widget>
+                   </item>
+                   <item row="3" column="1" colspan="2">
+                    <widget class="QLineEdit" name="UartSpeedLineEdit"/>
+                   </item>
+                   <item row="4" column="1" colspan="2">
                     <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/uartpollingthread.cpp +23 -7

             /*------------------------------------------------------------------------------
             --  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()
             {
+                char ch[4097];
+                int timeout =10;
                 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;
+                        int read =0,avail=0;
-                        char ch[1];
                         uartMutex->lock();
                         if(uartOpened)
                         {
-                            read =rs232read(this->uart,ch,1);
+                            avail = rs232availablebytes(this->uart);
-                            SocExplorerEngine::message(this->plugin,QString("Read %1 bytes on uart").arg(read),3);
+                            SocExplorerEngine::message(this->plugin,QString("%1 available bytes on uart").arg(read),3);
+                            if(avail)
+                            {
+                                if(avail>=4096)
+                                {
+                                    read = rs232read(this->uart,ch,4096);
+                                    timeout = 0;
+                                }
+                                else
+                                {
+                                    read = rs232read(this->uart,ch,avail);
+                                    timeout = 10;
+                                }
+                                SocExplorerEngine::message(this->plugin,QString("Read %1 bytes on uart").arg(read),3);
+                                ch[read]='\0';
+                            }
                         }
                         uartMutex->unlock();
                         if(read>=1)
                         {
-                            SocExplorerEngine::message(this->plugin,QString("Received one char from APBUART"),3);
+                                SocExplorerEngine::message(this->plugin,QString("Received %1 char(s) from APBUART").arg(read),3);
-                            emit this->apbUartTextReceived(QString(ch[0]));
+                                emit this->apbUartTextReceived(QString(ch));
                         }
-                        msleep(10);
+                        msleep(timeout);
                     }
                 }
             }
             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;
                     }
                 }
             }

memcheckplugin/memchecker.cpp +9 -8

             /*------------------------------------------------------------------------------
             --  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@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #include "memchecker.h"
             memchecker::memchecker(socexplorerplugin* plugin)
             {
                 this->plugin = plugin;
             }
-            bool memchecker::checkmemory(unsigned int address,unsigned int size)
+            QString memchecker::checkmemory(unsigned int address, unsigned int size, bool *success)
             {
-                bool success = true;
+                *success = true;
+                QString repport;
                 unsigned int* dataLocal = (unsigned int*)malloc(size);
                 unsigned int* dataOnBoard = (unsigned int*)malloc(size);
                 for(int i=0;(unsigned int)i<(size>>2);i++)
                 {
                     dataLocal[i]= (0xFFFF&rand())+(rand()<<16);
                 }
                 plugin->Write(dataLocal,size>>2,address);
                 plugin->Read(dataOnBoard,size>>2,address);
                 for(int i=0;(unsigned int)i<(size>>2);i++)
                 {
                     if(dataLocal[i]!=dataOnBoard[i])
-                        success=false;
+                        *success=false;
                 }
                 free(dataLocal);
                 free(dataOnBoard);
-                return success;
+                return repport;
             }
-            bool memchecker::checkdatabits(unsigned int address,unsigned int size)
+            QString memchecker::checkdatabits(unsigned int address,unsigned int size,bool* success)
             {
-                bool success = true;
+                *success = true;
-                return success;
+                QString repport;
+                return repport;
             }

memcheckplugin/memchecker.h +2 -2

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2014, Plasma Physics Laboratory - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #ifndef MEMCHECKER_H
             #define MEMCHECKER_H
             #include <socexplorerplugin.h>
             class memchecker
             {
             public:
                 memchecker(socexplorerplugin* plugin);
-                bool checkmemory(unsigned int address,unsigned int size);
+                QString checkmemory(unsigned int address,unsigned int size,bool* success);
-                bool checkdatabits(unsigned int address,unsigned int size);
+                QString checkdatabits(unsigned int address,unsigned int size,bool* success);
             private:
                 socexplorerplugin* plugin;
             };
             #endif // MEMCHECKER_H

memcheckplugin/memcheckplugin.cpp +14 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2011, Plasma Physics Laboratory - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #include "memcheckplugin.h"
             memcheckplugin::memcheckplugin(QWidget *parent):socexplorerplugin(parent,true)
             {
                 this->UI = new memcheckplugin_ui();
                 this->setWidget(this->UI);
                 this->checker = new memchecker(this);
+                QObject::connect(this->UI,SIGNAL(checkdatabits(uint,uint)),this,SLOT(checkdatabits(uint,uint)));
+                QObject::connect(this->UI,SIGNAL(checkmemory(uint,uint)),this,SLOT(checkmemory(uint,uint)));
             }
             memcheckplugin::~memcheckplugin()
             {}
-            void memcheckplugin::startCheck()
+            void memcheckplugin::checkmemory(unsigned int address, unsigned int size)
             {
+                bool success;
+                QString repport=this->checker->checkmemory(address,size,&success);
+                this->UI->setResult(success,repport);
             }
+            void memcheckplugin::checkdatabits(unsigned int address, unsigned int size)
+            {
+                bool success;
+                QString repport=this->checker->checkdatabits(address,size,&success);
+                this->UI->setResult(success,repport);
+            }

memcheckplugin/memcheckplugin.h +2 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2011, Plasma Physics Laboratory - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #ifndef MEMCTRLRPLUGIN_H
             /*------------------------------------------------------------------------------
             --  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@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #define MEMCTRLRPLUGIN_H
             #include "memcheckplugin_ui.h"
             #include <QMenuBar>
             #include <QMenu>
             #include <QAction>
             #include <QMainWindow>
             #include <socexplorerplugin.h>
             #include <memchecker.h>
             #include <socexplorerplugin.h>
             class memcheckplugin : public socexplorerplugin
             {
                 Q_OBJECT
             public:
                 explicit memcheckplugin(QWidget *parent = 0);
                 ~memcheckplugin();
             public slots:
-                void startCheck();
+                void checkmemory(unsigned int address,unsigned int size);
+                void checkdatabits(unsigned int address,unsigned int size);
             signals:
             private:
                 memcheckplugin_ui* UI;
                 memchecker* checker;
             };
             #endif // MEMCTRLRPLUGIN_H

memcheckplugin/memcheckplugin_ui.cpp +13 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@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #include "memcheckplugin_ui.h"
             #include "ui_memcheckplugin_ui.h"
             #include <memsizewdgt.h>
             #include <qhexspinbox.h>
             memcheckplugin_ui::memcheckplugin_ui(QWidget *parent) :
                 QWidget(parent),
                 ui(new Ui::memcheckplugin_ui)
             {
                 ui->setupUi(this);
                 connect(this->ui->StartTestQpb,SIGNAL(clicked()),this,SLOT(startCheck()));
             }
             memcheckplugin_ui::~memcheckplugin_ui()
             {
                 delete ui;
             }
             void memcheckplugin_ui::startCheck()
             {
                 if(this->ui->testTypeQchkBx->currentText()=="Check data bits")
                 {
                     emit checkdatabits(this->ui->StartAddress->value(),this->ui->MemSize->getsize());
                 }
                 if(this->ui->testTypeQchkBx->currentText()=="Check memory size")
                 {
                     emit checkmemory(this->ui->StartAddress->value(),this->ui->MemSize->getsize());
                 }
                 if(this->ui->testTypeQchkBx->currentText()=="Full test")
                 {
                 }
             }
+            void memcheckplugin_ui::setResult(bool success, QString repport)
+            {
+                this->ui->testDetails->setText(repport);
+                if(success)
+                {
+                    this->ui->TestResult->setText("Success");
+                }
+                else
+                {
+                    this->ui->TestResult->setText("Failed");
+                }
+            }

memcheckplugin/memcheckplugin_ui.h +3 -2

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2014, Plasma Physics Laboratory - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #ifndef MEMCHECKPLUGIN_UI_H
             #define MEMCHECKPLUGIN_UI_H
             #include <QWidget>
             namespace Ui {
             class memcheckplugin_ui;
             }
             class memcheckplugin_ui : public QWidget
             {
                 Q_OBJECT
             public:
                 explicit memcheckplugin_ui(QWidget *parent = 0);
                 ~memcheckplugin_ui();
             public slots:
                 void startCheck();
+                void setResult(bool success,QString repport);
             signals:
-                bool checkmemory(unsigned int address,unsigned int size);
+                void checkmemory(unsigned int address,unsigned int size);
-                bool checkdatabits(unsigned int address,unsigned int size);
+                void checkdatabits(unsigned int address,unsigned int size);
             private:
                 Ui::memcheckplugin_ui *ui;
             };
             #endif // MEMCHECKPLUGIN_UI_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