HG_REPOSITORIES/LPP/INSTRUMENTATION/SocExplorerPlugins Commit - r38:6939a908c25c

timecodes added to the spw plugin

paul -

parent child

Context file:

r38:6939a908c25c

Collapse all files

spwplugin/StarDundee/stardundeeGUI.ui +29 -8

                 <x>0</x>
                 <y>0</y>
                 <width>397</width>
-                <height>467</height>
+                <height>506</height>
                </rect>
               </property>
               <property name="windowTitle">
                 </widget>
                </item>
                <item row="3" column="1">
-                <widget class="QLineEdit" name="destKeyLineEdit">
+                <widget class="QLineEdit" name="sourceAddressLineEdit">
                  <property name="toolTip">
                   <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Set the Space Wire Brick destination Key, the default value is 32 (0x20).&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
                  </property>
                 </widget>
                </item>
                <item row="4" column="1">
-                <widget class="QLineEdit" name="RMAPAddresslineEdit">
+                <widget class="QLineEdit" name="destinationAddressLineEdit">
                  <property name="toolTip">
                   <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Set the RMAP target address, this address will be used as destination address for all the RMAP transfers.&lt;/p&gt;&lt;p&gt;This is you SOC spw address.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
                  </property>
                 </widget>
                </item>
                <item row="5" column="1">
-                <widget class="QLineEdit" name="RMAPKeylineEdit">
+                <widget class="QLineEdit" name="destinationKeyLineEdit">
                  <property name="toolTip">
                   <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Set the RMAP target key, this key will be used for all the RMAP transfers.&lt;/p&gt;&lt;p&gt;This is you SOC spw key.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
                  </property>
                  </property>
                 </widget>
                </item>
-               <item row="9" column="1">
+               <item row="10" column="1">
                 <widget class="QPushButton" name="connectQpb">
                  <property name="text">
                   <string>Connect</string>
                  </property>
                 </widget>
                </item>
-               <item row="7" column="1">
+               <item row="8" column="1">
                 <widget class="QRadioButton" name="setInterfaceModeQrb">
                  <property name="text">
                   <string>interface mode</string>
                  </property>
                 </widget>
                </item>
-               <item row="8" column="1">
+               <item row="9" column="1">
                 <widget class="QRadioButton" name="setRouterModeQrb">
                  <property name="text">
                   <string>router mode</string>
                  </property>
                 </widget>
                </item>
-               <item row="10" column="0" colspan="2">
+               <item row="11" column="0" colspan="2">
                 <layout class="QGridLayout" name="gridLayout">
                  <item row="1" column="0">
                   <widget class="QLabel" name="label_4">
                  </item>
                 </layout>
                </item>
+               <item row="8" column="0">
+                <widget class="QCheckBox" name="spwTimecodes">
+                 <property name="text">
+                  <string>timecode</string>
+                 </property>
+                </widget>
+               </item>
+               <item row="7" column="0">
+                <widget class="QLabel" name="label">
+                 <property name="text">
+                  <string>Timecode f (Hz)</string>
+                 </property>
+                </widget>
+               </item>
+               <item row="7" column="1">
+                <widget class="QLineEdit" name="timecodeFrequencyLineEdit">
+                 <property name="text">
+                  <string>1</string>
+                 </property>
+                </widget>
+               </item>
               </layout>
              </widget>
              <resources/>

spwplugin/StarDundee/stardundeegui.cpp +55 -21

                 connect(this->ui->selectBrickCmbx,SIGNAL(currentIndexChanged(int)),this,SIGNAL(brickSelectionChanged(int)));
                 connect(this->ui->selectLinkCmbx,SIGNAL(currentIndexChanged(int)),this,SIGNAL(linkNumberSelectionChanged(int)));
                 connect(this->ui->setLinkSpeedCmbx,SIGNAL(currentIndexChanged(QString)),this,SIGNAL(linkSpeedSelectionChanged(QString)));
