|
|
#include "mainwindow.h"
|
|
|
|
|
|
MainWindow::MainWindow(QWidget *parent) :
|
|
|
QWidget(parent)
|
|
|
{
|
|
|
hDevice = NULL;
|
|
|
UI = new mainwindowui();
|
|
|
time = new QTimer();
|
|
|
systemTime = 0x80000000;
|
|
|
flag_sendTimePacket = false;
|
|
|
|
|
|
packetToSend = new TCPacketToSend();
|
|
|
|
|
|
time->setInterval(1000);
|
|
|
|
|
|
connect(UI->starDundeeStatusQueryRetryButton, SIGNAL(clicked()), this, SLOT(reTestSPWLink()));
|
|
|
connect(this, SIGNAL(sendMessage(QString)), this->UI, SLOT(displayMessage(QString)));
|
|
|
connect(this, SIGNAL(systemTimeHasChanged(long)), this->UI->systemTime, SLOT(systemTimeHasChanged(long)));
|
|
|
|
|
|
connect(UI->startTimeButton, SIGNAL(clicked()), this, SLOT(sendTimecodesPeriodically()));
|
|
|
connect(UI->sendTimecodeButton, SIGNAL(clicked()), this, SLOT(sendOneTimecode()));
|
|
|
connect(UI->button_sendSystemTime, SIGNAL(clicked()), this, SLOT(sendSystemTime()));
|
|
|
connect(UI->button_sendArbitraryTime, SIGNAL(clicked()), this, SLOT(sendArbitraryTime()));
|
|
|
|
|
|
connect(this->time, SIGNAL(timeout()), this, SLOT(periodicalTimecodeTimeout()));
|
|
|
|
|
|
this->setLayout(UI->layout());
|
|
|
|
|
|
}
|
|
|
|
|
|
MainWindow::~MainWindow()
|
|
|
{
|
|
|
|
|
|
}
|
|
|
|
|
|
void MainWindow::sendOneTimecode()
|
|
|
{
|
|
|
unsigned int result;
|
|
|
U32 timecodeReg, val;
|
|
|
|
|
|
if (hDevice==NULL)
|
|
|
{
|
|
|
result = Open();
|
|
|
}
|
|
|
|
|
|
if (!getLinkStatus(UI->linkNumber_SPINBOX->value()))
|
|
|
{
|
|
|
emit sendMessage("ERR *** in sendOneTimecode *** stardundee brick not running");
|
|
|
}
|
|
|
|
|
|
if(!USBSpaceWire_TC_EnableExternalTimecodeSelection(hDevice,0))
|
|
|
{
|
|
|
emit sendMessage("ERR *** disable external timecode selection");
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
if(!USBSpaceWire_TC_PerformTickIn(hDevice, 0))
|
|
|
{
|
|
|
emit sendMessage("ERR *** in sendOneTimecode *** perform TickIn");
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// Read the timecode register
|
|
|
if (CFGSpaceWire_GetTimecodeRegister(hDevice, &timecodeReg) != CFG_TRANSFER_SUCCESS)
|
|
|
{
|
|
|
emit sendMessage("Could not read the timecode register");
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
CFGSpaceWire_TCGetValue(timecodeReg, &val);
|
|
|
//emit sendMessage("The timecode value is currently: " + QString::number(val));
|
|
|
this->UI->currentTimecodeValue_LABEL->setText("Current Timecode Value: " + QString::number(val));
|
|
|
CFGSpaceWire_TCGetFlags(timecodeReg, &val);
|
|
|
this->UI->currentTimecodeFlag_LABEL->setText("Current Timecode Flag: " + QString::number(val));
|
|
|
//emit sendMessage("The timecode flag value is currently: " + QString::number(val));
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
void MainWindow::sendTimecodesPeriodically()
|
|
|
{
|
|
|
if(time->isActive())
|
|
|
{
|
|
|
time->stop();
|
|
|
this->UI->startTimeButton->setText("start sending timecodes periodically");
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
time->start();
|
|
|
this->UI->startTimeButton->setText("stop sending timecodes periodically");
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void MainWindow::periodicalTimecodeTimeout()
|
|
|
{
|
|
|
sendOneTimecode();
|
|
|
systemTime = systemTime + 1;
|
|
|
if (flag_sendTimePacket == true)
|
|
|
{
|
|
|
flag_sendTimePacket = false;
|
|
|
QTimer::singleShot(700, this, SLOT(sendTimePacketTimeout()));
|
|
|
}
|
|
|
emit(systemTimeHasChanged(systemTime));
|
|
|
}
|
|
|
|
|
|
void MainWindow::sendTimePacketTimeout()
|
|
|
{
|
|
|
sendUpdateTime( systemTime + 1 );
|
|
|
}
|
|
|
|
|
|
void MainWindow::sendSystemTime()
|
|
|
{
|
|
|
flag_sendTimePacket = true;
|
|
|
}
|
|
|
|
|
|
void MainWindow::sendArbitraryTime()
|
|
|
{
|
|
|
flag_sendTimePacket = true;
|
|
|
systemTime = this->UI->arbitraryTime;
|
|
|
emit (systemTimeHasChanged( systemTime));
|
|
|
}
|
|
|
|
|
|
unsigned int MainWindow::Open()
|
|
|
{
|
|
|
U32 dwTickEnableStatus;
|
|
|
|
|
|
if (!USBSpaceWire_Open(&hDevice, UI->usbDeviceNumber_SPINBOX->value())) // Open the USB device
|
|
|
{
|
|
|
emit sendMessage("ERR *** in Open *** USBSpaceWire_Open(&hDevice, 0))");
|
|
|
return 0;
|
|
|
}
|
|
|
emit sendMessage("OK *** in Open *** USBSpaceWire_Open successful, device number: "
|
|
|
+ QString::number(UI->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
|
|
|
CFGSpaceWire_StackClear();
|
|
|
CFGSpaceWire_AddrStackPush(0);
|
|
|
CFGSpaceWire_AddrStackPush(254);
|
|
|
CFGSpaceWire_RetAddrStackPush(254);
|
|
|
|
|
|
if (getLinkStatus(UI->linkNumber_SPINBOX->value())==0)
|
|
|
{
|
|
|
return UI->starDundeeStatusQueryDialog->exec();
|
|
|
}
|
|
|
|
|
|
if (!USBSpaceWire_TC_Reset(hDevice))
|
|
|
{
|
|
|
emit sendMessage("ERR *** in Open *** Could not reset timecodes\n");
|
|
|
}
|
|
|
|
|
|
// 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");
|
|
|
|
|
|
CFGSpaceWire_GetTickEnableStatus(hDevice, &dwTickEnableStatus);
|
|
|
emit sendMessage("OK *** in Open *** CFGSpaceWire_GetTickEnableStatus, code is " + QString::number(dwTickEnableStatus, 2));
|
|
|
|
|
|
}
|
|
|
|
|
|
unsigned int MainWindow::getLinkStatus(unsigned char link)
|
|
|
{
|
|
|
unsigned int resultOpen;
|
|
|
|
|
|
U32 statusControl = 0, errorStatus = 0, portType = 0;
|
|
|
U32 linkStatus = 0, operatingSpeed = 0, outputPortConnection = 0;
|
|
|
char isLinkRunning = 0, isAutoStart = 0, isStart = 0, isDisabled = 0, isTristate = 0;
|
|
|
|
|
|
if (hDevice==NULL)
|
|
|
{
|
|
|
resultOpen = Open();
|
|
|
}
|
|
|
|
|
|
// Read the link status control register
|
|
|
if (CFGSpaceWire_GetLinkStatusControl(hDevice, 1, &statusControl) != CFG_TRANSFER_SUCCESS)
|
|
|
{
|
|
|
emit sendMessage("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 MainWindow::reTestSPWLink() // SLOT
|
|
|
{
|
|
|
if (getLinkStatus(UI->linkNumber_SPINBOX->value()))
|
|
|
{
|
|
|
UI->starDundeeStatusQueryDialog->accept();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void MainWindow::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_DEFAULT;
|
|
|
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
|
|
|
|
|
|
packetToSend->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);
|
|
|
}
|
|
|
|
|
|
unsigned int MainWindow::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 sendMessage("WARNING === in function WRITE of rmapplugin *** CCSDS packet size > 248 bytes\n");
|
|
|
return 1;
|
|
|
}
|
|
|
|
|
|
if ( getLinkStatus( this->UI->linkNumber_SPINBOX->value() ) == 0 )
|
|
|
{
|
|
|
emit sendMessage("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] = this->UI->linkNumber_SPINBOX->value(); // 1 by default, value can be 1 or 2
|
|
|
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;
|
|
|
}
|
|
|
|
|
|
//**************
|
|
|
// Free the send
|
|
|
USBSpaceWire_FreeSend(hDevice, pIdentifier);
|
|
|
free(SPWData);
|
|
|
|
|
|
return 1;
|
|
|
}
|
|
|
|
