HG_REPOSITORIES/LPP/INSTRUMENTATION/SOLO_LFR/LPPMON_PLUGINS_PAUL Commit - r63:3581c05019b0

Ajout d'un paramètre à la fonction sendTimecodePeriodically()...

leroy -

r63:3581c05019b0 default

parent child

Context file:

r63:3581c05019b0

rmapplugin/rmapplugin.cpp +2 -6

             /*------------------------------------------------------------------------------
             --  This file is a part of the LPPMON Software
             --  Copyright (C) 2012, Laboratory of Plasma Physics - 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 : Paul LEROY
             --                     Mail : paul.leroy@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #include "rmapplugin.h"
             #include <QHostAddress>
             #include <QIODevice>
             #include <QApplication>
             #include <rmappluginpythonwrapper.h>
             #include <PythonQt.h>
             #include <QTimer>
             #include <lppmonproxy.h>
             rmapplugin::rmapplugin(QWidget *parent)
               :lppmonplugin(parent,false)
             {
                 this->UI = new rmapPluginUI();
                 this->setWindowTitle(tr("RMAP and SPW Communication"));
                 this->setWidget((QWidget*)this->UI);
                 scanDone = false;
                 timeCode = 0;
                 time_COARSE = 0;
                 time_FINE = 0;
                 currentBridge = selectedBridgeIsUnknown;
                 connectPythonWrapper();
                 //**************
                 // get a smart pointer to the __main__ module of the Python interpreter
                 PythonQtObjectPtr context = PythonQt::self()->getMainModule();
                 // add a QObject as variable of name "BUTTON_rmapOpenCommunication" to the namespace of the __main__ module
                 context.addObject("BUTTON_rmapOpenCommunication", UI->rmapOpenCommunicationButton);
                 context.addObject("BUTTON_rmapCloseCommunication", UI->rmapCloseCommunicationButton);
                 context.addObject("BUTTON_selectStarDundee", UI->selectStarDundee_BUTTON);
                 context.addObject("BUTTON_selectGRESB", UI->selectGRESB_BUTTON);
                 context.addObject("GRESB_Bridge", UI->gresbBridge);
                 //**************
                 connect(UI->rmapOpenCommunicationButton, SIGNAL(clicked()), this, SLOT(openBridge()));
                 connect(UI->rmapCloseCommunicationButton, SIGNAL(clicked()), this, SLOT(closeBridge()));
                 connect(this, SIGNAL(
                             updateStatistics(unsigned char,unsigned char,unsigned char,unsigned char,uint,uint,uint,uint)
                             ),
                         this->UI->tmStatistics, SLOT(
                             updateStatistics(unsigned char,unsigned char,unsigned char,unsigned char,uint,uint,uint,uint)
                             ));
                 //******
                 // GRESB
                 connect(this->UI->gresbBridge, SIGNAL(sendMessage(QString)), this, SLOT(displayOnConsole(QString)));
                 connect(this->UI->gresbBridge, SIGNAL(RMAP_write_reply_setText(QString)), this, SLOT(RMAP_write_reply_setText(QString)));
                 connect(this->UI->gresbBridge, SIGNAL(appendToLog(QString)), this, SLOT(appendToLog(QString)));
                 connect(this, SIGNAL(ccsdsPacketIsProcessed()), this->UI->gresbBridge, SLOT(ccsdsPacketIsProcessed()));
                 connect(this->UI->rmapTargetLogicalAddressSpinBox, SIGNAL(valueChanged(int)),
                         this->UI->gresbBridge, SLOT(targetHasChanged(int)));
                 connect(this->UI->rmapSourceLogicalAddressSpinBox, SIGNAL(valueChanged(int)),
                         this->UI->gresbBridge, SLOT(sourceHasChanged(int)));
                 connect(this->UI->gresbBridge, SIGNAL(sendPacket(TMPacketToRead*)),
                         this, SLOT(receivePacketFromBridge(TMPacketToRead*)), Qt::DirectConnection);
                 //************
                 // Star Dundee
                 connect(this->UI->starDundee, SIGNAL(sendMessage(QString)), this, SLOT(displayOnConsole(QString)));
                 connect(this->UI->starDundee, SIGNAL(RMAP_write_reply_setText(QString)), this, SLOT(RMAP_write_reply_setText(QString)));
                 connect(this->UI->starDundee, SIGNAL(appendToLog(QString)), this, SLOT(appendToLog(QString)));
                 connect(this, SIGNAL(ccsdsPacketIsProcessed()), this->UI->starDundee, SLOT(ccsdsPacketIsProcessed()));
                 connect(this->UI->rmapTargetLogicalAddressSpinBox, SIGNAL(valueChanged(int)),
                         this->UI->starDundee, SLOT(targetHasChanged(int)));
                 connect(this->UI->rmapSourceLogicalAddressSpinBox, SIGNAL(valueChanged(int)),
                         this->UI->starDundee, SLOT(sourceHasChanged(int)));
                 connect(this, SIGNAL(spaceWireLinkNumberHasChanged(unsigned char)),
                         this->UI->starDundee, SLOT(spaceWireLinkHasChanged(unsigned char)), Qt::DirectConnection);
                 connect(this->UI->starDundee, SIGNAL(sendPacket(TMPacketToRead*)),
                         this, SLOT(receivePacketFromBridge(TMPacketToRead*)), Qt::DirectConnection);
                 connect(this->UI, SIGNAL(bridgeHasChanged(selectedBridge)), this, SLOT(bridgeHasChanged(selectedBridge)));
                 ((rmappluginPythonWrapper*)this->pyObject)->ccsdsPacketStore = &(this->generalCCSDSPacketStore);
                 //************
                 // LFR ACtions
                 connect(this->UI->lfrActions, SIGNAL(WriteSPWSig(char*,uint,char,char)),
                         this, SLOT(WriteSPW(char*,uint,char,char)));
             }
             rmapplugin::~rmapplugin()
             {
                 switch(currentBridge)
                 {
                 case selectedBridgeIsGRESB :
                     this->UI->gresbBridge->writeSettings();
                     break;
                 case selectedBridgeIsStarDundee :
                     break;
                 default:
                     break;
                 }
                 this->UI->tmStatistics->writeSettings();
             }
             unsigned int rmapplugin::Write(unsigned int *Value, unsigned int count, unsigned int address)
             {
                 unsigned int result;
                 switch(currentBridge)
                 {
                 case selectedBridgeIsGRESB :
                     result = UI->gresbBridge->Write(Value, count, address);
                     break;
                 case selectedBridgeIsStarDundee :
                     result = UI->starDundee->Write(Value, count, address);
                     break;
                 default:
                     result = 1;
                     break;
                 }
                 return result;
             }
             unsigned int rmapplugin::Read(unsigned int *Value, unsigned int count, unsigned int address)
             {
                 unsigned int result;
                 switch(currentBridge)
                 {
                 case selectedBridgeIsGRESB :
                     result = UI->gresbBridge->Read(Value, count, address);
                     break;
                 case selectedBridgeIsStarDundee :
                     result = UI->starDundee->Read(Value, count, address);
                     break;
                 default:
                     result = 1;
                     break;
                 }
                 return result;
             }
             ////////
             // SLOTS
             unsigned int rmapplugin::WriteSPW(char *Value, unsigned int count, char targetLogicalAddress, char userApplication) // SLOT
             {
                 unsigned int result;
                 switch(currentBridge)
                 {
                 case selectedBridgeIsGRESB :
                     result = UI->gresbBridge->WriteSPW(Value, count, targetLogicalAddress, userApplication);
                     break;
                 case selectedBridgeIsStarDundee :
                     result = UI->starDundee->WriteSPW(Value, count, targetLogicalAddress, userApplication);
                     break;
                 default:
                     result = 1;
                     break;
                 }
                 return result;
             }
             void rmapplugin::openBridge()
             {
                 switch(currentBridge)
                 {
                 case selectedBridgeIsGRESB :
                     this->Connected = this->UI->gresbBridge->Open();
                     break;
                 case selectedBridgeIsStarDundee :
                     this->Connected = this->UI->starDundee->Open();
                     break;
                 default:
                     break;
                 }
                 if((this->scanDone==false)&&(this->Connected == true))
                 {
                     lppmonproxy::loadChildSysDriver(this,"AMBA_PLUGIN");
                     this->scanDone=true;
                 }
                 emit activateSig( this->Connected );
             }
             void rmapplugin::closeBridge()
             {
                 switch(currentBridge)
                 {
                 case selectedBridgeIsGRESB :
                     this->UI->gresbBridge->Close();
                     break;
                 case selectedBridgeIsStarDundee :
                     this->UI->starDundee->Close();
                     break;
                 default:
                     break;
                 }
                 this->Connected = false;
                 emit activateSig( this->Connected );
             }
             void rmapplugin::RMAP_write_reply_setText(QString text)
             {
                 this->UI->RMAP_write_reply->setText(text);
             }
             void rmapplugin::appendToLog(QString text)
             {
                 APPENDTOLOG(text);
             }
             void rmapplugin::setValueTargetAddress(unsigned char newAddress)
             {
                 this->UI->rmapTargetLogicalAddressSpinBox->setValue(newAddress);
             }
             void rmapplugin::setValueSourceAddress(unsigned char newAddress)
             {
                 this->UI->rmapSourceLogicalAddressSpinBox->setValue(newAddress);
             }
             void rmapplugin::setValueSpaceWireLinkNumber(unsigned char linkNumber)
             {
             //    this->UI->spwLinkSpinBox->setValue( linkNumber );
                 emit this->spaceWireLinkNumberHasChanged( linkNumber );
             }
             void rmapplugin::receivePacketFromBridge(TMPacketToRead *packet)
             {
                 preProcessPacket(packet);
                 // Send the packet to the TM echo bridge for processing
                 this->UI->tmEchoBridge->sendTMPacketLESIA(packet);
                 this->generalCCSDSPacketStore.append(packet);
                 if (this->generalCCSDSPacketStore.size() > 200)
                 {
                     this->generalCCSDSPacketStore.erase(generalCCSDSPacketStore.begin(),
                                                         generalCCSDSPacketStore.begin() + 100);
                 }
                 this->UI->nbPacketInStore->setText("nb packets in store: " + QString::number(generalCCSDSPacketStore.size()));
                 processPacketStore();
             }
             void rmapplugin::preProcessPacket(TMPacketToRead *packet)
             {
                 unsigned char pid = 0;
                 unsigned char cat = 0;
                 unsigned char typ = 0;
                 unsigned char sub = 0;
                 unsigned int sid = 0;
                 unsigned int length = 0;
                 unsigned int coarse_t = 0;
                 unsigned int fine_t = 0;
                 //*********************************
                 // get the parameters of the packet
                 pid         = this->UI->tmStatistics->getPID( packet );
                 cat         = this->UI->tmStatistics->getCAT( packet );
                 typ         = this->UI->tmStatistics->getTYPE( packet );
                 sub         = this->UI->tmStatistics->getSUBTYPE( packet );
                 length      = this->UI->tmStatistics->getLENGTH( packet );
                 coarse_t    = this->UI->tmStatistics->getCoarseTime( packet );
                 fine_t      = this->UI->tmStatistics->getFineTime( packet );
                 sid         = this->UI->tmStatistics->getSID( packet, pid, cat, typ, sub );
                 emit updateStatistics(pid, cat, typ, sub, sid, length, coarse_t, fine_t);
                 //**********************************************
                 // if the packet is a parameter dump, display it
                 if ( (typ == TM_TYPE_PARAMETER_DUMP) & (sub == TM_SUBTYPE_PARAMETER_DUMP) & (sid == SID_PARAMETER_DUMP) )
                     this->UI->lfrActions->parameterDump->updateParameterDump(packet);
                 if ( (typ == TC_TYPE_TIME) & (sub == TC_SUBTYPE_UPDT_TIME) )    // RE-EMIT THE TC_LFR_UPDATE_TIME PACKET
                 {
                     emit spaceWireLinkNumberHasChanged( LFR_SPACEWIRE_LINK );
                     WriteSPW( (char *) &packet->Value[CCSDS_PROTOCOLE_EXTRA_BYTES],
                               packet->size - CCSDS_PROTOCOLE_EXTRA_BYTES,
                               DEFAULT_TARGET, CCSDS_USER_APP );
                 }
             }
             void rmapplugin::nbPacketHasChanged(int nb)
             {
                 this->UI->nbPacketInStore->setText("nb packets in store: " + QString::number(nb));
             }
             /////////////////////
             // INTERNAL FUNCTIONS
             void rmapplugin::processCCSDSPacket(unsigned char *ccsdsPacket, unsigned int size) // SLOT
             {
                 QString message;
                 unsigned int fine_time_value = 0;
                 fine_time_value = ((unsigned int) ccsdsPacket[7]<<24)
                         + ((unsigned int) ccsdsPacket[6]<<16)
                         + ((unsigned int) ccsdsPacket[5]<<8)
                         + ((unsigned int) ccsdsPacket[4]);
                 message.append(QTime::currentTime().toString() +":" + QString::number(QTime::currentTime().msec()) + ": ");
                 message.append("size "
                                + QString::number(size)
                                +" *** header "
                                + QString::number(ccsdsPacket[0], 16)
                                + " "
                                + QString::number(ccsdsPacket[1], 16)
                                + " "
                                + QString::number(ccsdsPacket[2], 16)
                                + " "
                                + QString::number(ccsdsPacket[3], 16)
                                + " *** coarse time "
                                + QString::number(fine_time_value));
                                //+ QString::number(ccsdsPacket[4], 16)
                                //+" "
                                //+ QString::number(ccsdsPacket[5], 16)
                                //+" "
                                //+ QString::number(ccsdsPacket[6], 16)
                                //+" "
                                //+ QString::number(ccsdsPacket[7], 16));
                 displayOnConsole(message);
                 //((rmappluginPythonWrapper*)this->pyObject)->storeCCSDSPacket(ccsdsPacket, size);
                 emit ccsdsPacketIsProcessed();
             }
             void rmapplugin::processPacketStore()
             {
                 ((rmappluginPythonWrapper*)this->pyObject)->processPacketStore();
             }
             int rmapplugin::fetchPacket()
             {
                 int ret = 0;
                 switch(currentBridge)
                 {
                 case selectedBridgeIsGRESB :
                     break;
                 case selectedBridgeIsStarDundee :
                     ret = this->UI->starDundee->receiveSPWPacketLoop();
                     break;
                 default:
                     break;
                 }
                 return ret;
             }
             void rmapplugin::connectPythonWrapper()
             {
                 this->pyObject = new rmappluginPythonWrapper();
                 connect( this->pyObject, SIGNAL( ReadSig(uint*,uint,uint) ), this, SLOT( Read(uint*,uint,uint) ) );
                 connect( this->pyObject, SIGNAL( WriteSig(uint*,uint,uint) ), this, SLOT( Write(uint*,uint,uint) ) );
                 //**
                 connect( (rmappluginPythonWrapper*)this->pyObject, SIGNAL( WriteSPWSig(char*,uint,char,char) ),
                         this, SLOT( WriteSPW(char*,uint,char,char) ), Qt::DirectConnection );
                 //**
                 connect( (rmappluginPythonWrapper*)this->pyObject, SIGNAL( updateTargetLogicalAddress(unsigned char) ),
                         this, SLOT( setValueTargetAddress(unsigned char) ) );
                 //**
                 connect( (rmappluginPythonWrapper*)this->pyObject, SIGNAL( updateSourceLogicalAddress(unsigned char) ),
                         this, SLOT( setValueSourceAddress(unsigned char) ) );
                 //**
                 connect( (rmappluginPythonWrapper*)this->pyObject, SIGNAL( updateSpaceWireLinkNumber(unsigned char) ),
                         this, SLOT( setValueSpaceWireLinkNumber(unsigned char) ) );
                 //**
                 connect( (rmappluginPythonWrapper*)this->pyObject, SIGNAL(sendMessage(QString)),
                          this, SLOT(displayOnConsole(QString)) );
                 //**
                 connect( (rmappluginPythonWrapper*)this->pyObject, SIGNAL(fetchPacketSig()),
                          this, SLOT(fetchPacket()), Qt::DirectConnection );
                 //***
                 connect( (rmappluginPythonWrapper*)this->pyObject, SIGNAL(nbPacketHasChanged(int)),
                          this, SLOT(nbPacketHasChanged(int)));
                 //**********
                 // TIMECODES
                 connect( (rmappluginPythonWrapper*)this->pyObject, SIGNAL(sig_sendOneTimecode()),
                          this->UI->starDundee, SLOT(sendOneTimecode()) );
-                connect( (rmappluginPythonWrapper*)this->pyObject, SIGNAL(sig_sendTimecodePeriodically()),
+                connect( (rmappluginPythonWrapper*)this->pyObject, SIGNAL(sig_sendTimecodePeriodically(unsigned char)),
-                         this->UI->starDundee, SLOT(sendTimecodePeriodically()) );
+                         this->UI->starDundee, SLOT(startSendingTimecodePeriodically(unsigned char)) );
-                connect( (rmappluginPythonWrapper*)this->pyObject, SIGNAL(sig_sendOneTimePacketAndOneTimecode()),
-                         this->UI->starDundee, SLOT(sendOneTimePacketAndOneTimecode()) );
-                connect( (rmappluginPythonWrapper*)this->pyObject, SIGNAL(sig_sendOneTimePacketAndTimecodePeriodically()),
-                         this->UI->starDundee, SLOT(sendOneTimePacketAndTimecodePeriodically()) );
             }

rmapplugin/rmappluginpythonwrapper.cpp +4 -2

             #include "rmappluginpythonwrapper.h"
             #include <math.h>
             #include <QApplication>
             rmappluginPythonWrapper::rmappluginPythonWrapper(lppmonplugin *parent) :
                 genericPySysdriver(parent)
             {
                 timer = new QTimer;
                 timer->setSingleShot(true);
                 connect(timer, SIGNAL(timeout()), this, SLOT(sendTC()));
                 connect(this, SIGNAL(activateTCLoopSig()), this, SLOT(sendTCLoop()));
             }
             QList<QVariant> rmappluginPythonWrapper::ReadSPW(unsigned int size) // size is not used
             {
                 QList<QVariant> result;
                 TMPacketToRead *ccsdsPacket;
                 if (!ccsdsPacketStore->isEmpty())
                 {
                     ccsdsPacket = ccsdsPacketStore->takeFirst();
                     for(unsigned int i = 0;i<ccsdsPacket->size;i++)
                     {
                         result.append((QVariant)ccsdsPacket->Value[i]);
                     }
                     delete(ccsdsPacket);
                 }
                 emit nbPacketHasChanged(ccsdsPacketStore->size());
                 return result;
             }
             void rmappluginPythonWrapper::WriteSPW(QList<int> dataList)
             {
                 char targetLogicalAddress;
                 char userApplication;
                 unsigned int count;
                 char *Value;
                 unsigned char data[dataList.count()];
                 for(int i = 0; i<dataList.count(); i++) // get the data as unsigned char
                 {
                     data[i] = (unsigned char)dataList.at(i);
                 }
                 // read the first bytes of the data to get the targetLogicalAddress and the userApplication parameters
                 targetLogicalAddress = data[0];
                 userApplication = data[3];
                 count = dataList.count() - 4; // the CCSDS header (4 bytes) is added by LPPMON
                 Value = (char*) &data[4];
                 emit WriteSPWSig(Value, count, targetLogicalAddress, userApplication);
             }
             void rmappluginPythonWrapper::WriteSPWDelay(QList<int> dataList, unsigned int delay)
             {
                 char targetLogicalAddress;
                 char userApplication;
                 unsigned int count;
                 char *Value;
                 TCPacketToSend *packet;
                 unsigned char data[dataList.count()];
                 for(int i = 0; i<dataList.count(); i++) // get the data as unsigned char
                 {
                     data[i] = (unsigned char)dataList.at(i);
                 }
                 // read the first bytes of the data to get the targetLogicalAddress and the userApplication parameters
                 targetLogicalAddress = data[0];
                 userApplication = data[3];
                 count = dataList.count() - 4; // the CCSDS header (4 bytes) is added by LPPMON
                 Value = (char*) &data[4];
                 packet = new TCPacketToSend(Value, count, targetLogicalAddress, userApplication, delay);
                 TCPacketStore.append(packet);
                 emit(activateTCLoopSig());
             }
             void rmappluginPythonWrapper::processPacketStoreLater(unsigned int delay)
             {
                 emit sendMessage(
                             "*** process packet store in " + QString::number(delay) + " ms"
                             );
                 QTimer::singleShot(delay, this, SLOT(sendProcessPacketStoreNowSig()));
             }
             void rmappluginPythonWrapper::sendTCLoop()
             {
                 unsigned int delay;
                 if (!timer->isActive())
                 {
                     if (!TCPacketStore.isEmpty())
                     {
                         delay = TCPacketStore.at(0)->delay;
                         timer->setInterval(delay);
                         timer->start();
                     }
                 }
             }
             void rmappluginPythonWrapper::sendTC()
             {
                 TCPacketToSend *packet;
                 unsigned int delay;
                 packet = TCPacketStore.takeFirst();
                 // the signal is connected with the option Qt::DirectConnection, thus it is processed immediately
                 emit(WriteSPWSig(packet->Value, packet->count,packet->targetLogicalAddress, packet->userApplication));
                 delete(packet);
                 if (!TCPacketStore.isEmpty())
                 {
                     delay = TCPacketStore.at(0)->delay;
                     timer->setInterval(delay);
                     timer->start();
                 }
             }
             void rmappluginPythonWrapper::processPacketStore()
             {
                 emit ccsdsPacketIsAvailable(ccsdsPacketStore->at(0)->size);
             }
             void rmappluginPythonWrapper::setValueTargetLogicalAddress(unsigned int address)
             {
                 unsigned char newAddress;
                 newAddress = (unsigned char) address;
                 emit updateTargetLogicalAddress(newAddress);
             }
             void rmappluginPythonWrapper::setValueSourceLogicalAddress(unsigned int address)
             {
                 unsigned char newAddress;
                 newAddress = (unsigned char) address;
                 emit updateSourceLogicalAddress(newAddress);
             }
             void rmappluginPythonWrapper::setValueSpaceWireLinkNumber(unsigned int linkNumber)
             {
                 unsigned char newLinkNumber;
                 newLinkNumber = (unsigned char) linkNumber;
                 emit updateSpaceWireLinkNumber(newLinkNumber);
             }
             void rmappluginPythonWrapper::ProcessPendingEvents()
             {
                 QCoreApplication::processEvents();
             }
             //*******************
             // TIMECODE FUNCTIONS
             void rmappluginPythonWrapper::sendOneTimecode()
             {
                 emit sig_sendOneTimecode();
             }
-            void rmappluginPythonWrapper::sendTimecodePeriodically()
+            void rmappluginPythonWrapper::sendTimecodePeriodically( unsigned int onOff )
             {
-                emit sig_sendTimecodePeriodically();
+                unsigned char newOnOff;
+                newOnOff = (unsigned char) onOff;
+                emit sig_sendTimecodePeriodically( newOnOff );
             }

rmapplugin/rmappluginpythonwrapper.h +2 -2

             #ifndef RMAPPLUGINPYTHONWRAPPER_H
             #define RMAPPLUGINPYTHONWRAPPER_H
             #include <QObject>
             #include <genericPySysdriver.h>
             #include <QList>
             #include <QVariant>
             #include <QTimer>
             #include "rmapoperations.h"
             #include "ccsds.h"
             #include "tcpackettosend.h"
             #include "tmpackettoread.h"
             class rmappluginPythonWrapper : public genericPySysdriver
             {
                 Q_OBJECT
             public:
                 explicit rmappluginPythonWrapper(lppmonplugin *parent = 0);
                 QList<TMPacketToRead*> *ccsdsPacketStore;
                 void processPacketStore();
                 unsigned int storeCCSDSPacket(unsigned char *ccsdsPacket, unsigned int size);
                 QList<TCPacketToSend*> TCPacketStore;
                 QTimer *timer;
             signals:
                 void ccsdsPacketIsAvailable(unsigned int size);
                 void wakeUpCallingThread();
                 unsigned int WriteSPWSig(char *Value, unsigned int count, char targetLogicalAddress, char userApplication);
                 //
                 void updateTargetLogicalAddress(unsigned char newAddress);
                 void updateSourceLogicalAddress(unsigned char newAddress);
                 void updateSpaceWireLinkNumber(unsigned char newAddress);
                 //
                 void activateTCLoopSig();
                 void processPacketStoreNowSig();
                 void sendMessage(QString message);
                 int fetchPacketSig();
                 void nbPacketHasChanged(int nb);
                 //*******************
                 // TIMECODE SIGNALS
                 void sig_sendOneTimecode();
-                void sig_sendTimecodePeriodically();
+                void sig_sendTimecodePeriodically(unsigned char);
             public slots:
                 QList<QVariant> ReadSPW(unsigned int size=0);
                 int fetchPacket() {return emit fetchPacketSig();}
                 void WriteSPW(QList<int> dataList);
                 void WriteSPWDelay(QList<int> dataList, unsigned int delay=0);
                 void processPacketStoreLater(unsigned int delay);
                 void sendProcessPacketStoreNowSig(){emit processPacketStoreNowSig();}
                 void sendTCLoop();
                 void sendTC();
                 void reEmitWriteSPWSig(char *Value, unsigned int count, char targetLogicalAddress, char userApplication)
                     {emit WriteSPWSig(Value, count, targetLogicalAddress, userApplication);}
                 //
                 void setValueTargetLogicalAddress(unsigned int address);
                 void setValueSourceLogicalAddress(unsigned int address);
                 void setValueSpaceWireLinkNumber(unsigned int linkNumber);
                 //
                 void ProcessPendingEvents();
                 void BlockAllSignals();
                 //*******************
                 // TIMECODE FUNCTIONS
                 void sendOneTimecode();
-                void sendTimecodePeriodically();
+                void sendTimecodePeriodically(unsigned int onOff);
             };
             #endif // RMAPPLUGINPYTHONWRAPPER_H

rmapplugin/stardundee.cpp +23 0

             #include "stardundee.h"
             #include <lppmonengine.h>
             #include <QTime>
             #include <QProgressBar>
             #include <math.h>
             #include "ccsds.h"
             StarDundee::StarDundee(QWidget *parent) :
                 QWidget(parent)
             {
                 // Packet receiver
                 timer = new QTimer;
                 rmapPacketSEMAPHORE = new QSemaphore;
                 ccsdsPacketSEMAPHORE = new QSemaphore;
                 rmapPacket = (char*) malloc(RMAP_MAX_PACKET_LENGTH);
                 ccsdsPacket = (unsigned char*) malloc(CCSDS_MAX_PACKET_LENGTH);
                 spwPacket = (char*) malloc( qMax(RMAP_MAX_PACKET_LENGTH, CCSDS_MAX_PACKET_LENGTH) );
                 starDundeeStatusQueryDialog = new QDialog;
                 commandCode = invalid0; // initialization of the cmmand code for the RMAP transfers
                 rmapTargetLogicalAddress = DEFAULT_TARGET;
                 rmapSourceLogicalAddress = DEFAULT_SOURCE;
                 connection_LAYOUT = new QGridLayout;
                 usbDeviceNumber_LABEL = new QLabel(tr("USB device number: "));
                 linkNumber_LABEL = new QLabel(tr("SpaceWire link number: "));
                 starDundeeStatusQueryDialogLabel = new QLabel(tr("SpaceWire links state"));
                 statusLink1 = new QLabel(tr("Link 1 status code: -"));
                 statusLink2 = new QLabel(tr("Link 2 status code: -"));
                 //*** QPUSHBUTTON ***//
                 starDundeeStatusQueryContinueButton = new QPushButton(tr("Continue"));
                 starDundeeStatusQueryRetryButton = new QPushButton(tr("Retry"));
                 starDundeeStatusQueryAbortButton = new QPushButton(tr("Abort"));
                 starDundeeSendOneTimecode = new QPushButton(tr("send one timecode"));
                 starDundeeSendOneTimePacketAndOneTimecode = new QPushButton(tr("send one update time\n+ one time code"));
                 starDundeeSendTimecodePeriodically = new QPushButton(tr("start timecodes at 1 Hz"));
                 starDundeeSendOneTimePacketAndTimecodePeriodically = new QPushButton(tr("send one update time\n+ timecodes at 1 Hz"));
                 arbitraryTime = new ArbitraryTime(1);   // 1 is for the horizontal layout
                 arbitraryTimeToSend = 0x80000000;
                 paulCommonCRC = new PaulCommonCRC();
                 flag_sendTimecodePeriodically = false;
                 starDundeeSendOneTimecode->setEnabled( false );
                 starDundeeSendTimecodePeriodically->setEnabled( false );
                 starDundeeSendOneTimePacketAndOneTimecode->setEnabled( false );
                 starDundeeSendOneTimePacketAndTimecodePeriodically->setEnabled( false );
                 usbDeviceNumber_SPINBOX = new QSpinBox;
                 usbDeviceNumber_SPINBOX->setRange(0,32);
                 usbDeviceNumber_SPINBOX->setValue(0);
                 linkNumber_SPINBOX = new QSpinBox;
                 linkNumber_SPINBOX->setRange(1,2);
                 linkNumber_SPINBOX->setValue(1);
                 // STAR DUNDEE STATUS QUERY DIALOG
                 starDundeeStatusQueryDialogLayout = new QGridLayout;
                 starDundeeStatusQueryDialogLayout->addWidget(starDundeeStatusQueryDialogLabel, 0, 0, 1, 2);
                 starDundeeStatusQueryDialogLayout->addWidget(starDundeeStatusQueryContinueButton, 1, 0, 0);
                 starDundeeStatusQueryDialogLayout->addWidget(starDundeeStatusQueryRetryButton, 1, 1, 0);
                 starDundeeStatusQueryDialogLayout->addWidget(starDundeeStatusQueryAbortButton, 1, 2, 0);
                 starDundeeStatusQueryDialogLayout->addWidget(statusLink1, 2, 0, 0);
                 starDundeeStatusQueryDialogLayout->addWidget(statusLink2, 3, 0, 0);
                 starDundeeStatusQueryDialog->setLayout(starDundeeStatusQueryDialogLayout);
                 connection_LAYOUT->addWidget(usbDeviceNumber_LABEL, 0, 0, 1, 1);
                 connection_LAYOUT->addWidget(usbDeviceNumber_SPINBOX, 0, 1, 1, 1);
                 connection_LAYOUT->addWidget(linkNumber_LABEL, 1, 0, 1, 1);
                 connection_LAYOUT->addWidget(linkNumber_SPINBOX, 1, 1, 1, 1);
                 connection_LAYOUT->addWidget(starDundeeSendOneTimecode, 2, 0, 1, 1);
                 connection_LAYOUT->addWidget(starDundeeSendOneTimePacketAndOneTimecode, 2, 1, 1, 1);
                 connection_LAYOUT->addWidget(starDundeeSendTimecodePeriodically, 3, 0, 1, 1 );
                 connection_LAYOUT->addWidget(starDundeeSendOneTimePacketAndTimecodePeriodically, 3, 1, 1, 1);
                 connection_LAYOUT->addWidget(arbitraryTime, 6, 0, 1, 2);
                 connection_LAYOUT->setRowStretch(7, 1);
                 connection_LAYOUT->setColumnStretch(2, 1);
                 this->setLayout(connection_LAYOUT);
                 connect(starDundeeStatusQueryRetryButton, SIGNAL(clicked()),
                         this, SLOT(reTestSPWLink()));
                 connect(starDundeeStatusQueryAbortButton, SIGNAL(clicked()),
                         starDundeeStatusQueryDialog, SLOT(reject()));
                 connect(starDundeeStatusQueryContinueButton, SIGNAL(clicked()),
                         starDundeeStatusQueryDialog, SLOT(accept()));
                 // TIMECODES
                 connect(this->starDundeeSendOneTimecode, SIGNAL(clicked()),
                         this, SLOT(sendOneTimecode()));
                 connect(this->starDundeeSendTimecodePeriodically, SIGNAL(clicked()),
                         this, SLOT(sendTimecodePeriodically()));
                 connect(this->starDundeeSendOneTimePacketAndOneTimecode, SIGNAL(clicked()),
                         this, SLOT(sendOneTimePacketAndOneTimecode()));
                 connect(this->starDundeeSendOneTimePacketAndTimecodePeriodically, SIGNAL(clicked()),
                         this, SLOT(sendOneTimePacketAndTimecodePeriodically()));
                 connect(this->arbitraryTime, SIGNAL(timeToSendChanged(long)),
                         this, SLOT(updateTimeToSend(long)));
                 connect(this->timer, SIGNAL(timeout()), this, SLOT(receivePollingLoop()));
             }
             StarDundee::~StarDundee()
             {
                 free(rmapPacket);
                 free(ccsdsPacket);
                 free(spwPacket);
                 USBSpaceWire_Close(hDevice); // Close the device
             }
             bool StarDundee::Open()
             {
                 int status;
                 U32 statusControl;
                 unsigned int linkStatus1;
                 unsigned int linkStatus2;
                 unsigned char linkNumber;
                 unsigned char deviceIsAnInterface;
                 if (!USBSpaceWire_Open(&hDevice, usbDeviceNumber_SPINBOX->value())) // Open the USB device
                 {
                     emit sendMessage("stardundee *** Open *** ERROR: USBSpaceWire_Open(&hDevice, 0))");
                     return false;
                 }
                 emit sendMessage("stardundee *** Open *** USBSpaceWire_Open successful, device number: "
                                  + QString::number(usbDeviceNumber_SPINBOX->value()));
                 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
                 // This affects just the operations performed by the Configuration Library and does not affect the packets
                 // sent and received using the driver API.
                 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)
                 {
                     emit sendMessage("ERROR CFGSpaceWire_SetBrickBaseTransmitRate");
                 }
                 else emit sendMessage("OK CFGSpaceWire_SetBrickBaseTransmitRate, base rate = 100 MHz");
                 //*********************
                 // LINK 1 CONFIGURATION
                 linkNumber = 1;
                 if (CFGSpaceWire_GetLinkStatusControl(hDevice, linkNumber, &statusControl) != CFG_TRANSFER_SUCCESS)
                     emit sendMessage("Could not read link status control for link " + QString::number(linkNumber));
                 else
                 {
                     emit sendMessage("OK CFGSpaceWire_GetLinkStatusControl of link " + QString::number(linkNumber));
                     // Set the link status control register properties
                     CFGSpaceWire_LSEnableAutoStart(&statusControl, 1);
                     CFGSpaceWire_LSEnableStart(&statusControl, 1);
                     CFGSpaceWire_LSEnableDisabled(&statusControl, 0);
                     CFGSpaceWire_LSEnableTristate(&statusControl, 0);
                     CFGSpaceWire_LSSetOperatingSpeed(&statusControl, 9);    // sets the link speed to ( 100 MHz / (9+1) ) = 10 MHz
                     // Set the link status control register
                     if (CFGSpaceWire_SetLinkStatusControl(hDevice, linkNumber, statusControl) != CFG_TRANSFER_SUCCESS)
                         emit sendMessage("Could not set the link status control for link " + QString::number(linkNumber));
                     else
                         emit sendMessage("link status control for link " + QString::number(0x01) + " is set");
                 }
                 //*********************
                 // LINK 2 CONFIGURATION
                 linkNumber = 2;
                 if (CFGSpaceWire_GetLinkStatusControl(hDevice, linkNumber, &statusControl) != CFG_TRANSFER_SUCCESS)
                     emit sendMessage("Could not read link status control for link " + QString::number(linkNumber));
                 else
                 {
                     emit sendMessage("OK CFGSpaceWire_GetLinkStatusControl of link " + QString::number(linkNumber));
                     // Set the link status control register properties
                     CFGSpaceWire_LSEnableAutoStart(&statusControl, 1);
                     CFGSpaceWire_LSEnableStart(&statusControl, 1);
                     CFGSpaceWire_LSEnableDisabled(&statusControl, 0);
                     CFGSpaceWire_LSEnableTristate(&statusControl, 0);
                     CFGSpaceWire_LSSetOperatingSpeed(&statusControl, 9);    // sets the link speed to ( 100 MHz / (9+1) ) = 10 MHz
                     // Set the link status control register
                     if (CFGSpaceWire_SetLinkStatusControl(hDevice, linkNumber, statusControl) != CFG_TRANSFER_SUCCESS)
                         emit sendMessage("Could not set the link status control for link " + QString::number(linkNumber));
                     else
                         emit sendMessage("link status control for link " + QString::number(linkNumber) + " is set");
                 }
                 //*******************************
                 // SET THE DEVICE AS AN INTERFACE
                 deviceIsAnInterface = 1;
                 if (CFGSpaceWire_SetAsInterface(hDevice, deviceIsAnInterface, 0) != CFG_TRANSFER_SUCCESS)
                     emit sendMessage("Could not set the device to be an interface");
                 else
                     emit sendMessage("Device is an interface: " + QString::number(deviceIsAnInterface) + " (1 => true, 0 => false)");
             //    setRoutingTableEntry(0xfe, 0x02); // [0010] => connect LFR     on the [Link 1] port
             //    setRoutingTableEntry(0xfd, 0x04); // [0100] => connect TIMEGEN on the [Link 2] port
             //    GetRoutingTableEntry(0xfe);
             //    GetRoutingTableEntry(0xfd);
             //    GetRoutingTableEntry(0x01);
                 USBSpaceWire_RegisterReceiveOnAllPorts(hDevice);  // Register to receive on port 1 only
             //    USBSpaceWire_RegisterReceiveOnPort(hDevice, 0x01);  // Register to receive on port 1 only
             //    USBSpaceWire_RegisterReceiveOnPort(hDevice, 0xfe);  // Register to receive on port 254 only
                 USBSpaceWire_ClearEndpoints(hDevice);               // clear the USB endpoints
                 emit sendMessage("The driver's current send buffer size is " + QString::number(USBSpaceWire_GetDriverSendBufferSize(hDevice)) + " bytes");
                 emit sendMessage("The driver's current read buffer size is " + QString::number(USBSpaceWire_GetDriverReadBufferSize(hDevice)) + " bytes");
                 emit sendMessage("USBSpaceWire_IsReadThrottling is " + QString::number(USBSpaceWire_IsReadThrottling(hDevice)));
                 // initialize SPW packet semaphores
                 while (rmapPacketSEMAPHORE->available()!=0) rmapPacketSEMAPHORE->acquire();
                 while (ccsdsPacketSEMAPHORE->available()!=0) ccsdsPacketSEMAPHORE->acquire();
                 //************
                 // test Link 1 and Link 2
                 linkStatus1 = getLinkStatus(0x01);
                 linkStatus2 = getLinkStatus(0x02);
                 if ((linkStatus1==1) || (linkStatus2==1))
                 {
             //        statusLink1->setText("Link 1 status code: " + QString::number(linkStatus1));
             //        statusLink2->setText("Link 2 status code: " + QString::number(linkStatus2));
             //        starDundeeStatusQueryDialog->exec();
                     emit isOpen(true);
                     timer->start(1); // starts the periodical timer, period = 100ms
                     initializeTimecodeGeneration();
                     return true;
                 }
                 else
                 {
                     statusLink1->setText("Link 1 status code: " + QString::number(linkStatus1));
                     statusLink2->setText("Link 2 status code: " + QString::number(linkStatus2));
                     starDundeeStatusQueryDialog->exec();
                     return false;
                 }
             }
             void StarDundee::Close()
             {
                 USBSpaceWire_Close(hDevice); // Close the device
                 emit sendMessage("stardundee *** Close *** USBSpaceWire_Close, device: " + QString::number(usbDeviceNumber_SPINBOX->value()));
                 USBSpaceWire_UnregisterReceiveOnAllPorts(hDevice);  // Stop receiving on all ports
                 emit isOpen(false);
             }
             unsigned char StarDundee::setRoutingTableEntry(int tableEntry, U32 dwOutputPorts)
             {
                 U32 routingTableEntry;
                 // SET THE ROUTING TABLE ENTRY FOR LOGICAL ADDRESSING, TARGET entryNumber
                 if (CFGSpaceWire_ClearRoutingTableEntry(hDevice, tableEntry) != CFG_TRANSFER_SUCCESS)
                 {
                     emit sendMessage("Could not clear routing table entry " + QString::number(tableEntry));
                 }
                 // Build the routing table entry
                 CFGSpaceWire_RTBuildRoutingTableEntry(&routingTableEntry,
                                                       dwOutputPorts,        // route out of port dwOutputPorts
 ,                    // header deletion disabled
 );                   // priority normal
                 // Set the routing table entry for logical address tableEntry
                 if (CFGSpaceWire_SetRoutingTableEntry(hDevice, tableEntry, routingTableEntry) != CFG_TRANSFER_SUCCESS)
                 {
                     emit sendMessage("Could not set routing table entry [" + QString::number(tableEntry) + "]");
                 }
                 else emit sendMessage("Routing table entry [" + QString::number(tableEntry) + "] set" );
                 return 1;
             }
             unsigned int StarDundee::GetRoutingTableEntry(int tableEntry)
             {
                 U32 routingTableEntry, outputPorts;
                 char enabled, delHead, priority;
                 int portNum;
                 emit sendMessage("GetRoutingTableEntry [" + QString::number(tableEntry) + "]");
                 // Read the routing table entry
                 if (CFGSpaceWire_GetRoutingTableEntry(hDevice, tableEntry, &routingTableEntry) != CFG_TRANSFER_SUCCESS)
                 {
                     emit sendMessage("Could not read routing table entry [" + QString::number(tableEntry) + "]");
                 }
                 else
                 {
                     // Display the routing table entry properties
                     CFGSpaceWire_RTIsEnabled(routingTableEntry, &enabled);
                     CFGSpaceWire_RTIsDelHead(routingTableEntry, &delHead);
                     CFGSpaceWire_RTIsPriority(routingTableEntry, &priority);
                     CFGSpaceWire_RTGetOutputPorts(routingTableEntry, &outputPorts);
                     emit sendMessage("CFGSpaceWire_RTIsEnabled      : " + QString::number(enabled));
                     emit sendMessage("CFGSpaceWire_RTIsDelHead      : " + QString::number(delHead));
                     emit sendMessage("CFGSpaceWire_RTIsPriority     : " + QString::number(priority));
                     emit sendMessage("CFGSpaceWire_RTGetOutputPorts : ");
                     for (portNum = 0; portNum < 32; portNum++)
                     {
                         if (outputPorts & (1 << portNum))
                         {
                             emit sendMessage(QString::number(portNum));
                         }
                     }
                 }
                 return 1;
             }
             unsigned int StarDundee::Write(unsigned int *Value, unsigned int count, unsigned int address)
             {
                 unsigned int remainingCount = count;
                 unsigned int iOffset = 0;
                 QString console_message;
                 char* data;
                 if(rmapPacketSEMAPHORE->available()!=0)
                 {
                     emit appendToLog("WARNING === in function WRITE of rmapplugin *** RMAP request already running, WRITE access stopped");
                     return 1;
                 }
                 emit this->RMAP_write_reply_setText("reply to the write command required\nlast reply status: unavailable");
                 data = (char*) malloc(READ_WRITE_MAX_COUNTS*4);
                 emit appendToLog(QString("*** START *** WRITE ")+ QString::number(count) + QString(" word(s) @0x")+ QString::number(address,16));
                 QProgressBar* progress=NULL;
                 if (count > READ_WRITE_MAX_COUNTS)
                 {
                     progress = lppmonEngine::getProgressBar("Reading on spw @0x"+QString::number(address,16)+" %v of "+QString::number(count)+" words ",count);
                 }
                 while (remainingCount > READ_WRITE_MAX_COUNTS)
                 {
                     // progress bar
                     progress->setValue(count-remainingCount);
                     qApp->processEvents();
                     for (int i = 0; i<READ_WRITE_MAX_COUNTS; i++)
                     {
                         data[i*4+3] = (char) ((unsigned int) Value[i+iOffset]);
                         data[i*4+2] = (char) ((unsigned int) Value[i+iOffset]>>8);
                         data[i*4+1] = (char) ((unsigned int) Value[i+iOffset]>>16);
                         data[i*4+0] = (char) ((unsigned int) Value[i+iOffset]>>24);
                     }
                     console_message.sprintf("remainingCount: %d => ", remainingCount);
                     emit appendToLog(console_message + QString("Write ")+ QString::number(READ_WRITE_MAX_COUNTS*4) + QString(" byte(s) @0x")+ QString::number(address,16));
                     if(WriteBLOCK(data, READ_WRITE_MAX_COUNTS*4, address)==0)
                     {
                         emit appendToLog("WARNING === in function WRITE of rmapplugin *** RMAP write command failed");
                         return 1;
                     }
                     remainingCount = remainingCount - READ_WRITE_MAX_COUNTS;
                     address = address + READ_WRITE_MAX_COUNTS * 4;
                     iOffset = iOffset + READ_WRITE_MAX_COUNTS;
                 }
                 if (remainingCount > 0)
                 {
                     for (unsigned int i = 0; i<remainingCount; i++)
                     {
                         data[i*4+3] = (char) ((unsigned int) Value[i+iOffset]);
                         data[i*4+2] = (char) ((unsigned int) Value[i+iOffset]>>8);
                         data[i*4+1] = (char) ((unsigned int) Value[i+iOffset]>>16);
                         data[i*4+0] = (char) ((unsigned int) Value[i+iOffset]>>24);
                     }
                     console_message.sprintf("remainingCount: %d => ", remainingCount);
                     emit appendToLog(console_message + QString("Write ")+ QString::number(remainingCount*4) + QString(" byte(s) @0x")+ QString::number(address,16));
                     if (WriteBLOCK(data, remainingCount*4, address)==0)
                     {
                         emit appendToLog("WARNING === in function WRITE of rmapplugin *** RMAP write command failed");
                         return 1;
                     }
                 }
                 if (count > READ_WRITE_MAX_COUNTS)
                 {
                     lppmonEngine::deleteProgressBar(progress);
                 }
                 emit appendToLog(QString("*** STOP *** WRITE"));
                 free(data);
                 return count;
             }
             unsigned int StarDundee::Read(unsigned int *Value, unsigned int count, unsigned int address)
             {
                 unsigned int remainingCount = count;
                 unsigned int iOffset = 0;
                 QString console_message;
                 if(rmapPacketSEMAPHORE->available()!=0)
                 {
                     emit appendToLog("WARNING === in function READ of rmapplugin *** RMAP request already running, READ access stopped");
                     return 1;
                 }
                 emit appendToLog(QString("*** START *** READ ")+ QString::number(count) + QString(" word(s) @0x")+ QString::number(address,16));
                 QProgressBar* progress=NULL;
                 if (count > READ_WRITE_MAX_COUNTS)
                 {
                     progress = lppmonEngine::getProgressBar("Reading on spw @0x"+QString::number(address,16)+" %v of "+QString::number(count)+" words ",count);
                 }
                 while (remainingCount > READ_WRITE_MAX_COUNTS)
                 {
                     // progress bar
                     progress->setValue(count-remainingCount);
                     qApp->processEvents();
                     console_message.sprintf("remainingCount: %d => ", remainingCount);
                     emit appendToLog(console_message + QString("Read ")+ QString::number(4*READ_WRITE_MAX_COUNTS) + QString(" byte(s) @0x")+ QString::number(address,16));
                     if (this->ReadBLOCK(READ_WRITE_MAX_COUNTS*4, address)==0)
                     {
                         emit appendToLog("WARNING === in function READ of rmapplugin *** RMAP packet not received");
                         return 1;
                     }
                     for(int i=0;i<READ_WRITE_MAX_COUNTS;i++)
                     {
                         Value[i+iOffset] = (unsigned char) rmapPacket[i*4+RMAP_READ_REPLY_HEADER_LENGTH];
                         for(int j=1;j<4;j++)
                         {
                             Value[i+iOffset]= ((unsigned char) (rmapPacket[i*4+j+RMAP_READ_REPLY_HEADER_LENGTH]))
                                     + Value[i+iOffset]*256;
                         }
                     }
                     remainingCount = remainingCount - READ_WRITE_MAX_COUNTS;
                     address = address + READ_WRITE_MAX_COUNTS * 4;
                     iOffset = iOffset + READ_WRITE_MAX_COUNTS;
                     this->acquireRMAPSemaphore();
                 }
                 if (remainingCount > 0)
                 {
                     console_message.sprintf("remainingCount: %d => ", remainingCount);
                     emit appendToLog(console_message + QString("Read ")+ QString::number(4*remainingCount) + QString(" byte(s) @0x")+ QString::number(address,16));
                     if (this->ReadBLOCK(4*remainingCount, address)==0)
                     {
                         emit appendToLog("WARNING === in function READ of rmapplugin *** RMAP packet not received");
                         return 1;
                     }
                     for(unsigned int i=0;i<remainingCount;i++)
                     {
                         Value[i+iOffset] = (unsigned char) rmapPacket[i*4+RMAP_READ_REPLY_HEADER_LENGTH];
                         for(int j=1;j<4;j++)
                         {
                             Value[i+iOffset]= ((unsigned char)(rmapPacket[i*4+j+RMAP_READ_REPLY_HEADER_LENGTH])) + Value[i+iOffset]*256;
                         }
                     }
                     this->acquireRMAPSemaphore();
                 }
                 if (count > READ_WRITE_MAX_COUNTS)
                 {
                     lppmonEngine::deleteProgressBar(progress);
                 }
                 emit appendToLog(QString("*** STOP *** READ "));
                 return count;
             }
             unsigned int StarDundee::WriteBLOCK(char *data, unsigned int nbBytes, unsigned int address)
             {
                 RMAP *RMAPCommand;
                 char * packet;
                 char* aux;
                 unsigned char offset, headerSize, CRCSize;
                 unsigned int totalSize;
                 int errorCode;
                 QString console_message;
                 if (getLinkStatus(this->linkNumber_SPINBOX->value()) == 0)
                 {
                     this->Close();
                     return 1;
                 }
                 RMAPCommand = new RMAP(this->commandCode,
                                        rmapTargetLogicalAddress,
                                        rmapSourceLogicalAddress,
                                        address,
                                        nbBytes,
                                        data);
                 headerSize = sizeof(RMAPCommand->RMAPHeader);
                 CRCSize = 1;
                 //*************************
                 // BUILD THE PACKET TO SEND
                 totalSize = headerSize + nbBytes + CRCSize + PATH_ADDRESSING_OFFSET;
                 packet = (char*) malloc( totalSize );
                 aux = (char*) ((void*) &RMAPCommand->RMAPHeader);
                 packet[0] = getPacketFirstByte();     // TO BE SUPPRESSED
                 for(unsigned int i = 0; i<headerSize; i++) packet[i+PATH_ADDRESSING_OFFSET] = aux[i];
                 offset = headerSize;
                 for(unsigned int i = 0; i<nbBytes; i++)
                 {
                     packet[i+offset+PATH_ADDRESSING_OFFSET] = data[i];
                 }
                 packet[nbBytes+offset+PATH_ADDRESSING_OFFSET] = RMAPCommand->dataCRC;
                 //****************
                 // SEND THE PACKET
                 result = USBSpaceWire_SendPacket(hDevice,
                                                  packet,
                                                  totalSize,
                                                  BWAIT_1, &pIdentifier);
                 if (result != TRANSFER_SUCCESS)
                 {
                     emit sendMessage("ERROR *** WriteStarDundee when sending packet of size "
                                      + QString::number(totalSize) +", with code: " + QString::number(result));
                     USBSpaceWire_FreeSend(hDevice, pIdentifier);
                     free(data);
                     return 1;
                 }
             //    else emit sendMessage("OK *** WriteStarDundee when sending packet of size " + QString::number(totalSize));
                 //**************
                 // Free the send
                 USBSpaceWire_FreeSend(hDevice, pIdentifier);
                 free(packet);
                 if ( (commandCode == writeSingle_noVer_Rep) | (commandCode == writeInc_noVer_Rep) |
                      (commandCode == writeSingle_ver_rep) | (commandCode == writeInc_ver_rep) )
                 {
                     // WAIT FOR THE RMAP REPLY PACKET
                     errorCode = this->receiveSPWPacket(1);
                     if (errorCode<=0)
                     {
                         emit appendToLog("WARNING === in function WriteBLOCK of rmapplugin *** RMAP packet reception failed with code " + QString::number(errorCode));
                         return 0;
                     }
                     if(rmapPacketSize != 8)
                      {
                         console_message.sprintf("WARNING === in function WRITE (with reply) of rmapplugin *** write reply format not compliant\n");
                         emit appendToLog(console_message);
                         return 0;
                      }
                     switch (this->rmapPacket[3]) // byte 4 is the status byte in the reply
                     {
                     case 0:
                         emit RMAP_write_reply_setText("reply to the write command required\nlast reply status: 0 Successfull");
                         break;
                     case 1:
                         emit appendToLog("WARNING === in function WRITE (with reply) of rmapplugin *** General error code");
                         emit RMAP_write_reply_setText("reply to the write command required\nlast reply status: 1 General error code");
                         break;
                     case 2:
                         emit appendToLog("WARNING === in function WRITE (with reply) of rmapplugin *** Unused RMAP packet type or command code");
                         emit RMAP_write_reply_setText("reply to the write command required\nlast reply status: 2 Unused RMAP packet type or command code");
                         break;
                     case 3:
                         emit appendToLog("WARNING === in function WRITE (with reply) of rmapplugin *** Invalid key");
                         emit RMAP_write_reply_setText("reply to the write command required\nlast reply status: 3 Invalid key");
                         break;
                     case 4:
                         emit appendToLog("WARNING === in function WRITE (with reply) of rmapplugin *** Invalid data CRC");
                         emit RMAP_write_reply_setText("reply to the write command required\nlast reply status: 4 Invalid data CRC");
                         break;
                     case 5:
                         emit appendToLog("WARNING === in function WRITE (with reply) of rmapplugin *** Early EOP");
                         emit RMAP_write_reply_setText("reply to the write command required\nlast reply status: 5 Early EOP");
                         break;
                     case 6:
                         emit appendToLog("WARNING === in function WRITE (with reply) of rmapplugin *** Too much data");
                         emit RMAP_write_reply_setText("reply to the write command required\nlast reply status: 6 Too much data");
                         break;
                     case 7:
                         emit appendToLog("WARNING === in function WRITE (with reply) of rmapplugin *** EEP");
                         emit RMAP_write_reply_setText("reply to the write command required\nlast reply status: 7 EEP");
                         break;
                     case 8:
                         emit appendToLog("WARNING === in function WRITE (with reply) of rmapplugin *** Reserved");
                         emit RMAP_write_reply_setText("reply to the write command required\nlast reply status: 8 Reserved");
                         break;
                     case 9:
                         emit appendToLog("WARNING === in function WRITE (with reply) of rmapplugin *** Verify buffer overrun");
                         emit RMAP_write_reply_setText("reply to the write command required\nlast reply status: 9 Verify buffer overrun");
                         break;
                     case 10:
                         emit appendToLog("WARNING === in function WRITE (with reply) of rmapplugin *** RMAP command not implemented or not authorised");
                         emit RMAP_write_reply_setText("reply to the write command required\nlast reply status: 10 RMAP command not implemented or not authorised");
                         break;
                     case 11:
                         emit appendToLog("WARNING === in function WRITE (with reply) of rmapplugin *** RMW data length error");
                         emit RMAP_write_reply_setText("reply to the write command required\nlast reply status: 11 RMAP RMW data length error");
                         break;
                     case 12:
                         emit appendToLog("WARNING === in function WRITE (with reply) of rmapplugin *** Invalid target logical address");
                         emit RMAP_write_reply_setText("reply to the write command required\nlast reply status: 12 Invalid target logical address");
                         break;
                     }
                     this->acquireRMAPSemaphore();
                 }
                 else
                     emit RMAP_write_reply_setText("reply to the write command required\nlast reply status: unavailable");
                 return nbBytes;
             }
             unsigned int StarDundee::ReadBLOCK(unsigned int nbBytes, unsigned int address)
             {
                 int errorCode;
                 RMAP *RMAPCommand;
                 char *packet;
                 char *aux;
                 unsigned int dataLength = 0;
                 unsigned int totalSize = 0;
                 //**********************
                 // Check the link status
                 if ( getLinkStatus( this->linkNumber_SPINBOX->value() ) == 0 )
                 {
                     this->Close();
                     emit appendToLog("WARNING === in function WriteSPW of StarDundee *** SPW link not running\n");
                     return 0;
                 }
                 //**********************
                 // SEND THE READ COMMAND
                 if (nbBytes > 4)
                 {
                     RMAPCommand = new RMAP(read_Inc,
                                            rmapTargetLogicalAddress,
                                            rmapSourceLogicalAddress,
                                            address,
                                            nbBytes,
                                            NULL);
                 }
                 else
                 {
                     RMAPCommand = new RMAP(read_Single,
                                            rmapTargetLogicalAddress,
                                            rmapSourceLogicalAddress,
                                            address,
                                            nbBytes,
                                            NULL);
                 }
                 //*************************
                 // BUILD THE PACKET TO SEND
                 totalSize = sizeof(RMAPCommand->RMAPHeader) + PATH_ADDRESSING_OFFSET;
                 packet = (char*) malloc( totalSize );
                 aux = (char*) ((void*) &RMAPCommand->RMAPHeader);
                 packet[0] = getPacketFirstByte();     // TO BE SUPPRESSED
                 for (unsigned int i = 0; i<sizeof(RMAPCommand->RMAPHeader); i++)
                     packet[i+PATH_ADDRESSING_OFFSET] = aux[i];
                 //****************
                 // SEND THE PACKET
                 result = USBSpaceWire_SendPacket(hDevice,
                                                  packet,
                                                  totalSize,
                                                  BWAIT_1, &pIdentifier);
                 if (result != TRANSFER_SUCCESS) emit sendMessage("ERR *** ReadStarDundee *** ReadBLOCK *** sending the READ command ");
                 else
                 {
             //        emit sendMessage("OK *** ReadStarDundee *** ReadBLOCK *** sending the READ command");
             //        emit appendToLog("packet sent, B0 = " + QString::number(packet[0], 16)
             //                         + " *** B1 = " + QString::number(packet[1], 16)
             //                         + " *** B2 = " + QString::number(packet[2], 16)
             //                         + " *** B3 = " + QString::number(packet[3], 16)
             //                         + " *** B4 = " + QString::number(packet[4], 16)
             //                         + " *** B5 = " + QString::number(packet[5], 16)
             //                         );
                 }
                 //**************
                 // Free the send
                 USBSpaceWire_FreeSend(hDevice, pIdentifier);
                 free(packet);
                 //*********************************
                 // RECEIVE THE INCOMING RMAP PACKET
                 errorCode = this->receiveSPWPacket(1); // request ID 1 is for RMAP packet
                 if (errorCode<=0)
                 {
                     emit appendToLog("WARNING === in function ReadBLOCK of StarDundee *** RMAP packet reception failed with code " + QString::number(errorCode));
                     return 0;
                 }
                 dataLength = rmapPacketSize - RMAP_READ_REPLY_HEADER_LENGTH - RMAP_DATA_CRC_LENGTH;
                 if(dataLength != nbBytes)
                  {
                     emit appendToLog("WARNING === in function READ of StarDundee *** number of data received ("
                                 +QString::number(dataLength)
                                 +") not equal to number of data requested ("
                                 +QString::number(nbBytes)
                                 +")");
                     return 0;
                  }
                 return dataLength;
             }
             unsigned int StarDundee::WriteSPW(char *Value, unsigned int count, char targetLogicalAddress, char userApplication)
             {
                 char protocoleIdentifier = 0x02;
                 char reserved = 0x00;
                 char *SPWData;
                 unsigned int totalSize;
                 if (count>248)
                 {
                     emit appendToLog("WARNING === in function WRITE of rmapplugin *** CCSDS packet size > 248 bytes\n");
                     return 1;
                 }
                 emit appendToLog("*** START *** Send CCSDS packet of "+ QString::number(count) + " byte(s)");
                 if ( getLinkStatus( this->linkNumber_SPINBOX->value() ) == 0 )
                 {
                     this->Close();
                     emit appendToLog("WARNING === in function WriteSPW of StarDundee *** SPW link not running\n");
                     return 1;
                 }
                 totalSize = count + 4 + PATH_ADDRESSING_OFFSET; // The StarDundee brick is in PATH addressing
                 SPWData = (char*) malloc(totalSize);
                 // SPW HEADER
                 SPWData[0] = getPacketFirstByte();
                 SPWData[0+PATH_ADDRESSING_OFFSET] = targetLogicalAddress;
                 SPWData[1+PATH_ADDRESSING_OFFSET] = protocoleIdentifier;
                 SPWData[2+PATH_ADDRESSING_OFFSET] = reserved;
                 SPWData[3+PATH_ADDRESSING_OFFSET] = userApplication;
                 // CCSDS PACKET
                 for (unsigned int i = 0; i<count; i++)
                 {
                     SPWData[i+4+PATH_ADDRESSING_OFFSET] = Value[i];
                 }
                 //****************
                 // SEND THE PACKET
                 result = USBSpaceWire_SendPacket(hDevice,
                                                  SPWData,
                                                  totalSize,
                                                  BWAIT_1, &pIdentifier);
                 if (result != TRANSFER_SUCCESS)
                 {
                     emit sendMessage("ERROR *** WriteSPW when sending packet of size "
                                      + QString::number(totalSize) +", with code: " + QString::number(result));
                     USBSpaceWire_FreeSend(hDevice, pIdentifier);
                     free(SPWData);
                     return 0;
                 }
                 else emit sendMessage("OK *** WriteSPW when sending packet of size " + QString::number(totalSize-1));
                 emit appendToLog("packet sent, B0 = " + QString::number(SPWData[0])
                                  + " *** B1 = " + QString::number(SPWData[1])
                                  + " *** B2 = " + QString::number(SPWData[2])
                                  + " *** B3 = " + QString::number(SPWData[3])
                                  + " *** B4 = " + QString::number(SPWData[4])
                                  + " *** B5 = " + QString::number(SPWData[5])
                                  + " *** B6 = " + QString::number(SPWData[6])
                                  + " *** B7 = " + QString::number(SPWData[7])
                                  + " *** B8 = " + QString::number(SPWData[8])
                                  + " *** B9 = " + QString::number(SPWData[9])
                                  + " *** B10 = " + QString::number(SPWData[10])
                                  + " *** B11 = " + QString::number(SPWData[11])
                                  + " *** B12 = " + QString::number(SPWData[12])
                                  );
                 //**************
                 // Free the send
                 USBSpaceWire_FreeSend(hDevice, pIdentifier);
                 free(SPWData);
                 emit appendToLog(QString("*** CCSDS packet sent"));
                 return 1;
             }
             unsigned int StarDundee::getLinkStatus(unsigned char link)
             {
                 U32 statusControl, errorStatus, portType;
                 U32 linkStatus, operatingSpeed, outputPortConnection;
                 char isLinkRunning, isAutoStart, isStart, isDisabled, isTristate;
                 // Read the link status control register
                 if (CFGSpaceWire_GetLinkStatusControl(hDevice, link, &statusControl) != CFG_TRANSFER_SUCCESS)
                 {
                     emit appendToLog("Could not read link status control for link" + QString::number(link));
                 }
                 else
                 {
                     // Display the link status control register properties
                     CFGSpaceWire_LSPortType(statusControl, &portType);
                     if (portType == CFG_CONFIGURATION_PORT)
                     {
                         CFGSpaceWire_LSConfigErrorStatus(statusControl, &errorStatus);
                         //emit appendToLog("Configuration port error status = " + QString::number(errorStatus));
                     }
                     else if (portType == CFG_SPACEWIRE_EXTERNAL_PORT)
                     {
                         CFGSpaceWire_LSExternalErrorStatus(statusControl, &errorStatus);
                         //emit appendToLog("External port error status = " + QString::number(errorStatus));
                     }
                     else
                     {
                         CFGSpaceWire_LSErrorStatus(statusControl, &errorStatus);
                         //emit appendToLog("SpaceWire link error status = " + QString::number(errorStatus));
                     }
                     CFGSpaceWire_LSLinkState(statusControl, &linkStatus);
                     CFGSpaceWire_LSIsLinkRunning(statusControl, &isLinkRunning);
                     CFGSpaceWire_LSIsAutoStart(statusControl, &isAutoStart);
                     CFGSpaceWire_LSIsStart(statusControl, &isStart);
                     CFGSpaceWire_LSIsDisabled(statusControl, &isDisabled);
                     CFGSpaceWire_LSIsTristate(statusControl, &isTristate);
                     CFGSpaceWire_LSOperatingSpeed(statusControl, &operatingSpeed);
                     CFGSpaceWire_LSOutputPortConnection(statusControl, &outputPortConnection);
                     //emit appendToLog("The link state is = " + QString::number(linkStatus));
                     //emit appendToLog("The link is running = " + QString::number(isLinkRunning));
                     //emit appendToLog("The autostart bit is enabled = " + QString::number(isAutoStart));
                     //emit appendToLog("The start bit is enabled = " + QString::number(isStart));
                     //emit appendToLog("The link is disabled = " + QString::number(isDisabled));
                     //emit appendToLog("The tri-state bit is enabled = " + QString::number(isAutoStart));
                     //emit appendToLog("The operating speed is = " + QString::number(operatingSpeed));
                     //emit appendToLog("This port is currently connected to output port = " + QString::number(outputPortConnection));
                 }
                 if (linkStatus == 5) return 1;
                 else return 0;
             }
             void StarDundee::spaceWireLinkHasChanged(unsigned char spaceWireLink)
             {
                 linkNumber_SPINBOX->setValue(spaceWireLink);
             }
             void StarDundee::receivePollingLoop()
             {
                 timer->blockSignals(true);
                 if (USBSpaceWire_WaitOnReadPacketAvailable(hDevice, 0)) receiveSPWPacketLoop(0);
                 timer->blockSignals(false);
             }
             int StarDundee::receiveSPWPacketLoop(unsigned char requestID)
             {
                 int result = 0;
                 emit appendToLog("Number of packets dropped by the driver: " +
                                  QString::number(USBSpaceWire_GetDriverDroppedPackets(hDevice)));
                 while (USBSpaceWire_WaitOnReadPacketAvailable(hDevice, 0))
                 {
                     result = receiveSPWPacket(requestID);
                 }
                 return result;
             }
             int StarDundee::receiveSPWPacket(unsigned char requestID) // SLOT
             {
                 unsigned int packetLength;
                 unsigned int nbBytes;
                 unsigned nPacketNum;
                 USB_SPACEWIRE_PACKET_PROPERTIES properties; // The properties of the read
                 if (requestID==1)
                 {
                     if (rmapPacketSEMAPHORE->available())
                     {
                         return rmapPacketSize;
                     }
                 }
                 //********************
                 // TRY TO RECEIVE DATA
                 nbBytes = qMax(RMAP_MAX_PACKET_LENGTH, CCSDS_MAX_PACKET_LENGTH); // maximum size of the packet to receive
                 nPacketNum = 1;
                 result = USBSpaceWire_ReadPackets(hDevice, spwPacket, nbBytes, nPacketNum, BWAIT_1, &properties, &pIdentifierRead);
                 if (result != TRANSFER_SUCCESS)
                 {
                     emit sendMessage("Error: Could not receive the packet, result = " + QString::number(result));
                     USBSpaceWire_FreeRead(hDevice, pIdentifierRead);         // Free the read buffer
                     return 0;
                 }
                 else
                 {
                     packetLength = properties.len;
                     if (properties.eop == SPACEWIRE_USB_NO_EOP)
                     {
                         emit appendToLog("No end of packet marker received");
                     }
             //        else if (properties.eop == SPACEWIRE_USB_EOP)
             //        {
             //            emit appendToLog("Normal end of packet marker received");
             //        }
                     else if (properties.eop == SPACEWIRE_USB_EEP)
                     {
                         emit appendToLog("Error end of packet marker received");
                     }
                     USBSpaceWire_FreeRead(hDevice, pIdentifierRead);         // Free the read buffer
                 }
                 switch(spwPacket[1]) // byte 1 is the protocole identifier in the SPW packet
                 {
                 case 1: // 0x01 is the protocole identifier for RMAP packets
                     if (rmapPacketSEMAPHORE->available()!=0) return -3; // ERROR === previous RMAP packet not processed yet
                     for(unsigned int i=0; i<packetLength; i++) rmapPacket[i] = spwPacket[i];
                     rmapPacketSize = packetLength;
                     rmapPacketSEMAPHORE->release();
             //        emit appendToLog("RMAP packet of size " + QString::number(packetLength) + " received");
             //        emit appendToLog("packet received, B0 = " + QString::number(spwPacket[0], 16)
             //                         + " *** B1 = " + QString::number(spwPacket[1], 16)
             //                         + " *** B2 = " + QString::number(spwPacket[2], 16)
             //                         + " *** B3 = " + QString::number(spwPacket[3], 16)
             //                         + " *** B4 = " + QString::number(spwPacket[4], 16)
             //                         + " *** B5 = " + QString::number(spwPacket[5], 16)
             //                         );
                     return packetLength;
                 case 2: // 0x02 is the protocole identifier for CCSDS packets
                     if (ccsdsPacketSEMAPHORE->available()!=0)
                     {
                         emit sendMessage("in function [receiveSPWPacket] === ERROR === previous CCSDS packet not processed yet");
                         return -4; // ERROR === previous CCSDS packet not processed yet
                     }
                     for(unsigned int i=0; i<packetLength; i++) ccsdsPacket[i] = spwPacket[i];
                     ccsdsPacketSize = packetLength;
                     emit appendToLog("CCSDS packet of size " + QString::number(packetLength) + " received");
                     emit appendToLog("packet received, byte0 " + QString::number(spwPacket[0], 16)
                                      + " *** byte1 " + QString::number(spwPacket[1], 16)
                                      + " *** byte2 " + QString::number(spwPacket[2], 16)
                                      + " *** byte3 " + QString::number(spwPacket[3], 16));
                     storeCCSDSPacket(ccsdsPacket, packetLength);
                     return packetLength;
                 default:
                     emit appendToLog("packet received, byte0 " + QString::number(spwPacket[0], 16)
                                      + " *** byte1 " + QString::number(spwPacket[1], 16)
                                      + " *** byte2 " + QString::number(spwPacket[2], 16)
                                      + " *** byte3 " + QString::number(spwPacket[3], 16));
                     return 0;
                 }
                 return 0;
             }
             unsigned int StarDundee::storeCCSDSPacket(unsigned char *ccsdsPacket, unsigned int size)
             {
                 TMPacketToRead *generalPacket;
                 generalPacket = new TMPacketToRead(ccsdsPacket, size);
                 emit sendPacket(generalPacket);
                 return 1;
             }
             void StarDundee::reTestSPWLink() // SLOT
             {
                 if (getLinkStatus(linkNumber_SPINBOX->value()))
                 {
                     emit isOpen(true);
                     starDundeeStatusQueryDialog->accept();
                 }
             }
             unsigned char StarDundee::getPacketFirstByte()
             {
                 unsigned char firstByte;
                 firstByte = (unsigned char) this->linkNumber_SPINBOX->value();
                 return firstByte;
             }
             //**********
             // TIMECODES
             void StarDundee::initializeTimecodeGeneration()
             {
                 U32 dwTickEnableStatus;
                 U32 rtr_clk_freq;
                 // (1) RESET
                 if (!USBSpaceWire_TC_Reset(hDevice))
                     emit sendMessage("ERR *** in Open *** Could not reset timecodes\n");
                 // (2) Clear the tick enable register
                 if (CFGSpaceWire_SetTickEnableStatus(hDevice, 6) != CFG_TRANSFER_SUCCESS)
                     emit sendMessage("Could not clear the tick enable register");
                 else
                     emit sendMessage("Cleared the tick enable register");
                 // (3) get the tick status
                 CFGSpaceWire_GetTickEnableStatus(hDevice, &dwTickEnableStatus);
                 emit sendMessage("OK *** in Open *** CFGSpaceWire_GetTickEnableStatus, code is " + QString::number(dwTickEnableStatus, 2));
                 // (4) enable external timecode selection
                 if(!USBSpaceWire_TC_EnableExternalTimecodeSelection(hDevice,0))
                     emit sendMessage("ERR *** disable external timecode selection");
                 rtr_clk_freq = USBSpaceWire_TC_GetClockFrequency(hDevice);
                 emit sendMessage("clock frequency = " + QString::number(rtr_clk_freq) );
                 if (!USBSpaceWire_TC_SetAutoTickInFrequency(hDevice, rtr_clk_freq) )
                     emit sendMessage("Could not set the tick-in frequency");
                 starDundeeSendOneTimecode->setEnabled( true );
                 starDundeeSendTimecodePeriodically->setEnabled( true );
                 starDundeeSendOneTimePacketAndOneTimecode->setEnabled( true );
                 starDundeeSendOneTimePacketAndTimecodePeriodically->setEnabled( true );
             }
             void StarDundee::sendOneTimecode()
             {
                 if(!USBSpaceWire_TC_PerformTickIn(hDevice, 0))
                     emit sendMessage("ERR *** in sendOneTimecode *** perform TickIn");
             }
             void StarDundee::sendOneTimePacketAndOneTimecode()
             {
                 sendUpdateTime( arbitraryTimeToSend );
                 QTimer::singleShot(300, this, SLOT(sendOneTimecode()));
             }
             void StarDundee::sendOneTimePacketAndTimecodePeriodically()
             {
                 sendUpdateTime( arbitraryTimeToSend );
                 starDundeeSendOneTimePacketAndTimecodePeriodically->setEnabled( false );
                 QTimer::singleShot(300, this, SLOT(sendTimecodePeriodically()));
             }
             void StarDundee::sendTimecodePeriodically()
             {
                 if (flag_sendTimecodePeriodically == false)
                 {
                     if (!USBSpaceWire_TC_EnableAutoTickIn(hDevice, 1, 1))
                         emit sendMessage("Could not enable auto tick-in");
                     flag_sendTimecodePeriodically = true;
                     this->starDundeeSendTimecodePeriodically->setText("stop timecodes at 1 Hz");
+                    starDundeeSendOneTimePacketAndTimecodePeriodically->setEnabled( false );
                 }
                 else
                 {
                     if (!USBSpaceWire_TC_EnableAutoTickIn(hDevice, 0, 0))
                         emit sendMessage("Could not disable auto tick-in");
                     flag_sendTimecodePeriodically = false;
                     this->starDundeeSendTimecodePeriodically->setText("start timecodes at 1 Hz");
                     starDundeeSendOneTimePacketAndTimecodePeriodically->setEnabled( true );
                 }
             }