-                connect(this->ui->destKeyLineEdit,SIGNAL(textChanged(QString)),this,SIGNAL(destinationKeyChanged(QString)));
+                connect(this->ui->sourceAddressLineEdit,SIGNAL(textChanged(QString)),this,SIGNAL(destinationKeyChanged(QString)));
-                connect(this->ui->RMAPAddresslineEdit,SIGNAL(textChanged(QString)),this,SIGNAL(rmapAddressChanged(QString)));
+                connect(this->ui->destinationAddressLineEdit,SIGNAL(textChanged(QString)),this,SIGNAL(rmapAddressChanged(QString)));
-                connect(this->ui->RMAPKeylineEdit,SIGNAL(textChanged(QString)),this,SIGNAL(rmapKeyChanged(QString)));
+                connect(this->ui->destinationKeyLineEdit,SIGNAL(textChanged(QString)),this,SIGNAL(rmapKeyChanged(QString)));
                 connect(this->ui->RMAPTimeoutLineEdit,SIGNAL(textChanged(QString)),this,SIGNAL(rmapTimeoutChanged(QString)));
+                connect(this->ui->timecodeFrequencyLineEdit, SIGNAL(textChanged(QString)), this, SIGNAL(timecodeFrequencyChange(QString)));
                 connect(this->ui->connectQpb,SIGNAL(clicked()),this,SIGNAL(connectClicked()));
                 connect(this->ui->setInterfaceModeQrb, SIGNAL(toggled(bool)), this, SIGNAL(brickModeChanged(bool)));
                 connect(this->ui->resetStatsQpb, SIGNAL(clicked()), this, SLOT(resetStatistics()));
+                connect(this->ui->spwTimecodes, SIGNAL(toggled(bool)), this, SIGNAL(startSendingTimecode(bool)));
             }
             int StarDundeeGUI::getBrickSelection()
                 return ui->setLinkSpeedCmbx->currentText();
             }
-            QString StarDundeeGUI::getDestinationKey()
+            QString StarDundeeGUI::getSourceAddress()
             {
-                return ui->destKeyLineEdit->text();
+                return ui->sourceAddressLineEdit->text();
             }
-            QString StarDundeeGUI::getRmapAddress()
+            QString StarDundeeGUI::getDestinationAddress()
             {
-                return ui->RMAPAddresslineEdit->text();
+                return ui->destinationAddressLineEdit->text();
             }
-            QString StarDundeeGUI::getRmapKey()
+            QString StarDundeeGUI::getDestinationKey()
             {
-                return ui->RMAPKeylineEdit->text();
+                return ui->destinationKeyLineEdit->text();
             }
             QString StarDundeeGUI::getRmapTimeout()
                 return ui->RMAPTimeoutLineEdit->text();
             }
+            QString StarDundeeGUI::getTimecodeFrequency()
+            {
+                return ui->timecodeFrequencyLineEdit->text();
+            }
+            bool StarDundeeGUI::getStartSendingTimecodes()
+            {
+                return ui->spwTimecodes->isChecked();
+            }
             bool StarDundeeGUI::isBrickSetAsAnInterface()
             {
                 return ui->setInterfaceModeQrb->isChecked();
                 this->ui->selectBrickCmbx->setDisabled(lock);
                 this->ui->selectLinkCmbx->setDisabled(lock);
                 this->ui->setLinkSpeedCmbx->setDisabled(lock);
-                this->ui->destKeyLineEdit->setDisabled(lock);
+                this->ui->sourceAddressLineEdit->setDisabled(lock);
-                this->ui->RMAPAddresslineEdit->setDisabled(lock);
+                this->ui->destinationAddressLineEdit->setDisabled(lock);
-                this->ui->RMAPKeylineEdit->setDisabled(lock);
+                this->ui->destinationKeyLineEdit->setDisabled(lock);
                 this->ui->RMAPTimeoutLineEdit->setDisabled(lock);
                 this->ui->setInterfaceModeQrb->setDisabled(lock);
                 this->ui->setRouterModeQrb->setDisabled(lock);
                 }
             }
