##// END OF EJS Templates
HG_REPOSITORIES » LPP » INSTRUMENTATION » SOLO_LFR » LPPMON_PLUGINS_PAUL
RSS

Clone from http://pc-instru.lpp.polytechnique.fr:5000/LPPMON_GROUP/LPPMON_PLUGINS_PAUL

Development of the waveform storage ability of the lfrgse
Development of the waveform storage ability of the lfrgse
leroy - - Load All Authors

File last commit:

r17:409986095715 default
r42:e422d9305701 default
Show More
stardundee.cpp
845 lines | 34.7 KiB | text/x-c | CppLexer
/ rmapplugin / stardundee.cpp
History | Source | Raw |Copy content |Copy permalink
leroy
Initial commit: rmapplugin fully operational with the GRESB Ethernet/SpaceWire bridge.
 r0 #include "stardundee.h"
paul@pc-solar1.lab-lpp.local
First version with the Star Dundee bridge operational
 r1 #include <QTime>
#include <math.h>
leroy
Plugin modified to allow the launch of interactiv tests from the python interpreter...
 r11 #include "ccsds.h"
leroy
Initial commit: rmapplugin fully operational with the GRESB Ethernet/SpaceWire bridge.
 r0
StarDundee::StarDundee(QWidget *parent) :
QWidget(parent)
{
leroy
Minor updates
 r3 // Packet receiver
leroy
the two bridges, Star Dundee and GRESB are fully functional
 r10 timer = new QTimer;
leroy
Minor updates
 r3 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) );
leroy
the two bridges, Star Dundee and GRESB are fully functional
 r10 starDundeeStatusQueryDialog = new QDialog;
paul@pc-solar1.lab-lpp.local
First version with the Star Dundee bridge operational
 r1 commandCode = invalid0; // initialization of the cmmand code for the RMAP transfers
leroy
Plugin modified to allow the launch of interactiv tests from the python interpreter...
 r11 rmapTargetLogicalAddress = DEFAULT_TARGET;
rmapSourceLogicalAddress = DEFAULT_SOURCE;
paul@pc-solar1.lab-lpp.local
First version with the Star Dundee bridge operational
 r1
leroy
Initial commit: rmapplugin fully operational with the GRESB Ethernet/SpaceWire bridge.
 r0 connection_LAYOUT = new QGridLayout;
usbDeviceNumber_LABEL = new QLabel(tr("USB device number: "));
paul@pc-solar1.lab-lpp.local
First version with the Star Dundee bridge operational
 r1 linkNumber_LABEL = new QLabel(tr("SpaceWire link number: "));
leroy
the two bridges, Star Dundee and GRESB are fully functional
 r10 starDundeeStatusQueryDialogLabel = new QLabel(tr("SpaceWire link not running"));
//*** QPUSHBUTTON ***//
starDundeeStatusQueryRetryButton = new QPushButton(tr("Retry"));
starDundeeStatusQueryAbortButton = new QPushButton(tr("Abort"));
leroy
Initial commit: rmapplugin fully operational with the GRESB Ethernet/SpaceWire bridge.
 r0
usbDeviceNumber_SPINBOX = new QSpinBox;
usbDeviceNumber_SPINBOX->setRange(0,32);
usbDeviceNumber_SPINBOX->setValue(0);
paul@pc-solar1.lab-lpp.local
First version with the Star Dundee bridge operational
 r1 linkNumber_SPINBOX = new QSpinBox;
linkNumber_SPINBOX->setRange(1,2);
linkNumber_SPINBOX->setValue(1);
leroy
Initial commit: rmapplugin fully operational with the GRESB Ethernet/SpaceWire bridge.
 r0
leroy
the two bridges, Star Dundee and GRESB are fully functional
 r10 // STAR DUNDEE STATUS QUERY DIALOG