+            void StarDundee::startSendingTimecodePeriodically(unsigned char onOff)
+            {
+                if (onOff == 0)
+                {
+                    if (!USBSpaceWire_TC_EnableAutoTickIn(hDevice, 0, 0))
+                        emit sendMessage("Could not disable auto tick-in");
+                    flag_sendTimecodePeriodically = false;
+                    this->starDundeeSendTimecodePeriodically->setText("start timecodes at 1 Hz");
+                    starDundeeSendOneTimePacketAndTimecodePeriodically->setEnabled( true );
+                }
+                else
+                {
+                    if (!USBSpaceWire_TC_EnableAutoTickIn(hDevice, 1, 1))
+                        emit sendMessage("Could not enable auto tick-in");
+                    flag_sendTimecodePeriodically = true;
+                    this->starDundeeSendTimecodePeriodically->setText("stop timecodes at 1 Hz");
+                    starDundeeSendOneTimePacketAndTimecodePeriodically->setEnabled( false );
+                }
+            }
             void StarDundee::sendUpdateTime(long time)
             {
                 Packet_TC_LFR_UPDATE_TIME_t packet;
                 unsigned char crcAsTwoBytes[2];
                 packet.packetID[0] = (unsigned char) (TC_LFR_PACKET_ID >> 8);
                 packet.packetID[1] = (unsigned char) (TC_LFR_PACKET_ID     );
                 packet.packetSequenceControl[0] = (unsigned char) (TC_LFR_PACKET_SEQUENCE_CONTROL >> 8);
                 packet.packetSequenceControl[1] = (unsigned char) (TC_LFR_PACKET_SEQUENCE_CONTROL     );
                 packet.packetLength[0] = (unsigned char) (PACKET_LENGTH_TC_LFR_UPDATE_TIME >> 8);
                 packet.packetLength[1] = (unsigned char) (PACKET_LENGTH_TC_LFR_UPDATE_TIME     );
                 packet.ccsdsSecHeaderFlag_pusVersion_ack = 0x19;
                 packet.serviceType = TC_TYPE_LFR_UPDATE_TIME;
                 packet.serviceSubType = TC_SUBTYPE_UPDATE_TIME;
                 packet.sourceID = SID_TC_RPW_INTERNAL;
                 packet.cp_rpw_time[0] = (unsigned char) (time >> 24);
                 packet.cp_rpw_time[1] = (unsigned char) (time >> 16);
                 packet.cp_rpw_time[2] = (unsigned char) (time >> 8);
                 packet.cp_rpw_time[3] = (unsigned char) (time);
                 packet.cp_rpw_time[4] = 0; // fine time MSB
                 packet.cp_rpw_time[5] = 0; // fine time LSB
                 paulCommonCRC->GetCRCAsTwoBytes((unsigned char*) &packet, crcAsTwoBytes,
                                                PACKET_LENGTH_TC_LFR_UPDATE_TIME + CCSDS_TC_TM_PACKET_OFFSET - 2);
                 packet.crc[0] = crcAsTwoBytes[0];
                 packet.crc[1] = crcAsTwoBytes[1];
                 WriteSPW((char*) &packet, PACKET_LENGTH_TC_LFR_UPDATE_TIME + CCSDS_TC_TM_PACKET_OFFSET,
                                  CCSDS_NODE_ADDRESS, CCSDS_USER_APP);
             }
             void StarDundee::updateTimeToSend(long timeToSend)
             {
                 arbitraryTimeToSend = timeToSend;
             }