-            void StarDundeeGUI::setDestinationKey(const QString &destKey)
+            void StarDundeeGUI::setSourceAddress(const QString &address)
             {
                 bool ok;
-                int Key=destKey.toInt(&ok,10);
+                address.toInt(&ok,10);
                 if(ok)
                 {
-                    this->ui->destKeyLineEdit->setText(destKey);
+                    this->ui->sourceAddressLineEdit->setText(address);
+                }
+            }
+            void StarDundeeGUI::setDestinationAddress(const QString &address)
+            {
+                bool ok;
+                address.toInt(&ok,10);
+                if(ok)
+                {
+                    this->ui->destinationAddressLineEdit->setText(address);
                 }
             }
-            void StarDundeeGUI::setRmapAddress(const QString &address)
+            void StarDundeeGUI::setDestinationKey(const QString &key)
             {
                 bool ok;
-                int tmp=address.toInt(&ok,10);
+                key.toInt(&ok,10);
                 if(ok)
                 {
-                    this->ui->RMAPAddresslineEdit->setText(address);
+                    this->ui->destinationKeyLineEdit->setText(key);
                 }
             }
-            void StarDundeeGUI::setRmapKey(const QString &key)
+            void StarDundeeGUI::setTimecodeFrequency(const QString &frequency)
             {
                 bool ok;
-                int tmp=key.toInt(&ok,10);
+                frequency.toDouble(&ok);
                 if(ok)
                 {
-                    this->ui->RMAPKeylineEdit->setText(key);
+                    this->ui->timecodeFrequencyLineEdit->setText(frequency);
+                }
+            }
+            void StarDundeeGUI::setStartSendingTimecodes( bool onOff )
+            {
+                if (this->ui->spwTimecodes->isChecked())
+                {
+                    if (onOff==false) this->ui->spwTimecodes->setChecked(false);
+                }
+                else
+                {
+                    if (onOff==true) this->ui->spwTimecodes->setChecked(true);
                 }
             }

spwplugin/StarDundee/stardundeegui.h +10 -4

                 int getBrickSelection();
                 int getLinkNumberSelection();
                 QString getLinkSpeedSelection();
+                QString getSourceAddress();
+                QString getDestinationAddress();
                 QString getDestinationKey();
-                QString getRmapAddress();
-                QString getRmapKey();
                 QString getRmapTimeout();
+                QString getTimecodeFrequency();
+                bool getStartSendingTimecodes();
                 bool isBrickSetAsAnInterface();
             signals:
                 void brickSelectionChanged(int brickIndex);
                 void rmapAddressChanged(const QString & address);
                 void rmapKeyChanged(const QString & key);
                 void rmapTimeoutChanged(const QString & timeout);
+                void timecodeFrequencyChange(const QString & timeout);
                 void connectClicked();
                 void brickModeChanged(bool);
+                void startSendingTimecode(bool);
             public slots:
                 void lock(bool lock);
                 void updateAvailableBrickCount(int count);
                 void selectLinkNumber(int linkIndex);
                 void selectLinkSpeed(int linkSpeed);
                 void setDestinationKey(const QString & destKey);
-                void setRmapAddress(const QString & address);
+                void setSourceAddress(const QString & address);
-                void setRmapKey(const QString & key);
+                void setDestinationAddress(const QString & address);
+                void setTimecodeFrequency(const QString &frequency);
+                void setStartSendingTimecodes( bool onOff );
                 void setRmapTimeout(const QString & timeout);
                 int getAvailableBrickCount( void );
                 void setBrickAsAnInterface(bool interfaceMode);