starDundeeStatusQueryDialogLayout = new QGridLayout;
starDundeeStatusQueryDialogLayout->addWidget(starDundeeStatusQueryDialogLabel, 0, 0, 1, 2);
starDundeeStatusQueryDialogLayout->addWidget(starDundeeStatusQueryRetryButton, 1, 0, 0);
starDundeeStatusQueryDialogLayout->addWidget(starDundeeStatusQueryAbortButton, 1, 1, 0);
starDundeeStatusQueryDialog->setLayout(starDundeeStatusQueryDialogLayout);
paul@pc-solar1.lab-lpp.local
First version with the Star Dundee bridge operational
 r1 connection_LAYOUT->addWidget(usbDeviceNumber_LABEL, 0, 0, 1, 1);
connection_LAYOUT->addWidget(usbDeviceNumber_SPINBOX, 0, 1, 1, 1);
leroy
Minor updates
 r3 connection_LAYOUT->addWidget(linkNumber_LABEL, 1, 0, 1, 1);
connection_LAYOUT->addWidget(linkNumber_SPINBOX, 1, 1, 1, 1);
paul@pc-solar1.lab-lpp.local
First version with the Star Dundee bridge operational
 r1
leroy
Plugin modified to allow the launch of interactiv tests from the python interpreter...
 r11 connection_LAYOUT->setRowStretch(2, 1);
paul@pc-solar1.lab-lpp.local
First version with the Star Dundee bridge operational
 r1 connection_LAYOUT->setColumnStretch(2, 1);
leroy
Initial commit: rmapplugin fully operational with the GRESB Ethernet/SpaceWire bridge.
 r0
this->setLayout(connection_LAYOUT);
leroy
the two bridges, Star Dundee and GRESB are fully functional
 r10 connect(starDundeeStatusQueryRetryButton, SIGNAL(clicked()), this, SLOT(reTestSPWLink()));
connect(starDundeeStatusQueryAbortButton, SIGNAL(clicked()), starDundeeStatusQueryDialog, SLOT(reject()));
connect(this->timer, SIGNAL(timeout()), this, SLOT(receivePollingLoop()));
leroy
Initial commit: rmapplugin fully operational with the GRESB Ethernet/SpaceWire bridge.
 r0 }
StarDundee::~StarDundee()
{
leroy
Minor updates
 r3 free(rmapPacket);
free(ccsdsPacket);
free(spwPacket);
leroy
Initial commit: rmapplugin fully operational with the GRESB Ethernet/SpaceWire bridge.
 r0 USBSpaceWire_Close(hDevice); // Close the device
}
leroy
changes on the gresb class, several methods and parameters added
 r6 void StarDundee::Open()
leroy
Initial commit: rmapplugin fully operational with the GRESB Ethernet/SpaceWire bridge.
 r0 {
paul@pc-solar1.lab-lpp.local
First version with the Star Dundee bridge operational
 r1 int status;
U32 statusControl;
if (!USBSpaceWire_Open(&hDevice, usbDeviceNumber_SPINBOX->value())) // Open the USB device
leroy
Initial commit: rmapplugin fully operational with the GRESB Ethernet/SpaceWire bridge.
 r0 {
leroy
Plugin modified to allow the launch of interactiv tests from the python interpreter...
 r11 emit sendMessage("stardundee *** Open *** ERROR: USBSpaceWire_Open(&hDevice, 0))");
return;
leroy
Initial commit: rmapplugin fully operational with the GRESB Ethernet/SpaceWire bridge.
 r0 }
paul@pc-solar1.lab-lpp.local
First version with the Star Dundee bridge operational
 r1 emit sendMessage("stardundee *** Open *** USBSpaceWire_Open successful, device number: "
+ QString::number(usbDeviceNumber_SPINBOX->value()));
USBSpaceWire_EnableNetworkMode(hDevice, 0); // deactivate the network mode
leroy
Plugin modified to allow the launch of interactiv tests from the python interpreter...
 r11 CFGSpaceWire_EnableRMAP(1); // Enable the use of RMAP for the StarDundee brick configuration
paul@pc-solar1.lab-lpp.local
First version with the Star Dundee bridge operational
 r1 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);
