void clientTask::ShowResults()
{
double average = Results.SumOfElements() / Results.size();
double min = 0.0;
double max = 0.0;
Results.MinAndMaxElement(min, max);
std::cout << std::endl << std::endl
<< "--------------------------------------------------------------------" << std::endl
<< "Size of elements used (in bytes) : " << sizeof(mtsDouble) << std::endl
<< "Number of samples: " << NumberOfSamplesCollected << std::endl
<< "avg (ms) : " << cmnInternalTo_ms(average) << std::endl
<< "std (ms) : " << cmnInternalTo_ms(StandardDeviation(Results)) << std::endl
<< "min (ms) : " << cmnInternalTo_ms(min) << std::endl
<< "max (ms) : " << cmnInternalTo_ms(max) << std::endl;
}
void clientTask::EventWriteHandler(const value_type & data)
{
if (this->BenchmarkDoneMember == false) {
if (this->NumberOfskippedElement < confNumberOfSamplesToSkip) {
this->NumberOfskippedElement++;
} else {
double originalTime = data.Timestamp();
double currentTime = TimeServer->GetRelativeTime();
this->Samples.Element(this->SamplesCollected) = (currentTime - originalTime);
this->SamplesCollected++;
}
}
if (this->SamplesCollected == confNumberOfSamples) {
this->BenchmarkDoneMember = true;
double average = Samples.SumOfElements() / Samples.size();
double min = 0.0;
double max = 0.0;
Samples.MinAndMaxElement(min, max);
std::cout << "csc: client->server->client: client write data (queued), server triggers event (queued)" << std::endl
<< "csc: Client period (ms): " << cmnInternalTo_ms(confClientPeriod) << std::endl
<< "csc: Server period (ms): " << cmnInternalTo_ms(confServerPeriod) << std::endl
<< "csc: Size of elements used (in bytes): " << sizeof(value_type) << std::endl
<< "csc: Number of samples: " << this->SamplesCollected << std::endl
<< "csc: Average (ms): " << cmnInternalTo_ms(average) << std::endl
<< "csc: Standard deviation (ms): " << cmnInternalTo_ms(StandardDeviation(this->Samples)) << std::endl
<< "csc: Min (ms): " << cmnInternalTo_ms(min) << std::endl
<< "csc: Max (ms): " << cmnInternalTo_ms(max) << std::endl;
this->SamplesCollected++; // just to avoid printing results again
}
}
void mtsRobotIO1394QtWidget::setupUi(void)
{
QFont font;
font.setBold(true);
// Power commands
QVBoxLayout * powerLayout = new QVBoxLayout;
QFrame * powerFrame = new QFrame;
QLabel * powerTitle = new QLabel("Power");
powerTitle->setFont(font);
powerTitle->setAlignment(Qt::AlignCenter);
powerLayout->addWidget(powerTitle);
QCBEnableAll = new QCheckBox("Enable all");
powerLayout->addWidget(QCBEnableAll);
QCBEnableAmps = new QCheckBox("Enable boards");
powerLayout->addWidget(QCBEnableAmps);
powerLayout->addSpacing(5);
QLAmpStatus = new QLabel("Actuators ON");
QLAmpStatus->setAlignment(Qt::AlignCenter);
powerLayout->addWidget(QLAmpStatus);
QLPowerStatus = new QLabel("Boards ON");
QLPowerStatus->setAlignment(Qt::AlignCenter);
powerLayout->addWidget(QLPowerStatus);
powerLayout->addStretch();
powerFrame->setLayout(powerLayout);
powerFrame->setFrameStyle(QFrame::StyledPanel | QFrame::Sunken);
// watchdog commands
QVBoxLayout * watchdogLayout = new QVBoxLayout;
QFrame * watchdogFrame = new QFrame;
QLabel * watchdogTitle = new QLabel("Watchdog");
watchdogTitle->setFont(font);
watchdogTitle->setAlignment(Qt::AlignCenter);
watchdogLayout->addWidget(watchdogTitle);
QHBoxLayout * watchdogSetLayout = new QHBoxLayout;
{
QLabel * wdogLabel = new QLabel("Wdog period (ms)");
QSBWatchdogPeriod = new QDoubleSpinBox;
QSBWatchdogPeriod->setMaximum(340.0); // max wdog_period = 340 ms
QSBWatchdogPeriod->setMinimum(0.0);
QSBWatchdogPeriod->setSingleStep(0.05);
QSBWatchdogPeriod->setValue(cmnInternalTo_ms(WatchdogPeriodInSeconds));
watchdogSetLayout->addWidget(wdogLabel);
watchdogSetLayout->addWidget(QSBWatchdogPeriod);
}
watchdogLayout->addLayout(watchdogSetLayout);
watchdogLayout->addSpacing(5);
QLSafetyRelay = new QLabel("Safety relay ON");
QLSafetyRelay->setAlignment(Qt::AlignCenter);
watchdogLayout->addWidget(QLSafetyRelay);
QLWatchdog = new QLabel("Watchdog Timeout FALSE");
QLWatchdog->setAlignment(Qt::AlignCenter);
QLWatchdog->setStyleSheet("QLabel { background-color: green }");
watchdogLayout->addWidget(QLWatchdog);
QLWatchdogLastTimeout = new QLabel("Last timeout: n/a");
QLWatchdogLastTimeout->setAlignment(Qt::AlignCenter);
watchdogLayout->addWidget(QLWatchdogLastTimeout);
watchdogLayout->addStretch();
watchdogFrame->setLayout(watchdogLayout);
watchdogFrame->setFrameStyle(QFrame::StyledPanel | QFrame::Sunken);
// Encoder commands
QVBoxLayout * encoderLayout = new QVBoxLayout;
QFrame * encoderFrame = new QFrame;
QLabel * encoderTitle = new QLabel("Encoders");
encoderTitle->setFont(font);
encoderTitle->setAlignment(Qt::AlignCenter);
encoderLayout->addWidget(encoderTitle);
QPBResetEncAll = new QPushButton("Reset all");
encoderLayout->addWidget(QPBResetEncAll);
QPBBiasEncAll = new QPushButton("Bias from potentiometers");
encoderLayout->addWidget(QPBBiasEncAll);
encoderLayout->addStretch();
encoderFrame->setLayout(encoderLayout);
encoderFrame->setFrameStyle(QFrame::StyledPanel | QFrame::Sunken);
// Current comands
QVBoxLayout * currentLayout = new QVBoxLayout;
QFrame * currentFrame = new QFrame;
QLabel * currentTitle = new QLabel("Current");
currentTitle->setFont(font);
currentTitle->setAlignment(Qt::AlignCenter);
currentLayout->addWidget(currentTitle);
QCBEnableDirectControl = new QCheckBox("Direct control");
currentLayout->addWidget(QCBEnableDirectControl);
currentLayout->addStretch();
QLabel * serialTitle = new QLabel("Serial Number");
serialTitle->setFont(font);
serialTitle->setAlignment(Qt::AlignCenter);
currentLayout->addWidget(serialTitle);
QLSerialNumber = new QLabel("-----");
QLSerialNumber->setAlignment(Qt::AlignCenter);
currentLayout->addWidget(QLSerialNumber);
currentLayout->addStretch();
currentFrame->setLayout(currentLayout);
currentFrame->setFrameStyle(QFrame::StyledPanel | QFrame::Sunken);
// Timing
QVBoxLayout * timingLayout = new QVBoxLayout;
QFrame * timingFrame = new QFrame;
QLabel * timingTitle = new QLabel("Timing");
timingTitle->setFont(font);
timingTitle->setAlignment(Qt::AlignCenter);
timingLayout->addWidget(timingTitle);
QMIntervalStatistics = new mtsQtWidgetIntervalStatistics();
timingLayout->addWidget(QMIntervalStatistics);
timingLayout->addStretch();
timingFrame->setLayout(timingLayout);
timingFrame->setFrameStyle(QFrame::StyledPanel | QFrame::Sunken);
// Commands layout
QHBoxLayout * commandLayout = new QHBoxLayout;
commandLayout->addWidget(powerFrame);
commandLayout->addWidget(watchdogFrame);
commandLayout->addWidget(encoderFrame);
commandLayout->addWidget(currentFrame);
commandLayout->addWidget(timingFrame);
// Feedbacks Label
QGridLayout * gridLayout = new QGridLayout;
gridLayout->setSpacing(1);
int row = 0;
if (NumberOfActuators != 0) {
vctBoolVec defaultEnable(NumberOfActuators, false);
vctDoubleVec defaultCurrent(NumberOfActuators, 0.0);
gridLayout->addWidget(new QLabel("Actuator power"), row, 0);
QVWActuatorCurrentEnableEachWidget = new vctQtWidgetDynamicVectorBoolWrite();
QVWActuatorCurrentEnableEachWidget->SetValue(defaultEnable);
gridLayout->addWidget(QVWActuatorCurrentEnableEachWidget, row, 1);
row++;
gridLayout->addWidget(new QLabel("Desired current (mA)"), row, 0);
QVWActuatorCurrentSpinBoxWidget = new vctQtWidgetDynamicVectorDoubleWrite(vctQtWidgetDynamicVectorDoubleWrite::SPINBOX_WIDGET);
QVWActuatorCurrentSpinBoxWidget->SetValue(defaultCurrent);
gridLayout->addWidget(QVWActuatorCurrentSpinBoxWidget, row, 1);
row++;
QPBResetCurrentAll = new QPushButton("Reset current");
gridLayout->addWidget(QPBResetCurrentAll, row, 0);
QVWActuatorCurrentSliderWidget = new vctQtWidgetDynamicVectorDoubleWrite(vctQtWidgetDynamicVectorDoubleWrite::SLIDER_WIDGET);
QVWActuatorCurrentSliderWidget->SetValue(defaultCurrent);
gridLayout->addWidget(QVWActuatorCurrentSliderWidget, row, 1);
row++;
gridLayout->addWidget(new QLabel("Current feedback (mA)"), row, 0);
QVRActuatorCurrentFeedbackWidget = new vctQtWidgetDynamicVectorDoubleRead();
gridLayout->addWidget(QVRActuatorCurrentFeedbackWidget, row, 1);
row++;
gridLayout->addWidget(new QLabel("Joint positions (deg)"), row, 0);
QVRJointPositionWidget = new vctQtWidgetDynamicVectorDoubleRead();
gridLayout->addWidget(QVRJointPositionWidget, row, 1);
row++;
gridLayout->addWidget(new QLabel("Actuator positions (deg)"), row, 0);
QVRActuatorPositionWidget = new vctQtWidgetDynamicVectorDoubleRead();
gridLayout->addWidget(QVRActuatorPositionWidget, row, 1);
row++;
gridLayout->addWidget(new QLabel("Velocities (deg/s)"), row, 0);
QVRActuatorVelocityWidget = new vctQtWidgetDynamicVectorDoubleRead();
gridLayout->addWidget(QVRActuatorVelocityWidget, row, 1);
row++;
gridLayout->addWidget(new QLabel("Analog inputs (V)"), row, 0);
QVRPotVoltsWidget = new vctQtWidgetDynamicVectorDoubleRead();
gridLayout->addWidget(QVRPotVoltsWidget, row, 1);
row++;
gridLayout->addWidget(new QLabel("Potentiometers (deg)"), row, 0);
QVRPotPositionWidget = new vctQtWidgetDynamicVectorDoubleRead();
gridLayout->addWidget(QVRPotPositionWidget, row, 1);
row++;
gridLayout->addWidget(new QLabel("Amp temperature (C)"), row, 0);
QVRActuatorAmpTemperature = new vctQtWidgetDynamicVectorDoubleRead();
gridLayout->addWidget(QVRActuatorAmpTemperature, row, 1);
row++;
}
if (NumberOfBrakes != 0) {
vctBoolVec defaultEnable(NumberOfBrakes, false);
gridLayout->addWidget(new QLabel("Brakes"), row, 0);
QHBoxLayout * brakeButtonsLayout = new QHBoxLayout();
QPBBrakeRelease = new QPushButton("Release");
brakeButtonsLayout->addWidget(QPBBrakeRelease);
QPBBrakeEngage = new QPushButton("Engage");
brakeButtonsLayout->addWidget(QPBBrakeEngage);
gridLayout->addLayout(brakeButtonsLayout, row, 1);
row++;
gridLayout->addWidget(new QLabel("Brake power"), row, 0);
QVWBrakeCurrentEnableEachWidget = new vctQtWidgetDynamicVectorBoolWrite();
QVWBrakeCurrentEnableEachWidget->SetValue(defaultEnable);
gridLayout->addWidget(QVWBrakeCurrentEnableEachWidget, row, 1);
row++;
gridLayout->addWidget(new QLabel("Current desired (mA)"), row, 0);
QVRBrakeCurrentCommandWidget = new vctQtWidgetDynamicVectorDoubleRead();
gridLayout->addWidget(QVRBrakeCurrentCommandWidget, row, 1);
row++;
gridLayout->addWidget(new QLabel("Current feedback (mA)"), row, 0);
QVRBrakeCurrentFeedbackWidget = new vctQtWidgetDynamicVectorDoubleRead();
gridLayout->addWidget(QVRBrakeCurrentFeedbackWidget, row, 1);
row++;
gridLayout->addWidget(new QLabel("Amp temperature (C)"), row, 0);
QVRBrakeAmpTemperature = new vctQtWidgetDynamicVectorDoubleRead();
gridLayout->addWidget(QVRBrakeAmpTemperature, row, 1);
row++;
}
// main layout
QVBoxLayout * mainLayout = new QVBoxLayout;
mainLayout->addLayout(commandLayout);
mainLayout->addLayout(gridLayout);
mainLayout->addStretch();
setLayout(mainLayout);
setWindowTitle(QString(this->GetName().c_str()));
resize(sizeHint());
// connect signals & slots
connect(QCBEnableAmps, SIGNAL(toggled(bool)), this, SLOT(SlotEnableAmps(bool)));
connect(QCBEnableAll, SIGNAL(toggled(bool)), this, SLOT(SlotEnableAll(bool)));
connect(QCBEnableDirectControl, SIGNAL(toggled(bool)), this, SLOT(SlotEnableDirectControl(bool)));
connect(QPBResetCurrentAll, SIGNAL(clicked()), this, SLOT(SlotResetCurrentAll()));
connect(QPBResetEncAll, SIGNAL(clicked()), this, SLOT(SlotResetEncodersAll()));
connect(QPBBiasEncAll, SIGNAL(clicked()), this, SLOT(SlotBiasEncodersAll()));
connect(QSBWatchdogPeriod, SIGNAL(valueChanged(double)),
this, SLOT(SlotWatchdogPeriod(double)));
connect(QVWActuatorCurrentEnableEachWidget, SIGNAL(valueChanged()), this, SLOT(SlotActuatorAmpEnable()));
connect(QVWActuatorCurrentSpinBoxWidget, SIGNAL(valueChanged()), this, SLOT(SlotActuatorCurrentValueChanged()));
connect(QVWActuatorCurrentSliderWidget, SIGNAL(valueChanged()), this, SLOT(SlotSliderActuatorCurrentValueChanged()));
if (NumberOfBrakes != 0) {
connect(QPBBrakeRelease, SIGNAL(clicked()), this, SLOT(SlotBrakeRelease()));
connect(QPBBrakeEngage, SIGNAL(clicked()), this, SLOT(SlotBrakeEngage()));
connect(QVWBrakeCurrentEnableEachWidget, SIGNAL(valueChanged()), this, SLOT(SlotBrakeAmpEnable()));
}
// connect cisstMultiTask events
connect(this, SIGNAL(SignalPowerStatus(bool)), this, SLOT(SlotPowerStatus(bool)));
connect(this, SIGNAL(SignalWatchdogStatus(bool)), this, SLOT(SlotWatchdogStatus(bool)));
// set initial value
QCBEnableAmps->setChecked(false);
QCBEnableAll->setChecked(false);
QCBEnableDirectControl->setChecked(DirectControl);
SlotEnableDirectControl(DirectControl);
}
int main(int argc, char * argv[])
{
if (argc != 2) {
std::cerr << "Usage: " << argv[0] << " GlobalManagerIP" << std::endl;
exit(-1);
}
//*
// before we start, estimate overhead related to serialization and de-serialization of parameters
osaTimeServer timeServer;
std::stringstream serializationStream;
cmnSerializer serialization(serializationStream);
cmnDeSerializer deSerialization(serializationStream);
unsigned int index;
prmPositionCartesianGet parameter;
cmnGenericObject * generated;
timeServer.SetTimeOrigin();
for (index = 0; index < confNumberOfSamples; index++) {
serialization.Serialize(parameter);
generated = deSerialization.DeSerialize();
if (generated->Services() != parameter.Services()) {
std::cout << "Serialization test failed!" << std::endl;
exit(0);
}
// delete generated object created by de-serialization
delete generated;
}
double elapsedTime = timeServer.GetRelativeTime();
std::cout << std::endl << std::endl
<< "Serialization, dynamic creation and deserialization time for "
<< confNumberOfSamples << " samples of " << parameter.Services()->GetName()
<< ": " << cmnInternalTo_ms(elapsedTime) << " (ms)" << std::endl
<< "Per sample: " << cmnInternalTo_ms(elapsedTime / confNumberOfSamples) << " (ms)" << std::endl
<< std::endl << std::endl;
//*/
// networking part
std::string globalTaskManagerIP(argv[1]);
// Log configuration
cmnLogger::SetMask(CMN_LOG_ALLOW_ERRORS_AND_WARNINGS);
cmnLogger::SetMaskFunction(CMN_LOG_ALLOW_ERRORS_AND_WARNINGS);
// create our server task
clientTask * client = new clientTask("Client", confClientPeriod);
// Get the TaskManager instance and set operation mode
mtsTaskManager * taskManager = mtsTaskManager::GetInstance();
taskManager->AddComponent(client);
// Connect the tasks across networks
taskManager->Connect("Client", "Required", "Server", "Provided");
// create the tasks, i.e. find the commands
taskManager->CreateAll();
// start the periodic Run
taskManager->StartAll();
// run while the benchmarks are not over
while (!(client->IsBenchmarkCompleted())) {
osaSleep(10.0 * cmn_ms);
}
// cleanup
taskManager->Cleanup();
taskManager->KillAll();
// To prevent crash due to CMN_LOG_CLASS (cmnLODOutputMultiplexer).
osaSleep(0.5 * cmn_s);
return 0;
}