spwplugin/StarDundee/stardundeespw_usb.cpp +56 -21

             {
                 if(this->manager->connectBridge())
                 {
+                    this->timecodeFrequencyChanged(   ((StarDundeeGUI*)this->p_GUI)->getTimecodeFrequency());
+                    this->startSendingTimecodes(      ((StarDundeeGUI*)this->p_GUI)->getStartSendingTimecodes());
                     ((StarDundeeGUI*)this->p_GUI)->lock(true);
                     emit setConnected(true);
                     return true;
                 SocExplorerEngine::message(plugin,QString("Changing Destination Key: %1").arg(manager->sourceLogicalAddress),1);
             }
-            void stardundeeSPW_USB::rmapAddressChanged(const QString &rmapaddress)
+            void stardundeeSPW_USB::destinationAddressChanged(const QString &rmapaddress)
             {
                 this->manager->destinationLogicalAddress = rmapaddress.toInt();
                 SocExplorerEngine::message(plugin,QString("Changing RMAP address: %1").arg(manager->destinationLogicalAddress),1);
                 this->manager->interfaceMode = interfaceMode;
             }
+            void stardundeeSPW_USB::timecodeFrequencyChanged(const QString &frequency)
+            {
+                this->manager->timecodeFrequency = frequency.toDouble();
+                this->manager->setTimecodeFrequency( this->manager->timecodeFrequency);
+                SocExplorerEngine::message(plugin,QString("Changing timecode frequency: %1").arg(manager->timecodeFrequency),1);
+            }
+            void stardundeeSPW_USB::startSendingTimecodes(bool onOff )
+            {
+                this->manager->sendTimecodePeriodically( onOff );
+            }
             void stardundeeSPW_USB::rmapTimeoutChanged(const QString &timeout)
             {
                 int tim=timeout.toInt();
                 connect(((StarDundeeGUI*)this->p_GUI),SIGNAL(linkNumberSelectionChanged(int)),this,SLOT(linkNumberSelectionChanged(int)));
                 connect(((StarDundeeGUI*)this->p_GUI),SIGNAL(linkSpeedSelectionChanged(QString)),this,SLOT(linkSpeedSelectionChanged(QString)));
                 connect(((StarDundeeGUI*)this->p_GUI),SIGNAL(sourceLogicalAddressChanged(QString)),this,SLOT(sourceLogicalAddressChanged(QString)));
-                connect(((StarDundeeGUI*)this->p_GUI),SIGNAL(rmapAddressChanged(QString)),this,SLOT(rmapAddressChanged(QString)));
+                connect(((StarDundeeGUI*)this->p_GUI),SIGNAL(rmapAddressChanged(QString)),this,SLOT(destinationAddressChanged(QString)));
                 connect(((StarDundeeGUI*)this->p_GUI),SIGNAL(destinationKeyChanged(QString)),this,SLOT(destinationKeyChanged(QString)));
                 connect(((StarDundeeGUI*)this->p_GUI),SIGNAL(rmapTimeoutChanged(QString)),this,SLOT(rmapTimeoutChanged(QString)));
                 connect(((StarDundeeGUI*)this->p_GUI),SIGNAL(brickModeChanged(bool)), this, SLOT(brickModeChanged(bool)));
+                connect(((StarDundeeGUI*)this->p_GUI),SIGNAL(timecodeFrequencyChange(QString)), this, SLOT(timecodeFrequencyChanged(QString)));
+                connect(((StarDundeeGUI*)this->p_GUI),SIGNAL(startSendingTimecode(bool)), this, SLOT(startSendingTimecodes(bool)));
                 this->brickSelectionChanged(      ((StarDundeeGUI*)this->p_GUI)->getBrickSelection());
                 this->linkNumberSelectionChanged( ((StarDundeeGUI*)this->p_GUI)->getLinkNumberSelection());
                 this->linkSpeedSelectionChanged(  ((StarDundeeGUI*)this->p_GUI)->getLinkSpeedSelection());
-                this->sourceLogicalAddressChanged(((StarDundeeGUI*)this->p_GUI)->getDestinationKey());
+                this->sourceLogicalAddressChanged(((StarDundeeGUI*)this->p_GUI)->getSourceAddress());
-                this->rmapAddressChanged(((StarDundeeGUI*)this->p_GUI)->getRmapAddress());
+                this->destinationAddressChanged(  ((StarDundeeGUI*)this->p_GUI)->getDestinationAddress());
-                this->destinationKeyChanged(((StarDundeeGUI*)this->p_GUI)->getRmapKey());
+                this->destinationKeyChanged(      ((StarDundeeGUI*)this->p_GUI)->getDestinationKey());
                 this->rmapTimeoutChanged(         ((StarDundeeGUI*)this->p_GUI)->getRmapTimeout());
                 this->brickModeChanged(           ((StarDundeeGUI*)this->p_GUI)->isBrickSetAsAnInterface());
                 connect(this,SIGNAL(SelectLinkNumber(int)),         ((StarDundeeGUI*)this->p_GUI),SLOT(selectLinkNumber(int)));
                 connect(this,SIGNAL(SelectLinkSpeed(int)),          ((StarDundeeGUI*)this->p_GUI),SLOT(selectLinkSpeed(int)));
                 connect(this,SIGNAL(SetDestinationKey(QString)),    ((StarDundeeGUI*)this->p_GUI),SLOT(setDestinationKey(QString)));
-                connect(this,SIGNAL(SetRmapAddress(QString)),     ((StarDundeeGUI*)this->p_GUI),SLOT(setRmapAddress(QString)));
+                connect(this,SIGNAL(SetDestinationAddress(QString)),((StarDundeeGUI*)this->p_GUI),SLOT(setDestinationAddress(QString)));
-                connect(this,SIGNAL(SetRmapKey(QString)),         ((StarDundeeGUI*)this->p_GUI),SLOT(setRmapKey(QString)));
+                connect(this,SIGNAL(SetSourceAddress(QString)),     ((StarDundeeGUI*)this->p_GUI),SLOT(setSourceAddress(QString)));
                 connect(this,SIGNAL(SetRmapTimeout(QString)),       ((StarDundeeGUI*)this->p_GUI),SLOT(setRmapTimeout(QString)));
                 connect(this,SIGNAL(GetAvailableBrickCount()),      ((StarDundeeGUI*)this->p_GUI),SLOT(getAvailableBrickCount()));
                 connect(this,SIGNAL(SetBrickAsAnInterface(bool)),   ((StarDundeeGUI*)this->p_GUI),SLOT(setBrickAsAnInterface(bool)));
                 connect(this,SIGNAL(SetBrickAsARouter(bool)),       ((StarDundeeGUI*)this->p_GUI),SLOT(setBrickAsARouter(bool)));
                 connect(this,SIGNAL(BytesReceivedFromSpw(uint)),    ((StarDundeeGUI*)this->p_GUI),SLOT(updateNbReceivedBytesFromSpw(uint)));
                 connect(this,SIGNAL(BytesTransmittedToSpw(uint)),   ((StarDundeeGUI*)this->p_GUI),SLOT(updateNbTransmittedBytesToSpw(uint)));
+                connect(this,SIGNAL(SetTimecodeFrequency(double)),  ((StarDundeeGUI*)this->p_GUI),SLOT(setTimecodeFrequency(QString)));
+                connect(this,SIGNAL(StartSendingTimecodes(bool)),   ((StarDundeeGUI*)this->p_GUI),SLOT(setStartSendingTimecodes(bool)));
             }
             void stardundeeSPW_USB::sendPacketComingFromTCPServer(char *packet, int size)
                 RMAP_AnswersMtx->unlock();
             }