// 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");
// read the link status
if (CFGSpaceWire_GetLinkStatusControl(hDevice, linkNumber_SPINBOX->value(), &statusControl) != CFG_TRANSFER_SUCCESS)
{
emit sendMessage("Could not read link status control for link " + QString::number(linkNumber_SPINBOX->value()));
}
else
{
emit sendMessage("OK CFGSpaceWire_GetLinkStatusControl of link " + QString::number(linkNumber_SPINBOX->value()));
// 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_SPINBOX->value(), statusControl) != CFG_TRANSFER_SUCCESS)
{
emit sendMessage("Could not set the link status control for link " + QString::number(linkNumber_SPINBOX->value()));
}
else emit sendMessage("Set the link status control for link " + QString::number(linkNumber_SPINBOX->value()));
}
leroy
Plugin modified to allow the launch of interactiv tests from the python interpreter...
 r11 if (CFGSpaceWire_SetAsInterface(hDevice, 1, 0) != CFG_TRANSFER_SUCCESS)
{
emit sendMessage("Could not set the device to be an interface");
}
else
{
emit sendMessage("Device set to be an interface");
}
paul@pc-solar1.lab-lpp.local
First version with the Star Dundee bridge operational
 r1
leroy
Plugin modified to allow the launch of interactiv tests from the python interpreter...
 r11 //setRoutingTableEntry(rmapTargetLogicalAddress, (1<<linkNumber_SPINBOX->value()));
//setRoutingTableEntry(rmapSourceLogicalAddress, (1<<3));
//GetRoutingTableEntry(rmapTargetLogicalAddress);
//GetRoutingTableEntry(rmapSourceLogicalAddress);
paul@pc-solar1.lab-lpp.local
First version with the Star Dundee bridge operational
 r1
leroy
Minor updates
 r3 USBSpaceWire_RegisterReceiveOnAllPorts(hDevice); // Register to receive on all ports
USBSpaceWire_ClearEndpoints(hDevice); // clear the USB endpoints
paul@pc-solar1.lab-lpp.local
First version with the Star Dundee bridge operational
 r1
leroy
Plugin modified to allow the launch of interactiv tests from the python interpreter...
 r11 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)));
leroy
Minor updates
 r3 // initialize SPW packet semaphores
while (rmapPacketSEMAPHORE->available()!=0) rmapPacketSEMAPHORE->acquire();
while (ccsdsPacketSEMAPHORE->available()!=0) ccsdsPacketSEMAPHORE->acquire();
paul@pc-solar1.lab-lpp.local
First version with the Star Dundee bridge operational
 r1
leroy
the two bridges, Star Dundee and GRESB are fully functional
 r10 if (getLinkStatus(linkNumber_SPINBOX->value()))
{
emit isOpen(true);
leroy
plugin updated, TM packet store reworked to store any TM continuously...
 r13 timer->start(100); // starts the periodical timer, period = 100ms
leroy
the two bridges, Star Dundee and GRESB are fully functional
 r10 }
else
{
leroy
Plugin modified to allow the launch of interactiv tests from the python interpreter...
 r11 starDundeeStatusQueryDialog->exec();
leroy
the two bridges, Star Dundee and GRESB are fully functional
 r10 }
leroy
Initial commit: rmapplugin fully operational with the GRESB Ethernet/SpaceWire bridge.
 r0 }
leroy
changes on the gresb class, several methods and parameters added
 r6 void StarDundee::Close()
leroy
Initial commit: rmapplugin fully operational with the GRESB Ethernet/SpaceWire bridge.
 r0 {
USBSpaceWire_Close(hDevice); // Close the device
paul@pc-solar1.lab-lpp.local
First version with the Star Dundee bridge operational
 r1 emit sendMessage("stardundee *** Close *** USBSpaceWire_Close, device: " + QString::number(usbDeviceNumber_SPINBOX->value()));
USBSpaceWire_UnregisterReceiveOnAllPorts(hDevice); // Stop receiving on all ports
leroy
Minor updates
 r3 emit isOpen(false);
paul@pc-solar1.lab-lpp.local
First version with the Star Dundee bridge operational
 r1 }
leroy
Plugin modified to allow the launch of interactiv tests from the python interpreter...
 r11 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