rmapplugin/stardundee.h +1 0

             #ifndef STARDUNDEE_H
             #define STARDUNDEE_H
             #include <QWidget>
             #include <QPushButton>
             #include <QGridLayout>
             #include <QSpinBox>
             #include <QLabel>
             #include <QSemaphore>
             #include <QTimer>
             #include <QDialog>
             #include <arbitrarytime.h>
             #include <TC_types.h>
             #include <paulcommoncrc.h>
             #include "rmapoperations.h"
             #include "spw_usb_api.h"
             #include "spw_config_library.h"
             #include "ccsds.h"
             #include "tmpackettoread.h"
             #define BWAIT_0 0
             #define BWAIT_1 1
             #define PATH_ADDRESSING_OFFSET 1
             class StarDundee : public QWidget
             {
                 Q_OBJECT
             public:
                 explicit StarDundee(QWidget *parent = 0);
                 ~StarDundee();
                 unsigned int Write(unsigned int *Value,unsigned int count,unsigned int address=0);
                 unsigned int Read(unsigned int *Value,unsigned int count,unsigned int address=0);
                 unsigned int WriteSPW(char *Value, unsigned int count, char targetLogicalAddress, char userApplication);
                 unsigned int storeCCSDSPacket(unsigned char *ccsdsPacket, unsigned int size);
                 void initializeTimecodeGeneration();
                 void sendUpdateTime(long time);
             signals:
                 void sendMessage(QString message);
                 void sendPacket(TMPacketToRead*);
                 void isOpen(bool);
                 void RMAP_write_reply_setText(QString);
                 void appendToLog(QString);
             public slots:
                 bool Open();
                 void Close();
                 void reTestSPWLink();
                 int receiveSPWPacketLoop(unsigned char requestID=0);
                 int receiveSPWPacket(unsigned char requestID=0);
                 void commandCodeHasChanged(RMAP_command_codes code) {this->commandCode = code;}
                 void targetHasChanged(int target) {rmapTargetLogicalAddress = (unsigned char) target;}
                 void sourceHasChanged(int source) {rmapSourceLogicalAddress = (unsigned char) source;}
                 void spaceWireLinkHasChanged(unsigned char spaceWireLink);
                 void ccsdsPacketIsProcessed() {ccsdsPacketSEMAPHORE->tryAcquire();}
                 //
                 void receivePollingLoop();
                 // TIMECODES
                 void sendOneTimecode();
                 void sendTimecodePeriodically();
+                void startSendingTimecodePeriodically( unsigned char onOff );
                 void sendOneTimePacketAndOneTimecode();
                 void sendOneTimePacketAndTimecodePeriodically();
                 void updateTimeToSend(long timeToSend);
             private:
                 unsigned int WriteBLOCK(char *data,unsigned int nbBytes,unsigned int address=0);
                 unsigned int ReadBLOCK(unsigned int nbBytes,unsigned int address=0);
                 void acquireRMAPSemaphore() {rmapPacketSEMAPHORE->tryAcquire();}
                 void acquireCCSDSSemaphore() {ccsdsPacketSEMAPHORE->tryAcquire();}
                 unsigned char setRoutingTableEntry(int tableEntry, U32 dwOutputPorts);
                 unsigned int GetRoutingTableEntry(int tableEntry);
                 unsigned int getLinkStatus(unsigned char link);
                 unsigned char getPacketFirstByte();
                 unsigned char rmapTargetLogicalAddress ;
                 unsigned char rmapSourceLogicalAddress ;
                 RMAP_command_codes commandCode;
                 QLabel *usbDeviceNumber_LABEL;
                 QLabel *linkNumber_LABEL;
                 QLabel *starDundeeStatusQueryDialogLabel;
                 QLabel *statusLink1;
                 QLabel *statusLink2;
                 QSpinBox *usbDeviceNumber_SPINBOX;
                 QSpinBox *linkNumber_SPINBOX;
                 QGridLayout *connection_LAYOUT;
                 QGridLayout *starDundeeStatusQueryDialogLayout;
                 QDialog *starDundeeStatusQueryDialog;
                 QPushButton *starDundeeStatusQueryRetryButton;
                 QPushButton *starDundeeStatusQueryAbortButton;
                 QPushButton *starDundeeStatusQueryContinueButton;
                 QPushButton *starDundeeSendOneTimecode;
                 QPushButton *starDundeeSendOneTimePacketAndOneTimecode;
                 QPushButton *starDundeeSendTimecodePeriodically;
                 QPushButton *starDundeeSendOneTimePacketAndTimecodePeriodically;
                 ArbitraryTime *arbitraryTime;
                 long arbitraryTimeToSend;
                 PaulCommonCRC *paulCommonCRC;
                 bool flag_sendTimecodePeriodically;
                 QTimer *timer;
                 unsigned char pBuffer[10];          // Pointer to the start of the user buffer from which to transmit data
                 USB_SPACEWIRE_ID pIdentifierRead;   // A pointer to a variable which will be set to contain a unique identifier for the read
                 USB_SPACEWIRE_ID pIdentifier;
                 star_device_handle hDevice;     // Handle to the SpaceWire device
                 USB_SPACEWIRE_STATUS result;    // The result of the send operation
                 // Packet receiver
                 QSemaphore *rmapPacketSEMAPHORE;
                 QSemaphore *ccsdsPacketSEMAPHORE;
                 char* rmapPacket;      // The buffer to receive RMAP READ packets
                 unsigned char *ccsdsPacket;
                 char *spwPacket;
                 unsigned int rmapPacketSize;
                 unsigned int ccsdsPacketSize;
             };
             #endif // STARDUNDEE_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