+            void stardundeeSPW_USB_Manager::sendTimecodePeriodically( bool onOff )
+            {
+                if (onOff == true)
+                {
+                    if (!USBSpaceWire_TC_EnableAutoTickIn(hDevice, 1, 1))
+                        SocExplorerEngine::message(this->plugin,"Could not enable auto tick-in");
+                }
+                else
+                {
+                    if (!USBSpaceWire_TC_EnableAutoTickIn(hDevice, 0, 0))
+                        SocExplorerEngine::message(this->plugin,"Could not disable auto tick-in");
+                }
+            }
+            void stardundeeSPW_USB_Manager::setTimecodeFrequency(double requestedFrequency)
+            {
+                U32 rtr_clk_freq;
+                U32 freqCount;
+                double freqCountInDouble;
+                double currentFrequency;
+                rtr_clk_freq = USBSpaceWire_TC_GetClockFrequency(hDevice);
+                freqCountInDouble = ((double) rtr_clk_freq) / requestedFrequency;
+                freqCount = (unsigned int) freqCountInDouble;
+                currentFrequency = ((double) rtr_clk_freq) / ((double) freqCount);
+                //**************************************************
+                // auto _ tick _ freq = rtr _ clk _ freq / freqCount
+                if (!USBSpaceWire_TC_SetAutoTickInFrequency(hDevice, freqCount) )
+                    SocExplorerEngine::message(this->plugin,"Could not set the tick-in frequency");
+                else
+                    SocExplorerEngine::message(this->plugin,"tick frequency set to " + QString::number(currentFrequency) +" Hz");
+            }