0, // header deletion disabled
0); // 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)
paul@pc-solar1.lab-lpp.local
First version with the Star Dundee bridge operational
 r1 {
U32 routingTableEntry, outputPorts;
char enabled, delHead, priority;
int portNum;
leroy
Plugin modified to allow the launch of interactiv tests from the python interpreter...
 r11 emit sendMessage("GetRoutingTableEntry [" + QString::number(tableEntry) + "]");
paul@pc-solar1.lab-lpp.local
First version with the Star Dundee bridge operational
 r1 // 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;
}
leroy
Minor updates
 r3 unsigned int StarDundee::Write(unsigned int *Value, unsigned int count, unsigned int address)
paul@pc-solar1.lab-lpp.local
First version with the Star Dundee bridge operational
 r1 {
leroy
Minor updates
 r3 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));
while (remainingCount > READ_WRITE_MAX_COUNTS)
{
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));
paul@pc-solar1.lab-lpp.local
First version with the Star Dundee bridge operational
 r1
leroy
Minor updates
 r3 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)
paul@pc-solar1.lab-lpp.local
First version with the Star Dundee bridge operational
 r1 {
leroy
Minor updates
 r3 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));
paul@pc-solar1.lab-lpp.local
First version with the Star Dundee bridge operational
 r1
leroy
Minor updates
 r3 if (WriteBLOCK(data, remainingCount*4, address)==0)
{
emit appendToLog("WARNING === in function WRITE of rmapplugin *** RMAP write command failed");
return 1;
}
}
paul@pc-solar1.lab-lpp.local
First version with the Star Dundee bridge operational
 r1
leroy
Minor updates
 r3 emit appendToLog(QString("*** STOP *** WRITE"));
free(data);
return count;
paul@pc-solar1.lab-lpp.local
First version with the Star Dundee bridge operational
 r1 }
leroy
Minor updates
 r3 unsigned int StarDundee::Read(unsigned int *Value, unsigned int count, unsigned int address)
paul@pc-solar1.lab-lpp.local
First version with the Star Dundee bridge operational
 r1 {
leroy
Minor updates
 r3 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));
while (remainingCount > READ_WRITE_MAX_COUNTS)
{
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();
}
emit appendToLog(QString("*** STOP *** READ "));
return count;
paul@pc-solar1.lab-lpp.local
First version with the Star Dundee bridge operational
 r1 }
leroy
Minor updates
 r3 unsigned int StarDundee::WriteBLOCK(char *data, unsigned int nbBytes, unsigned int address)
paul@pc-solar1.lab-lpp.local
First version with the Star Dundee bridge operational
 r1 {
RMAP *RMAPCommand;
leroy
Minor updates
 r3 char * packet;
leroy
Plugin modified to allow the launch of interactiv tests from the python interpreter...
 r11 char* aux;
leroy
Minor updates
 r3 unsigned char offset, headerSize, CRCSize;
unsigned int totalSize;
int errorCode;
QString console_message;
paul@pc-solar1.lab-lpp.local
First version with the Star Dundee bridge operational
 r1
leroy
Minor updates
 r3 if (getLinkStatus(this->linkNumber_SPINBOX->value()) == 0)
paul@pc-solar1.lab-lpp.local
First version with the Star Dundee bridge operational
 r1 {
leroy
Minor updates
 r3 this->Close();
return 1;
paul@pc-solar1.lab-lpp.local
First version with the Star Dundee bridge operational
 r1 }
leroy
Minor updates
 r3 RMAPCommand = new RMAP(this->commandCode,
paul@pc-solar1.lab-lpp.local
First version with the Star Dundee bridge operational
 r1 rmapTargetLogicalAddress,
rmapSourceLogicalAddress,
address,
leroy
Minor updates
 r3 nbBytes,
data);
paul@pc-solar1.lab-lpp.local
First version with the Star Dundee bridge operational
 r1 headerSize = sizeof(RMAPCommand->RMAPHeader);
CRCSize = 1;
//*************************
// BUILD THE PACKET TO SEND
leroy
Plugin modified to allow the launch of interactiv tests from the python interpreter...
 r11 totalSize = headerSize + nbBytes + CRCSize + PATH_ADDRESSING_OFFSET;
leroy
Minor updates
 r3 packet = (char*) malloc( totalSize );
aux = (char*) ((void*) &RMAPCommand->RMAPHeader);
leroy
Plugin modified to allow the launch of interactiv tests from the python interpreter...
 r11 packet[0] = this->linkNumber_SPINBOX->value();
for(unsigned int i = 0; i<headerSize; i++) packet[i+PATH_ADDRESSING_OFFSET] = aux[i];
paul@pc-solar1.lab-lpp.local
First version with the Star Dundee bridge operational
 r1 offset = headerSize;
leroy
Minor updates
 r3 for(unsigned int i = 0; i<nbBytes; i++)
paul@pc-solar1.lab-lpp.local
First version with the Star Dundee bridge operational
 r1 {
leroy
Plugin modified to allow the launch of interactiv tests from the python interpreter...
 r11 packet[i+offset+PATH_ADDRESSING_OFFSET] = data[i];
paul@pc-solar1.lab-lpp.local
First version with the Star Dundee bridge operational
 r1 }
leroy
Plugin modified to allow the launch of interactiv tests from the python interpreter...
 r11 packet[nbBytes+offset+PATH_ADDRESSING_OFFSET] = RMAPCommand->dataCRC;
paul@pc-solar1.lab-lpp.local
First version with the Star Dundee bridge operational
 r1
leroy
Minor updates
 r3 //****************
paul@pc-solar1.lab-lpp.local
First version with the Star Dundee bridge operational
 r1 // SEND THE PACKET
result = USBSpaceWire_SendPacket(hDevice,
leroy
Minor updates
 r3 packet,
paul@pc-solar1.lab-lpp.local
First version with the Star Dundee bridge operational
 r1 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);
leroy
Minor updates
 r3 free(packet);
paul@pc-solar1.lab-lpp.local
First version with the Star Dundee bridge operational
 r1
if ( (commandCode == writeSingle_noVer_Rep) | (commandCode == writeInc_noVer_Rep) |
(commandCode == writeSingle_ver_rep) | (commandCode == writeInc_ver_rep) )
{
leroy
Minor updates
 r3 // WAIT FOR THE RMAP REPLY PACKET
errorCode = this->receiveSPWPacket(1);
if (errorCode<=0)
paul@pc-solar1.lab-lpp.local
First version with the Star Dundee bridge operational
 r1 {
leroy
Minor updates
 r3 emit appendToLog("WARNING === in function WriteBLOCK of rmapplugin *** RMAP packet reception failed with code " + QString::number(errorCode));
return 0;
paul@pc-solar1.lab-lpp.local
First version with the Star Dundee bridge operational
 r1 }
leroy
Minor updates
 r3 if(rmapPacketSize != 8)
paul@pc-solar1.lab-lpp.local
First version with the Star Dundee bridge operational
 r1 {
leroy
Minor updates
 r3 console_message.sprintf("WARNING === in function WRITE (with reply) of rmapplugin *** write reply format not compliant\n");
emit appendToLog(console_message);
return 0;
paul@pc-solar1.lab-lpp.local
First version with the Star Dundee bridge operational
 r1 }
leroy
Minor updates
 r3 switch (this->rmapPacket[3]) // byte 4 is the status byte in the reply
paul@pc-solar1.lab-lpp.local
First version with the Star Dundee bridge operational
 r1 {
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;
}
leroy
Minor updates
 r3 this->acquireRMAPSemaphore();
paul@pc-solar1.lab-lpp.local
First version with the Star Dundee bridge operational
 r1 }
else
emit RMAP_write_reply_setText("reply to the write command required\nlast reply status: unavailable");
leroy
Minor updates
 r3
return nbBytes;
}
unsigned int StarDundee::ReadBLOCK(unsigned int nbBytes, unsigned int address)
{
int errorCode;
RMAP *RMAPCommand;
leroy
Plugin modified to allow the launch of interactiv tests from the python interpreter...
 r11 char *packet;
char *aux;
unsigned int dataLength = 0;
unsigned int totalSize = 0;
leroy
Minor updates
 r3
//**********************
// 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);
}
leroy
Plugin modified to allow the launch of interactiv tests from the python interpreter...
 r11