spwplugin/StarDundee/stardundeespw_usb.h +12 -3

                 unsigned char setRoutingTableEntry(int tableEntry, U32 dwOutputPorts, char bDelHead);
                 unsigned int getRoutingTableEntry(int tableEntry);
                 void initializeTimecodeGeneration();
+                void setTimecodeFrequency(double requestedFrequency);
                 unsigned int getLinkStatus(unsigned char link);
                 bool disconnectBridge();
                 int getRMAPtransactionID();
                 void bytesReceivedFromSpw( unsigned int );
                 void bytesTransmittedToSpw( unsigned int);
+            public slots:
+                void sendTimecodePeriodically( bool onOff );
             private:
                 QMutex* handleMutex,*RMAP_AnswersMtx,*RMAP_pending_transaction_IDsMtx;
                 QSemaphore* RMAP_AnswersSem;
                 int destinationLogicalAddress;
                 int destinationKey;
                 int RMAPtimeout;
+                double timecodeFrequency;
                 bool interfaceMode; // 1 => interface mode, 0 => router mode
             };
                 void SelectLinkNumber(int linkIndex);
                 void SelectLinkSpeed(int linkSpeed);
                 void SetDestinationKey(const QString & destKey);
-                void SetRmapAddress(const QString & address);
+                void SetSourceAddress(const QString & address);
-                void SetRmapKey(const QString & key);
+                void SetDestinationAddress(const QString & address);
                 void SetRmapTimeout(const QString & timeout);
+                void SetTimecodeFrequency( double );
                 void SetBrickAsAnInterface( bool );
                 void SetBrickAsARouter( bool );
                 int GetAvailableBrickCount( void );
                 void BytesReceivedFromSpw( unsigned int );
                 void BytesTransmittedToSpw( unsigned int );
+                void StartSendingTimecodes( bool );
             public slots:
                 void toggleBridgeConnection();
                 void linkNumberSelectionChanged(int linkIndex);
                 void linkSpeedSelectionChanged(const QString & linkSpeed);
                 void sourceLogicalAddressChanged(const QString & destKey);
-                void rmapAddressChanged(const QString & rmapaddress);
+                void destinationAddressChanged(const QString & rmapaddress);
                 void brickModeChanged( bool interfaceMode );
                 void destinationKeyChanged(const QString & key);
                 void rmapTimeoutChanged(const QString & timeout);
                 void sendPacketComingFromTCPServer(char *packet, int size);
+                void timecodeFrequencyChanged(const QString &frequency);
+                void startSendingTimecodes( bool onOff );
             private:
                 void makeGUI(socexplorerplugin *parent);
                 stardundeeSPW_USB_Manager* manager;

spwplugin/spwplugin.cpp +6 -2

                     connect(((spwPyWrapper*)this->pyObject),SIGNAL(StarDundeeSelectBrick(int)),((stardundeeSPW_USB*)bridge),SIGNAL(SelectBrick(int)));
                     connect(((spwPyWrapper*)this->pyObject),SIGNAL(StarDundeeSelectLinkNumber(int)),((stardundeeSPW_USB*)bridge),SIGNAL(SelectLinkNumber(int)));
                     connect(((spwPyWrapper*)this->pyObject),SIGNAL(StarDundeeSelectLinkSpeed(int)),((stardundeeSPW_USB*)bridge),SIGNAL(SelectLinkSpeed(int)));