//*************************
// BUILD THE PACKET TO SEND
totalSize = sizeof(RMAPCommand->RMAPHeader) + PATH_ADDRESSING_OFFSET;
packet = (char*) malloc( totalSize );
aux = (char*) ((void*) &RMAPCommand->RMAPHeader);
packet[0] = this->linkNumber_SPINBOX->value();
for (unsigned int i = 0; i<sizeof(RMAPCommand->RMAPHeader); i++)
packet[i+PATH_ADDRESSING_OFFSET] = aux[i];
//****************
// SEND THE PACKET
leroy
Minor updates
 r3 result = USBSpaceWire_SendPacket(hDevice,
leroy
Plugin modified to allow the launch of interactiv tests from the python interpreter...
 r11 packet,
totalSize,
leroy
Minor updates
 r3 BWAIT_1, &pIdentifier);
if (result != TRANSFER_SUCCESS) emit sendMessage("ERR *** ReadStarDundee *** ReadBLOCK *** sending the READ command ");
leroy
Plugin modified to allow the launch of interactiv tests from the python interpreter...
 r11 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);
leroy
Minor updates
 r3
//*********************************
// 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;
paul@pc-solar1.lab-lpp.local
First version with the Star Dundee bridge operational
 r1 }
leroy
Minor updates
 r3 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;
}
leroy
Plugin modified to allow the launch of interactiv tests from the python interpreter...
 r11 totalSize = count + 4 + PATH_ADDRESSING_OFFSET; // The StarDundee brick is in PATH addressing
leroy
Minor updates
 r3 SPWData = (char*) malloc(totalSize);
// SPW HEADER
leroy
Plugin modified to allow the launch of interactiv tests from the python interpreter...
 r11 SPWData[0] = this->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;
leroy
Minor updates
 r3 // CCSDS PACKET
for (unsigned int i = 0; i<count; i++)
{
leroy
Plugin modified to allow the launch of interactiv tests from the python interpreter...
 r11 SPWData[i+4+PATH_ADDRESSING_OFFSET] = Value[i];
leroy
Minor updates
 r3 }
leroy
Plugin modified to allow the launch of interactiv tests from the python interpreter...
 r11 //****************
leroy
Minor updates
 r3 // 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;
}
leroy
Plugin modified to allow the launch of interactiv tests from the python interpreter...
 r11 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])
);
leroy
Minor updates
 r3
//**************
// 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;
paul@pc-solar1.lab-lpp.local
First version with the Star Dundee bridge operational
 r1
leroy
Minor updates
 r3 // Read the link status control register
if (CFGSpaceWire_GetLinkStatusControl(hDevice, 1, &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;
}
leroy
Plugin modified to allow the launch of interactiv tests from the python interpreter...
 r11 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);
}
leroy
first version of the waveform display...
 r17
leroy
Plugin modified to allow the launch of interactiv tests from the python interpreter...
 r11 return result;
}
leroy
Minor updates
 r3 int StarDundee::receiveSPWPacket(unsigned char requestID) // SLOT