+                    connect(((spwPyWrapper*)this->pyObject),SIGNAL(StarDundeeSetSourceAddress(QString)),((stardundeeSPW_USB*)bridge),SIGNAL(SetSourceAddress(QString)));
+                    connect(((spwPyWrapper*)this->pyObject),SIGNAL(StarDundeeSetDestinationAddress(QString)),((stardundeeSPW_USB*)bridge),SIGNAL(SetDestinationAddress(QString)));
                     connect(((spwPyWrapper*)this->pyObject),SIGNAL(StarDundeeSetDestinationKey(QString)),((stardundeeSPW_USB*)bridge),SIGNAL(SetDestinationKey(QString)));
-                    connect(((spwPyWrapper*)this->pyObject),SIGNAL(StarDundeeSetRmapAddress(QString)),((stardundeeSPW_USB*)bridge),SIGNAL(SetRmapAddress(QString)));
-                    connect(((spwPyWrapper*)this->pyObject),SIGNAL(StarDundeeSetRmapKey(QString)),((stardundeeSPW_USB*)bridge),SIGNAL(SetRmapKey(QString)));
                     connect(((spwPyWrapper*)this->pyObject),SIGNAL(StarDundeeSetRmapTimeout(QString)),((stardundeeSPW_USB*)bridge),SIGNAL(SetRmapTimeout(QString)));
                     connect(((spwPyWrapper*)this->pyObject),SIGNAL(connectBridge()),((stardundeeSPW_USB*)bridge),SLOT(connectBridge()));
                     connect(((spwPyWrapper*)this->pyObject),SIGNAL(disconnectBridge()),((stardundeeSPW_USB*)bridge),SLOT(disconnectBridge()));
                             ((stardundeeSPW_USB*)bridge),SIGNAL(SetBrickAsAnInterface(bool)));
                     connect(((spwPyWrapper*)this->pyObject),SIGNAL(StarDundeeSetBrickAsARouter(bool)),
                             ((stardundeeSPW_USB*)bridge),SIGNAL(SetBrickAsARouter(bool)));
+                    connect(((spwPyWrapper*)this->pyObject),SIGNAL(StarDundeeStartTimecodes(bool)),
+                            ((stardundeeSPW_USB*)bridge),SIGNAL(StartSendingTimecodes(bool)));
+                    connect(((spwPyWrapper*)this->pyObject),SIGNAL(StarDundeeSetTimecodeFrequency(double)),
+                            ((stardundeeSPW_USB*)bridge),SIGNAL(SetTimecodeFrequency(double)));
                     connect(this->bridge,SIGNAL(pushPacketOverTCP(char*,int)),this->tcpServer,SLOT(pushPacket(char*,int)));
                     connect(this->tcpServer, SIGNAL(sendSPWPacket(char*,int)), ((stardundeeSPW_USB*)bridge), SLOT(sendPacketComingFromTCPServer(char*,int)));
                 }

spwplugin/spwpywrapper.h +5 -3

                 void StarDundeeSelectBrick(int brickIndex);
                 void StarDundeeSelectLinkNumber(int linkIndex);
                 void StarDundeeSelectLinkSpeed(int linkSpeed);
-                void StarDundeeSetDestinationKey(const QString & destKey);
+                void StarDundeeSetSourceAddress(const QString & destKey);
-                void StarDundeeSetRmapAddress(const QString & address);
+                void StarDundeeSetDestinationAddress(const QString & address);
-                void StarDundeeSetRmapKey(const QString & key);
+                void StarDundeeSetDestinationKey(const QString & key);
                 void StarDundeeSetRmapTimeout(const QString & timeout);
                 int StarDundeeGetAvailableBrickCount();
                 void StarDundeeSetBrickAsAninterface( bool );
                 void StarDundeeSetBrickAsARouter( bool );
+                void StarDundeeSetTimecodeFrequency( double );
+                void StarDundeeStartTimecodes( bool );
                 void TCPServerConnect();
                 void TCPServerDisconnect();

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