paul@pc-solar1.lab-lpp.local
First version with the Star Dundee bridge operational
 r1 {
leroy
Minor updates
 r3 unsigned int packetLength;
unsigned int nbBytes;
unsigned nPacketNum;
USB_SPACEWIRE_PACKET_PROPERTIES properties; // The properties of the read
if (requestID==1)
{
leroy
the two bridges, Star Dundee and GRESB are fully functional
 r10 if (rmapPacketSEMAPHORE->available())
{
return rmapPacketSize;
}
leroy
Minor updates
 r3 }
//********************
// TRY TO RECEIVE DATA
nbBytes = qMax(RMAP_MAX_PACKET_LENGTH, CCSDS_MAX_PACKET_LENGTH); // maximum size of the packet to receive
nPacketNum = 1;
leroy
Plugin modified to allow the launch of interactiv tests from the python interpreter...
 r11 result = USBSpaceWire_ReadPackets(hDevice, spwPacket, nbBytes, nPacketNum, BWAIT_1, &properties, &pIdentifierRead);
leroy
the two bridges, Star Dundee and GRESB are fully functional
 r10 if (result != TRANSFER_SUCCESS)
{
emit sendMessage("Error: Could not receive the packet");
leroy
plugin updated, TM packet store reworked to store any TM continuously...
 r13 USBSpaceWire_FreeRead(hDevice, pIdentifierRead); // Free the read buffer
leroy
the two bridges, Star Dundee and GRESB are fully functional
 r10 return 0;
}
leroy
Minor updates
 r3 else
{
leroy
the two bridges, Star Dundee and GRESB are fully functional
 r10 packetLength = properties.len;
leroy
Plugin modified to allow the launch of interactiv tests from the python interpreter...
 r11 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
leroy
Minor updates
 r3 }
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();
leroy
the two bridges, Star Dundee and GRESB are fully functional
 r10 emit appendToLog("RMAP packet of size " + QString::number(packetLength) + " received");
leroy
Plugin modified to allow the launch of interactiv tests from the python interpreter...
 r11 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)
);
leroy
Minor updates
 r3 return packetLength;
case 2: // 0x02 is the protocole identifier for CCSDS packets
leroy
Plugin modified to allow the launch of interactiv tests from the python interpreter...
 r11 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
}
leroy
Minor updates
 r3 for(unsigned int i=0; i<packetLength; i++) ccsdsPacket[i] = spwPacket[i];
ccsdsPacketSize = packetLength;
leroy
the two bridges, Star Dundee and GRESB are fully functional
 r10 emit appendToLog("CCSDS packet of size " + QString::number(packetLength) + " received");
leroy
Plugin modified to allow the launch of interactiv tests from the python interpreter...
 r11 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);
leroy
Minor updates
 r3 return packetLength;
leroy
Plugin modified to allow the launch of interactiv tests from the python interpreter...
 r11 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));
leroy
Last commit before installation on pc-alison
 r12 return 0;
leroy
Minor updates
 r3 }
return 0;
paul@pc-solar1.lab-lpp.local
First version with the Star Dundee bridge operational
 r1 }
leroy
Minor updates
 r3
leroy
Plugin modified to allow the launch of interactiv tests from the python interpreter...
 r11 unsigned int StarDundee::storeCCSDSPacket(unsigned char *ccsdsPacket, unsigned int size)
leroy
the two bridges, Star Dundee and GRESB are fully functional
 r10 {
leroy
first version of the waveform display...
 r17 TMPacketToRead *generalPacket;
leroy
Plugin modified to allow the launch of interactiv tests from the python interpreter...
 r11
leroy
first version of the waveform display...
 r17 generalPacket = new TMPacketToRead(ccsdsPacket, size);
emit sendPacket(generalPacket);
leroy
plugin updated, TM packet store reworked to store any TM continuously...
 r13
leroy
Plugin modified to allow the launch of interactiv tests from the python interpreter...
 r11 return 1;
leroy
the two bridges, Star Dundee and GRESB are fully functional
 r10 }
leroy
Minor updates
 r3
leroy
Plugin modified to allow the launch of interactiv tests from the python interpreter...
 r11 void StarDundee::reTestSPWLink() // SLOT
leroy
the two bridges, Star Dundee and GRESB are fully functional
 r10 {
leroy
Plugin modified to allow the launch of interactiv tests from the python interpreter...
 r11 if (getLinkStatus(linkNumber_SPINBOX->value()))
leroy
the two bridges, Star Dundee and GRESB are fully functional
 r10 {
leroy
Plugin modified to allow the launch of interactiv tests from the python interpreter...
 r11 emit isOpen(true);
starDundeeStatusQueryDialog->accept();
leroy
the two bridges, Star Dundee and GRESB are fully functional
 r10 }
}